MEM_guardedalloc.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#ifndef __MEM_GUARDEDALLOC_H__
#define __MEM_GUARDEDALLOC_H__
 
/* Needed for uintptr_t and attributes, exception, don't use BLI anywhere else in `MEM_*` */
#include "../../source/blender/blenlib/BLI_compiler_attrs.h"
#include "../../source/blender/blenlib/BLI_sys_types.h"
 
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* -------------------------------------------------------------------- */

extern size_t (*MEM_allocN_len)(const void *vmemh) ATTR_WARN_UNUSED_RESULT;

void MEM_freeN(void *vmemh);
 
#if 0 /* UNUSED */
extern short (*MEM_testN)(void *vmemh);
#endif

void *MEM_dupallocN(const void *vmemh) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT;

extern void *(*MEM_reallocN_id)(void *vmemh,
                                size_t len,
                                const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(2);

extern void *(*MEM_recallocN_id)(void *vmemh,
                                 size_t len,
                                 const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(2);
 
#define MEM_reallocN(vmemh, len) MEM_reallocN_id(vmemh, len, __func__)
#define MEM_recallocN(vmemh, len) MEM_recallocN_id(vmemh, len, __func__)

void *MEM_callocN(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1)
    ATTR_NONNULL(2);

void *MEM_calloc_arrayN(size_t len,
                        size_t size,
                        const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);

void *MEM_mallocN(size_t len, const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);

void *MEM_malloc_arrayN(size_t len,
                        size_t size,
                        const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);

void *MEM_mallocN_aligned(size_t len,
                          size_t alignment,
                          const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT
    ATTR_ALLOC_SIZE(1) ATTR_NONNULL(3);

extern void *(*MEM_malloc_arrayN_aligned)(
    size_t len,
    size_t size,
    size_t alignment,
    const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1, 2)
    ATTR_NONNULL(4);

extern void *(*MEM_calloc_arrayN_aligned)(
    size_t len,
    size_t size,
    size_t alignment,
    const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1, 2)
    ATTR_NONNULL(4);
 
#ifdef __cplusplus
#  define MEM_SAFE_FREE(v) \
    do { \
      if (v) { \
        MEM_freeN(v); \
        (v) = nullptr; \
      } \
    } while (0)

struct MEM_freeN_smart_ptr_deleter {
  void operator()(void *pointer) const noexcept
  {
    MEM_SAFE_FREE(pointer);
  }
};
 
#else
#  define MEM_SAFE_FREE(v) \
    do { \
      void **_v = (void **)&(v); \
      if (*_v) { \
        MEM_freeN(*_v); \
        *_v = NULL; \
      } \
    } while (0)
#endif

 
/* -------------------------------------------------------------------- */

extern void (*MEM_printmemlist_pydict)(void);

extern void (*MEM_printmemlist)(void);

extern void (*MEM_callbackmemlist)(void (*func)(void *));

extern void (*MEM_printmemlist_stats)(void);

extern void (*MEM_set_error_callback)(void (*func)(const char *));

extern bool (*MEM_consistency_check)(void);

extern void (*MEM_set_memory_debug)(void);

extern size_t (*MEM_get_memory_in_use)(void);
extern unsigned int (*MEM_get_memory_blocks_in_use)(void);

extern void (*MEM_reset_peak_memory)(void);

extern size_t (*MEM_get_peak_memory)(void) ATTR_WARN_UNUSED_RESULT;

#define MEM_SIZE_OVERHEAD sizeof(size_t)
#define MEM_SIZE_OPTIMAL(size) ((size) - MEM_SIZE_OVERHEAD)
 
#ifndef NDEBUG
extern const char *(*MEM_name_ptr)(void *vmemh);
extern void (*MEM_name_ptr_set)(void *vmemh, const char *str) ATTR_NONNULL();
#endif

void MEM_init_memleak_detection(void);

void MEM_enable_fail_on_memleak(void);

void MEM_use_lockfree_allocator(void);

void MEM_use_guarded_allocator(void);

 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#ifdef __cplusplus
 
#  include <any>
#  include <memory>
#  include <new>
#  include <type_traits>
#  include <utility>
 
#  include "intern/mallocn_intern_function_pointers.hh"

#  define MEM_MIN_CPP_ALIGNMENT \
    (__STDCPP_DEFAULT_NEW_ALIGNMENT__ < alignof(void *) ? __STDCPP_DEFAULT_NEW_ALIGNMENT__ : \
                                                          alignof(void *))
 
/* -------------------------------------------------------------------- */
 
namespace mem_guarded::internal {
/* Note that we intentionally don't care about a non-trivial default constructor here. */
template<typename T>
constexpr bool is_trivial_after_construction = std::is_trivially_copyable_v<T> &&
                                               std::is_trivially_destructible_v<T>;
}  // namespace mem_guarded::internal

template<typename T, typename... Args>
inline T *MEM_new(const char *allocation_name, Args &&...args)
{
  void *buffer = mem_guarded::internal::mem_mallocN_aligned_ex(
      sizeof(T), alignof(T), allocation_name, mem_guarded::internal::AllocationType::NEW_DELETE);
  return new (buffer) T(std::forward<Args>(args)...);
}

template<typename T> inline T *MEM_new_for_free(const char *allocation_name)
{
  static_assert(mem_guarded::internal::is_trivial_after_construction<T>,
                "MEM_new_for_free can only construct types that are trivially copyable and "
                "destructible, use MEM_new instead.");
  void *buffer;
  /* There is no lower level #calloc with an alignment parameter, so unless the alignment is less
   * than or equal to what we'd get by default, we have to fall back to #memset unfortunately. */
  if (alignof(T) <= MEM_MIN_CPP_ALIGNMENT) {
    buffer = MEM_callocN(sizeof(T), allocation_name);
  }
  else {
    buffer = mem_guarded::internal::mem_mallocN_aligned_ex(
        sizeof(T), alignof(T), allocation_name, mem_guarded::internal::AllocationType::ALLOC_FREE);
    memset(buffer, 0, sizeof(T));
  }
  return new (buffer) T;
}

template<typename T> inline void MEM_delete(const T *ptr)
{
  static_assert(
      !std::is_void_v<T>,
      "MEM_delete on a void pointer is not possible, `static_cast` it to the correct type");
  if (ptr == nullptr) {
    return;
  }
  const void *complete_ptr = [ptr]() {
    if constexpr (std::is_polymorphic_v<T>) {
      /* Polymorphic objects lifetime can be managed with pointers to their most derived type or
       * with pointers to any of their ancestor types in their hierarchy tree that define a virtual
       * destructor, however ancestor pointers may differ in a offset from the same derived object.
       * For freeing the correct memory allocated with #MEM_new, we need to ensure that the given
       * pointer is equal to the pointer to the most derived object, which can be obtained with
       * `dynamic_cast<void *>(ptr)`. */
      return dynamic_cast<const void *>(ptr);
    }
    else {
      return static_cast<const void *>(ptr);
    }
  }();
  /* C++ allows destruction of `const` objects, so the pointer is allowed to be `const`. */
  ptr->~T();
  mem_guarded::internal::mem_freeN_ex(const_cast<void *>(complete_ptr),
                                      mem_guarded::internal::AllocationType::NEW_DELETE);
}

#  define MEM_SAFE_DELETE(v) \
    do { \
      if (v) { \
        MEM_delete(v); \
        (v) = nullptr; \
      } \
    } while (0)

#  define MEM_CXX_CLASS_ALLOC_FUNCS(_id) \
   public: \
    void *operator new(size_t num_bytes) \
    { \
      return mem_guarded::internal::mem_mallocN_aligned_ex( \
          num_bytes, \
          __STDCPP_DEFAULT_NEW_ALIGNMENT__, \
          _id, \
          mem_guarded::internal::AllocationType::NEW_DELETE); \
    } \
    void *operator new(size_t num_bytes, std::align_val_t alignment) \
    { \
      return mem_guarded::internal::mem_mallocN_aligned_ex( \
          num_bytes, size_t(alignment), _id, mem_guarded::internal::AllocationType::NEW_DELETE); \
    } \
    void operator delete(void *mem) \
    { \
      if (mem) { \
        mem_guarded::internal::mem_freeN_ex(mem, \
                                            mem_guarded::internal::AllocationType::NEW_DELETE); \
      } \
    } \
    void *operator new[](size_t num_bytes) \
    { \
      return mem_guarded::internal::mem_mallocN_aligned_ex( \
          num_bytes, \
          __STDCPP_DEFAULT_NEW_ALIGNMENT__, \
          _id "[]", \
          mem_guarded::internal::AllocationType::NEW_DELETE); \
    } \
    void *operator new[](size_t num_bytes, std::align_val_t alignment) \
    { \
      return mem_guarded::internal::mem_mallocN_aligned_ex( \
          num_bytes, \
          size_t(alignment), \
          _id "[]", \
          mem_guarded::internal::AllocationType::NEW_DELETE); \
    } \
    void operator delete[](void *mem) \
    { \
      if (mem) { \
        mem_guarded::internal::mem_freeN_ex(mem, \
                                            mem_guarded::internal::AllocationType::NEW_DELETE); \
      } \
    } \
    void *operator new(size_t /*count*/, void *ptr) \
    { \
      return ptr; \
    } \
 \
    void operator delete(void * /*ptr_to_free*/, void * /*ptr*/) {}

 
/* -------------------------------------------------------------------- */

template<typename T> inline T *MEM_callocN(const char *allocation_name)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_constructible_v<T>,
                "For non-trivial types, MEM_new must be used.");
#  else
  static_assert(std::is_trivial_v<T>, "For non-trivial types, MEM_new must be used.");
#  endif
  return static_cast<T *>(MEM_calloc_arrayN_aligned(1, sizeof(T), alignof(T), allocation_name));
}

template<typename T> inline T *MEM_calloc_arrayN(const size_t length, const char *allocation_name)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_constructible_v<T>,
                "For non-trivial types, MEM_new must be used.");
#  else
  static_assert(std::is_trivial_v<T>, "For non-trivial types, MEM_new must be used.");
#  endif
  return static_cast<T *>(
      MEM_calloc_arrayN_aligned(length, sizeof(T), alignof(T), allocation_name));
}

template<typename T> inline T *MEM_mallocN(const char *allocation_name)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_constructible_v<T>,
                "For non-trivial types, MEM_new must be used.");
#  else
  static_assert(std::is_trivial_v<T>, "For non-trivial types, MEM_new must be used.");
#  endif
  return static_cast<T *>(MEM_malloc_arrayN_aligned(1, sizeof(T), alignof(T), allocation_name));
}

template<typename T> inline T *MEM_malloc_arrayN(const size_t length, const char *allocation_name)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_constructible_v<T>,
                "For non-trivial types, MEM_new must be used.");
#  else
  static_assert(std::is_trivial_v<T>, "For non-trivial types, MEM_new must be used.");
#  endif
  return static_cast<T *>(
      MEM_malloc_arrayN_aligned(length, sizeof(T), alignof(T), allocation_name));
}

template<typename T> inline T *MEM_dupallocN(const char *allocation_name, const T &other)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_assignable_v<T &, T> && std::is_trivially_destructible_v<T>,
                "MEM_dupallocN can only duplicate types that are trivially copyable and "
                "destructible, use MEM_new instead.");
#  else
  static_assert(mem_guarded::internal::is_trivial_after_construction<T>,
                "MEM_dupallocN can only duplicate types that are trivially copyable and "
                "destructible, use MEM_new instead.");
#  endif
  T *new_object = static_cast<T *>(MEM_mallocN_aligned(sizeof(T), alignof(T), allocation_name));
  if (new_object) {
    memcpy(new_object, &other, sizeof(T));
  }
  return new_object;
}
 
template<typename T> inline void MEM_freeN(T *ptr)
{
#  ifdef _MSC_VER
  static_assert(std::is_trivially_destructible_v<T>,
                "MEM_freeN can only free types that are trivially copyable and destructible, use "
                "MEM_delete instead.");
#  else
  static_assert(mem_guarded::internal::is_trivial_after_construction<T>,
                "MEM_freeN can only free types that are trivially copyable and destructible, use "
                "MEM_delete instead.");
#  endif
  mem_guarded::internal::mem_freeN_ex(const_cast<void *>(static_cast<const void *>(ptr)),
                                      mem_guarded::internal::AllocationType::ALLOC_FREE);
}


template<typename T, typename... Args> T &MEM_construct_leak_detection_data(Args &&...args)
{
  std::shared_ptr<T> data = std::make_shared<T>(std::forward<Args>(args)...);
  std::any any_data = std::make_any<std::shared_ptr<T>>(data);
  mem_guarded::internal::add_memleak_data(any_data);
  return *data;
}
 
#endif /* __cplusplus */
 
#endif /* __MEM_GUARDEDALLOC_H__ */