caffe 源码学习（三） SyncedMemory 与 shared_ptr
在blob.hpp中我们会看到protected成员变量：
protected:
shared_ptr data_;
shared_ptr diff_;
shared_ptr shape_data_;
vector<int> shape_;
int count_;
int capacity_; 其中data_，diff_，shape_data_ 就是指向数据，梯度，和形状数据的shared_ptr指针。在这里顺便学习一下shared_ptr，主要参考http://blog.csdn.net/sndaxdrs/article/details/6175701。自己写了点代码，体会了一下。
注意，编译时：g++ shared_ptr.cpp -lboost_system
// shared_ptr.cpp
#include22);
cout << ap.use_count() << endl;
// test class S
int m = 1;
int n = 2;
S s;
s.print_inS1();
s.print_inS2();
s.set_inS1(m,n);
s.print_inS1();
s.print_inS2();
s.printcount();
s.S1pointtoS2();
s.print_inS1();
s.print_inS2();
s.printcount();
// shared_ptr in vector
typedef vector< shared_ptr<int> > vs;
vs v(10);
int i = 0;
for(vs::iterator pos = v.begin(); pos != v.end(); ++pos)
{
shared_ptr<int> vp(new int(++i));
*pos = vp;
}
for(int i = 0; i < 10; ++i)
{
cout << *(v[i]) << endl;
cout << v[i].use_count() << endl;
}
shared_ptr<int> vp1 = v[1];
*vp1 = 11;
cout << *v[1] << endl;
cout << v[1].use_count() << endl;
return 0;
} 在之前的Blob学习中简单的了解了SyncedMemory类中都有些什么东西，为了进一步了解caffe是如何完成cpu和gpu数据管理，还是读一读源码吧。
syncedmem.hpp
#ifndef CAFFE_SYNCEDMEM_HPP_
#define CAFFE_SYNCEDMEM_HPP_
#include 通过读头文件再参考下面的cpp文件已经对SyncedMemory的功能很清楚了，并且能够大体了解时如何实现的，如果再深究的话，可能就要研究cuda，这里就简单理解它给出函数的意义就可以了，比如cudaMemcpyAsync。下面的cpp文件内容少易读，上面的注释就是参考它写的，所以就不在赘述了，为了方便还是贴出来吧。
#include "caffe/common.hpp"
#include "caffe/syncedmem.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
SyncedMemory::~SyncedMemory() {
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_ONLY
}
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
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;
#endif
break;
case HEAD_AT_CPU:
case SYNCED:
break;
}
}
inline void SyncedMemory::to_gpu() {
#ifndef CPU_ONLY
switch (head_) {
case UNINITIALIZED:
CUDA_CHECK(cudaGetDevice(&gpu_device_));
CUDA_CHECK(cudaMalloc(&gpu_ptr_, size_));
caffe_gpu_memset(size_, 0, gpu_ptr_);
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
}
const void* SyncedMemory::cpu_data() {
to_cpu();
return (const void*)cpu_ptr_;
}
void SyncedMemory::set_cpu_data(void* data) {
CHECK(data);
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
总结
通过读SyncedMemory的源代码，可以看到，用它可以为数据分配内存空间，根据需要储存，获取，修改cpu或gpu数据，比如，set_cpu_data，set_gpu_data，cpu_data，gpu_data，mutable_cpu_data，mutable_gpu_data。并可以在cpu和gpu之间进行同步，不用关心其具体细节。
希望大家批评指正。
参考：
【1】http://www.cnblogs.com/louyihang-loves-baiyan/p/5150554.html