Blender内存管理库(bf_intern_guardedalloc)

Blender内部定义了自己内存泄漏检测机制，同时提供了了二套实现机制，函数整合于于bf_intern_guardedalloc库中：

mallocn_lockfree_impl.c和mallocn_guarded_impl.c分别实现了这二套内存分配机制，头文件定义于MEM_guardedalloc.h中，为方便实现二种机制的切换，函数头使用的是函数指针方式，以便于动态切换。

mallocn_lockfree_impl.c中的实现用于正常工作模式，mallocn_guarded_impl.c的实现用于调试模式，提供更多信息，更方便定位内存问题。

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.
");
        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
",
              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
", (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 */
}

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