Refactor: Cycles: Simplify util_guarded_mem_alloc/free calls

Pull Request: https://projects.blender.org/blender/blender/pulls/132912

intern/cycles/device/cpu/device_impl.cpp

@@ -166,7 +166,7 @@ void CPUDevice::mem_free(device_memory &mem)
   }
   else if (mem.device_pointer) {
     if (mem.type == MEM_DEVICE_ONLY || !mem.host_pointer) {
-      util_aligned_free((void *)mem.device_pointer);
+      util_aligned_free((void *)mem.device_pointer, mem.memory_size());
     }
     mem.device_pointer = 0;
     stats.mem_free(mem.device_size);

intern/cycles/device/memory.cpp

@@ -47,10 +47,7 @@ void *device_memory::host_alloc(const size_t size)
 
   void *ptr = util_aligned_malloc(size, MIN_ALIGNMENT_CPU_DATA_TYPES);
 
-  if (ptr) {
-    util_guarded_mem_alloc(size);
-  }
-  else {
+  if (ptr == nullptr) {
     throw std::bad_alloc();
   }
 
@@ -60,8 +57,7 @@ void *device_memory::host_alloc(const size_t size)
 void device_memory::host_free()
 {
   if (host_pointer) {
-    util_guarded_mem_free(memory_size());
-    util_aligned_free(host_pointer);
+    util_aligned_free(host_pointer, memory_size());
     host_pointer = nullptr;
   }
 }

intern/cycles/test/util_aligned_malloc_test.cpp

@@ -14,7 +14,7 @@ TEST(util_aligned_malloc, aligned_malloc_16)
 {
   int *mem = (int *)util_aligned_malloc(sizeof(int), 16);
   CHECK_ALIGNMENT(mem, 16);
-  util_aligned_free(mem);
+  util_aligned_free(mem, sizeof(int));
 }
 
 /* On Apple we currently only support 16 bytes alignment. */
@@ -23,7 +23,7 @@ TEST(util_aligned_malloc, aligned_malloc_32)
 {
   int *mem = (int *)util_aligned_malloc(sizeof(int), 32);
   CHECK_ALIGNMENT(mem, 32);
-  util_aligned_free(mem);
+  util_aligned_free(mem, sizeof(int));
 }
 #endif /* __APPLE__ */
 

intern/cycles/util/aligned_malloc.cpp

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0 */
 
 #include "util/aligned_malloc.h"
+#include "util/guarded_allocator.h"
 
 #ifdef WITH_BLENDER_GUARDEDALLOC
 #  include "../../guardedalloc/MEM_guardedalloc.h"
@@ -33,26 +34,31 @@ CCL_NAMESPACE_BEGIN
 
 void *util_aligned_malloc(const size_t size, const int alignment)
 {
+  void *mem = nullptr;
 #ifdef WITH_BLENDER_GUARDEDALLOC
-  return MEM_mallocN_aligned(size, alignment, "Cycles Aligned Alloc");
+  mem = MEM_mallocN_aligned(size, alignment, "Cycles Aligned Alloc");
 #elif defined(_WIN32)
-  return _aligned_malloc(size, alignment);
+  mem = _aligned_malloc(size, alignment);
 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-  void *result;
-  if (posix_memalign(&result, alignment, size)) {
+  if (posix_memalign(&mem, alignment, size)) {
     /* Non-zero means allocation error
-     * either no allocation or bad alignment value.
-     */
-    return nullptr;
+     * either no allocation or bad alignment value. */
+    mem = nullptr;
   }
-  return result;
 #else /* This is for Linux. */
-  return memalign(alignment, size);
+  mem = memalign(alignment, size);
 #endif
+  if (mem) {
+    util_guarded_mem_alloc(size);
+  }
+  return mem;
 }
 
-void util_aligned_free(void *ptr)
+void util_aligned_free(void *ptr, const size_t size)
 {
+  if (ptr) {
+    util_guarded_mem_free(size);
+  }
 #if defined(WITH_BLENDER_GUARDEDALLOC)
   if (ptr != nullptr) {
     MEM_freeN(ptr);

intern/cycles/util/aligned_malloc.h

@@ -15,7 +15,7 @@ CCL_NAMESPACE_BEGIN
 void *util_aligned_malloc(const size_t size, const int alignment);
 
 /* Free memory allocated by util_aligned_malloc. */
-void util_aligned_free(void *ptr);
+void util_aligned_free(void *ptr, const size_t size);
 
 /* Aligned new operator. */
 template<typename T, typename... Args> T *util_aligned_new(Args... args)
@@ -28,7 +28,7 @@ template<typename T> void util_aligned_delete(T *t)
 {
   if (t) {
     t->~T();
-    util_aligned_free(t);
+    util_aligned_free(t, sizeof(T));
   }
 }
 

intern/cycles/util/array.h

@@ -274,10 +274,7 @@ template<typename T, const size_t alignment = MIN_ALIGNMENT_CPU_DATA_TYPES> clas
       return nullptr;
     }
     T *mem = (T *)util_aligned_malloc(sizeof(T) * N, alignment);
-    if (mem != nullptr) {
-      util_guarded_mem_alloc(sizeof(T) * N);
-    }
-    else {
+    if (mem == nullptr) {
       throw std::bad_alloc();
     }
     return mem;
@@ -286,8 +283,7 @@ template<typename T, const size_t alignment = MIN_ALIGNMENT_CPU_DATA_TYPES> clas
   void mem_free(T *mem, const size_t N)
   {
     if (mem != nullptr) {
-      util_guarded_mem_free(sizeof(T) * N);
-      util_aligned_free(mem);
+      util_aligned_free(mem, sizeof(T) * N);
     }
   }