caffe1源码解析从入门到放弃1）：内存管理syncedmem.hpp / syncedmem.cpp

/*这些代码都是本人在linux-nsight-eclipse环境下纯手打。
  文章结尾都会抛出一些本人尚未解决的问题，欢迎各路大神拍砖。
  文章属于学习交流性质，随着本人学力的提升，此blog将会长期修正更新。
 * syncedmem.hpp
 *  Created on: Jun 4, 2017
 *      Author: pan
 */
#ifndef SYNCEDMEM_HPP_
#define SYNCEDMEM_HPP_
#include <cstdlib>
#include "caffe/common.hpp"
/*定义了caffe名称空间，内部封装了caffe所有的类和方法，
 * eg:using namespace caffe / using namespace std*/
namespace caffe
{
  // If CUDA is available and in GPU mode, host memory will be allocated pinned,
  // using cudaMallocHost. It avoids dynamic pinning for transfers (DMA).
  // The improvement in performance seems negligible in the single GPU case,
  // but might be more significant for parallel training. Most importantly,
  // it improved stability for large models on many GPUs.
  /*如果主机支持CUDA并且工作在GPU模式下，主机内存将会 allocated（分配） pinned, 使用cudaMallocHost().
   * 它避免了dynamic pinning for transfers (DMA).在单GPU情况下使用cudaMallocHost()，这个操作在性能
   * 上的提高看起来几乎可以忽视。但是在多GPU并行训练的情况下，cudaMallocHost()可能会显的更重要。最重要的是，
   * cudaMallocHost()的使用提高了在多GPU环境下大模型的稳定性。
   * caffe工作在GPU模式下使用cudaMallocHost()在主机上分配内存将会比使用malloc()方法有性能和稳定性的提高。
   */
  /*在主机上分配内存，CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);方法使用二级指针
  cpu_ptr_分配内存*/
  inline void CaffeMallocHost(void** ptr, size_t size, bool* use_cuda)
  {
  #ifndef CPU_ONLY
    if(Caffe::mode() == Caffe::GPU)
    {
    CUDA_CHECK(cudaMallocHost(ptr, size));//*****************
        *use_cuda = true;
        return ;//在void类型的函数中，return用于返回空，不是返回 0 值
    }
  #endif
    /*这里分配了size个字节的内存，由于使用的是void*最后要强制类型转换成特定类型的
     * 指针eg: static_cast<int*> cpu_ptr_ 。这点在Blob中会详细陈述*/
    *ptr = malloc(size);
    *use_cuda = false;
    CHECK(*ptr)<<"host allocation of size "<< size <<" failed";//**********************
  }
  /*内存释放方法，由于在cuda环境下有两种主机分配内存的方法，所以在这里做了一个宏定义处理，分别是
  cudaFreeHost（）和 free()*/
  inline void CaffeFreeHost(void* ptr, bool use_cuda)
  {
  #ifndef CPU_ONLY
    if(use_cuda)
    {
    CUDA_CHECK(cudaFreeHost(ptr));//***************
    return ;
    }
  #endif
    free(ptr);
  }
  /**
   * @brief Manages memory allocation and synchronization between the host (CPU)
   *        and device (GPU).
   *
   * TODO(dox): more thorough description.
   */
  /*
   *SyncedMemory类 @简单的用于在主机（CPU）和 设备（GPU）之间进行内存分配和同步工作，也就是说在CPU和GPU
   *之间管理内存。
   *TODO(dox): more thorough description.
   * */
  class SyncedMemory
  {
  public:
    /*构造函数将初始化各种指针*/
    SyncedMemory()
         : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(0), head_(UNINITIALIZED),
           own_cpu_data_(false), cpu_malloc_use_cuda_(false),own_gpu_data_(false),
           gpu_device_(-1){}
    /*构造函数将初始化各种指针
     * explicit 表示构造函数不接受隐式转换 eg:  ********************/
    explicit SyncedMemory(size_t size) : cpu_ptr_(NULL), gpu_ptr_(NULL), size_(size),
    head_(UNINITIALIZED), own_cpu_data_(false), cpu_malloc_use_cuda_(false),
    own_gpu_data_(false), gpu_device_(-1){}
    /*析构函数中定义了释放堆区内存的操作，在caffe的数据容器Blob中，定义了shared_ptr<syncedmemory> data_
     * 定义了shared_ptr<syncedmemory> diff_ 的智能指针，通过reset方法控制内存的释放。由于nvcc编译器
     * 对C++11支持的不好，暂且不能够使用unique_ptr智能指针，目前只能调用boost库的shared_ptr*/
   ~SyncedMemory(){};

  public:
   /*cpu_data()和gpu_data()返回值为const void* 表示cpu_ptr_和gpu_ptr_所指向的内存空间不允许被修改
    * 与此相反void* mutable_cpu_data() 和 void* mutable_gpu_data(); 返回的是void* 的指针，也即内存返回的
    * 内存空间是允许修改的*/
   const void* cpu_data();
   void set_cpu_data(void* data);
   const void* gpu_data();
   void set_gpu_data(void* data);
   void* mutable_cpu_data();
   void* mutable_gpu_data();
   /*此处定义了一个枚举类型SyncedHead主要作用是标志头指针状态,其中SYNCED表示内存已经同步*/
   enum SyncedHead {UNINITIALIZED, HEAD_AT_CPU, HEAD_AT_GPU, SYNCED};

   SyncedHead head()  {return head_;}
   //size_t是标准C库中定义的，应为unsigned int，在64位系统中为 long unsigned int
   size_t size()  {return size_;}

  #ifndef CPU_ONLY
    void async_gpu_push(const cudaStream_t& stream);//*****************
  #endif

  private:
   SyncedHead head_;//头指针位置
   /*控制内存同步的方法，如果head在cpu上执行to_cpu（）表示内存已经同步，否则要调用caffe_gpu_memcpy（）方法
    * 实质上调用的是cudaMemcpy(Y, X, N, cudaMemcpyDefault)，caffe_gpu_memcpy（）做了一层封装而已。
    * 同理to_gpu（）*/
   void to_cpu();
   void to_gpu();


   void* cpu_ptr_;
   void* gpu_ptr_;
   size_t size_;

   bool own_cpu_data_;
   bool cpu_malloc_use_cuda_;
   bool own_gpu_data_;
   int gpu_device_;
   DISABLE_COPY_AND_ASSIGN(SyncedMemory);//***************
  };// class SyncedMemory

};//namespace caffe

#endif /* SYNCEDMEM_HPP_ */
---------------------------------------------
---------------------------------------------
---------------------------------------------
/*
 * syncedmem.cpp
 *
 *  Created on: Jun 4, 2017
 *      Author: pan
 */
#include "common.hpp"
#include "syncedmem.hpp"
#include "util/math_functions.hpp"

namespace caffe
{
  SyncedMemory::~SyncedMemory()
  {
    /*cpu_ptr_不为NULL，不能释放NULL指针， own_cpu_data_标志位不为 0这个标志位不知道如何理解 ？？？？？？？？？？？？？？？？？？*/
    if(cpu_ptr_ && own_cpu_data_)
    {
    CaffeFreeHost(cpu_ptr_, cpu_malloc_use_cuda_);
    }
  #ifndef CPU_ONLY
    if(gpu_ptr_ && own_gpu_data_)
    {
      int initial_device;
      cudaGetDevice(&initial_device);
      if (gpu_device_ != -1)
      {
        CUDA_CHECK(cudaSetDevice(gpu_device_));//????????????????
      }
      CUDA_CHECK(cudaFree(gpu_ptr_));
      cudaSetDevice(initial_device);
    }
  #endif

  }
  //同步内存到CPU 即设置cpu_ptr_
  inline void SyncedMemory::to_cpu()
  {
    switch (head_)
    {
      case UNINITIALIZED:
    CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
    caffe_memset(size_, 0, cpu_ptr_);
    head_ = HEAD_AT_CPU;
    own_cpu_data_ = true;
    break;

      case HEAD_AT_GPU:
      #ifndef CPU_ONLY//Makefile.config中定义
    if (cpu_ptr_ == NULL)
    {
        CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
        own_cpu_data_ = true;
    }
    caffe_gpu_memcpy(size_, gpu_ptr_, cpu_ptr_);
    head_ = SYNCED;
      #else
    NO_GPU;//Makefile.config中定义
      #endif
    break;

      case HEAD_AT_CPU://头指针指向CPU内存已经同步
      case SYNCED:
        break;
    }
  }//to_cpu()
  //同步内存到CPU 即设置gpu_ptr_
  inline void SyncedMemory::to_gpu()
  {
  #ifndef CPU_ONLY
    switch (head_)
    {
      case UNINITIALIZED://???????????????????/
        head_ = HEAD_AT_GPU;
        own_gpu_data_ = true;
        break;

      case HEAD_AT_CPU:
    if(gpu_ptr_ == NULL)
    {
          CUDA_CHECK(cudaGetDevice(&gpu_device_));
          CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_));
          own_gpu_data_ = true;
    }
        caffe_gpu_memcpy(size_, cpu_ptr_, gpu_ptr_);
    head_ = SYNCED;
        break;
      case HEAD_AT_GPU:
      case SYNCED:
        break;
    }
  #else
    NO_GPU
  #endif
  }//to_gpu()
  //获取cpu 堆区内存头指针
  const void* SyncedMemory::cpu_data()
  {
    to_cpu();
    return (const void*)cpu_ptr_;
  }

  void SyncedMemory::set_cpu_data(void* data)
  {
    CHECK(data);//???????????????????????
                //????if(data == NULL) return -1;?????????????????
    if(own_cpu_data_)
    {
    CaffeFreeHost(cpu_ptr_, cpu_malloc_use_cuda_);
    }
    cpu_ptr_ = data;
    head_ = HEAD_AT_CPU;
    own_cpu_data_ = false;
  }

  const void* SyncedMemory::gpu_data()
  {
  #ifndef CPU_ONLY
    to_gpu();
    return (const void*)gpu_ptr_;
  #else
    NO_GPU;
    return NULL;
  #endif
  }

  void SyncedMemory::set_gpu_data(void* data)
  {
  #ifndef CPU_ONLY
    CHECK(data);
    if (own_gpu_data_)
    {
      int initial_device;
      cudaGetDevice(&initial_device);
      if (gpu_device_ != -1)
      {
        CUDA_CHECK(cudaSetDevice(gpu_device_));
      }
      CUDA_CHECK(cudaFree(gpu_ptr_));
      cudaSetDevice(initial_device);
    }
    gpu_ptr_ = data;
    head_ = HEAD_AT_GPU;
    own_gpu_data_ = false;
  #else
    NO_GPU;
  #endif
  }

  void* SyncedMemory::mutable_cpu_data()
  {
    to_cpu();
    head_ = HEAD_AT_CPU;
    return cpu_ptr_;
  }

  void* SyncedMemory::mutable_gpu_data()
  {
  #ifndef CPU_ONLY
    to_gpu();
    head_ = HEAD_AT_GPU;
    return gpu_ptr_;
  #else
    NO_GPU;
    return NULL;
  #endif
  }

#ifndef CPU_ONLY
  void SyncedMemory::async_gpu_push(const cudaStream_t& stream)
  {
    CHECK(head_ == HEAD_AT_CPU);
    if (gpu_ptr_ == NULL)
    {
      CUDA_CHECK(cudaGetDevice(&gpu_device_));
      CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_));
      own_gpu_data_ = true;
    }
    const cudaMemcpyKind put = cudaMemcpyHostToDevice;
    CUDA_CHECK(cudaMemcpyAsync(gpu_ptr_, cpu_ptr_, size_, put, stream));
    // Assume caller will synchronize on the stream before use
    head_ = SYNCED;
  }
#endif
};//namespace caffe

自己写的测试代码分析构造函数和析构函数的行为
/*
 * caffe.cpp
 *
 *  Created on: Jun 5, 2017
 *      Author: pan
 */
#include <iostream>
#include <climits>
#include <cstdlib>
#include <boost/shared_ptr.hpp>
using namespace std;
using boost::shared_ptr;
// inline void CaffeMallocHost(void** ptr, size_t size, bool* use_cuda)

inline void CaffeMallocoHost(void** ptr, size_t size)
{
// #ifndef CPU_ONLY
//    cudaMallocHost(ptr, size);
//      void* ptr = (void*)(new char[size]);
    *ptr = malloc(size);
    if(ptr == NULL)
    {
    cout<<"malloc error in fuction CaffeMallocoHost !"<<endl;
    }
}

inline void CaffeFreeHost(void* ptr)
{
  cout<<">>>>>>>>>>>>>CaffeFreeHost";
  if(ptr != NULL)
  {
      free(ptr);
      cout<<">>>>>>>>>>>now free cpu_ptr_ "<<endl;
  }
}

class synced
{
public:
  synced(size_t size, int num) : cpu_ptr_(NULL),
        gpu_ptr_(NULL), own_cpu_data_(false),own_gpu_data_(false),
        size_(size), cpu_malloc_use_cuda_(0),num_(num){cout<<"constructor "<< num_<<" called !\n";}

  ~synced()
  {

    CaffeFreeHost(cpu_ptr_);

    cout<<"destructor "<<num_<<" called!\n";

  }

  void to_cpu()
  {
    CaffeMallocoHost(&cpu_ptr_, size_);
  }
  void* cpu_data()
  {
    to_cpu();
    return cpu_ptr_;
  }
private:
  void* cpu_ptr_;
  bool own_cpu_data_;
  void* gpu_ptr_;
  bool own_gpu_data_;
  bool cpu_malloc_use_cuda_;
  size_t size_;

  int num_;
};


int main()
{
  shared_ptr<synced> data;
  data.reset(new synced(10 * sizeof(int), 1));
  int* ptr = static_cast<int*>(data->cpu_data());
  ptr[9] = 10;
 // cout<< INT_MAX <<endl;

  return 0;
}

抛出问题： caffe内存管理如何使用new delete 形式重写CaffeFreeHost（） ; CaffeMallocHost()。 主要困难是c++
如何分配一个void* 并delete 一个void* 。