Blender内存管理库(bf_intern_guardedalloc)

Blender项目主要由c/C++编写的，模块较多，规模很大。由于C/C++语言很容易出现内存泄漏，为此Blender在底层代码中提供了内存泄漏检测机制，方便在需要时进入调试模式报告内存泄漏。

为实现内存泄漏检测，必须在内存分配时做些额外的记录，为此，提供了一组函数替换c/c++语言原生的内存分配函数。

 

额外的内存泄漏检测必然将影响程序的工作性能，解决的办法是，Blender提供了二组内存分配方法，一套提供额外的内存泄漏检测，用于调试，便于发现内存问题，一套用于正式工作，不影响性能。

为便于二套内存分配方法切换，Blender定义了一组内存分配指针函数，替换c/C++语言原生的内存分配函数来实现内存泄漏检测功能，代码(位于mallocn.c文件中)如下：

查看代码

/* NOTE: Keep in sync with MEM_use_lockfree_allocator(). */
size_t (*MEM_allocN_len)(const void *vmemh) = MEM_lockfree_allocN_len;
void (*MEM_freeN)(void *vmemh) = MEM_lockfree_freeN;
void *(*MEM_dupallocN)(const void *vmemh) = MEM_lockfree_dupallocN;
void *(*MEM_reallocN_id)(void *vmemh, size_t len, const char *str) = MEM_lockfree_reallocN_id;
void *(*MEM_recallocN_id)(void *vmemh, size_t len, const char *str) = MEM_lockfree_recallocN_id;
void *(*MEM_callocN)(size_t len, const char *str) = MEM_lockfree_callocN;
void *(*MEM_calloc_arrayN)(size_t len, size_t size, const char *str) = MEM_lockfree_calloc_arrayN;
void *(*MEM_mallocN)(size_t len, const char *str) = MEM_lockfree_mallocN;
void *(*MEM_malloc_arrayN)(size_t len, size_t size, const char *str) = MEM_lockfree_malloc_arrayN;
void *(*MEM_mallocN_aligned)(size_t len,
                             size_t alignment,
                             const char *str) = MEM_lockfree_mallocN_aligned;
void (*MEM_printmemlist_pydict)(void) = MEM_lockfree_printmemlist_pydict;
void (*MEM_printmemlist)(void) = MEM_lockfree_printmemlist;
void (*MEM_callbackmemlist)(void (*func)(void *)) = MEM_lockfree_callbackmemlist;
void (*MEM_printmemlist_stats)(void) = MEM_lockfree_printmemlist_stats;
void (*MEM_set_error_callback)(void (*func)(const char *)) = MEM_lockfree_set_error_callback;
bool (*MEM_consistency_check)(void) = MEM_lockfree_consistency_check;
void (*MEM_set_memory_debug)(void) = MEM_lockfree_set_memory_debug;
size_t (*MEM_get_memory_in_use)(void) = MEM_lockfree_get_memory_in_use;
unsigned int (*MEM_get_memory_blocks_in_use)(void) = MEM_lockfree_get_memory_blocks_in_use;
void (*MEM_reset_peak_memory)(void) = MEM_lockfree_reset_peak_memory;
size_t (*MEM_get_peak_memory)(void) = MEM_lockfree_get_peak_memory;

#ifndef NDEBUG
const char *(*MEM_name_ptr)(void *vmemh) = MEM_lockfree_name_ptr;
#endif

MEM_guardedalloc.h中定义了相关内存分配函数，均为指针函数，通过指针函数赋值，来实现二种机制的切换。二套函数具体实现分别们于mallocn_lockfree_impl.c和mallocn_guarded_impl.c文件中，整合在bf_intern_guardedalloc静态库中。

mallocn.c中实现函数指针被赋值，默认使用mallocn_lockfree_impl.c中的函数，如果需要使用mallocn_guarded_impl.c中的函数，只需要调用MEM_use_guarded_allocator函数，实现二套机制的切换。

在blender主程序文件中createor.c中提供了选择，仅当运行参数中包含调试选项时时使用保护(guarded)模式内存分配，以方便理准确定位内存问题

/* NOTE: Special exception for guarded allocator type switch:
   *       we need to perform switch from lock-free to fully
   *       guarded allocator before any allocation happened.
   */
  {
    int i;
    for (i = 0; i < argc; i++) {
      if (STR_ELEM(argv[i], "-d", "--debug", "--debug-memory", "--debug-all")) {
        printf("Switching to fully guarded memory allocator.\n");
        MEM_use_guarded_allocator();
        break;
      }
      else if (STREQ(argv[i], "--")) {
        break;
      }
    }
    MEM_initialize_memleak_detection();
  }

 

 同时在第17行调用MEM_initialize_memleak_detection()函数实例化MemLeakPrinter（leak_detector.cc中定义）类到静态变量中，用于初始内存泄漏检测。该类只定义了析构函数，因此在程序结束时自动释放时调用析构函数，实现打印内存泄漏信息。也就无需主动调用，正发布版程序中也无需处理，不用担心性能。

 

例如：MEM_guardedalloc.h中定义的函数指针：extern void *(*MEM_callocN)(size_t len, const char *str) ，在mallocn.c中将它赋值

void *(*MEM_callocN)(size_t len, const char *str) = MEM_guarded_callocN;

MME_lockfree_callocN函数定义于mallocn_guarded_impl.c文件中，如下： 

 

void *MEM_guarded_mallocN(size_t len, const char *str)
{
  MemHead *memh;

  len = SIZET_ALIGN_4(len);

  memh = (MemHead *)malloc(len + sizeof(MemHead) + sizeof(MemTail));

  if (LIKELY(memh)) {
    make_memhead_header(memh, len, str);
    if (UNLIKELY(malloc_debug_memset && len)) {
      memset(memh + 1, 255, len);
    }

#ifdef DEBUG_MEMCOUNTER
    if (_mallocn_count == DEBUG_MEMCOUNTER_ERROR_VAL)
      memcount_raise(__func__);
    memh->_count = _mallocn_count++;
#endif
    return (++memh);
  }
  print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
              SIZET_ARG(len),
              str,
              (unsigned int)mem_in_use);
  return NULL;
}

 

 

 

通过代码分析可知，内存分配的保护措施就是，在请求分配内存块时，在前面额外增加了一个MemHead和MemTail，它存储了请求的内存块大小，同时更新totblock,mem_in_use,peak_mem三个与内存保护相关变量

以下是Mem_freeN指向的函数MEM_gurded_freeN（它与Mem_allocN相对应，用于释放内存）

void MEM_guarded_freeN(void *vmemh)
{
  MemTail *memt;
  MemHead *memh = vmemh;
  const char *name;

  if (memh == NULL) {
    MemorY_ErroR("free", "attempt to free NULL pointer");
    /* print_error(err_stream, "%d\n", (memh+4000)->tag1); */
    return;
  }

  if (sizeof(intptr_t) == 8) {
    if (((intptr_t)memh) & 0x7) {
      MemorY_ErroR("free", "attempt to free illegal pointer");
      return;
    }
  }
  else {
    if (((intptr_t)memh) & 0x3) {
      MemorY_ErroR("free", "attempt to free illegal pointer");
      return;
    }
  }

  memh--;
  if (memh->tag1 == MEMFREE && memh->tag2 == MEMFREE) {
    MemorY_ErroR(memh->name, "double free");
    return;
  }

  if ((memh->tag1 == MEMTAG1) && (memh->tag2 == MEMTAG2) && ((memh->len & 0x3) == 0)) {
    memt = (MemTail *)(((char *)memh) + sizeof(MemHead) + memh->len);
    if (memt->tag3 == MEMTAG3) {

      if (leak_detector_has_run) {
        MemorY_ErroR(memh->name, free_after_leak_detection_message);
      }

      memh->tag1 = MEMFREE;
      memh->tag2 = MEMFREE;
      memt->tag3 = MEMFREE;
      /* after tags !!! */
      rem_memblock(memh);

      return;
    }
    MemorY_ErroR(memh->name, "end corrupt");
    name = check_memlist(memh);
    if (name != NULL) {
      if (name != memh->name) {
        MemorY_ErroR(name, "is also corrupt");
      }
    }
  }
  else {
    mem_lock_thread();
    name = check_memlist(memh);
    mem_unlock_thread();
    if (name == NULL) {
      MemorY_ErroR("free", "pointer not in memlist");
    }
    else {
      MemorY_ErroR(name, "error in header");
    }
  }

  totblock--;
  /* here a DUMP should happen */
}

 

只要通过该库中函数分配的内存就能通过设置启动参数，在程序结束时显示内存泄漏等相关情况。