我正在尝试在管理某些内存的设备上构建容器类。 在内核中的对象构造期间动态分配该内存并填充该内存。 根据可以使用内核中的简单new []完成的文档(在Visual Studio 2012中使用带有计算可运行性5.0的CUDA 8.0)。 之后我想在主机代码中访问容器内的数据(例如,用于测试所有值是否正确)。
DeviceContainer
类的最小版本如下所示:
class DeviceContainer
{
public:
__device__ DeviceContainer(unsigned int size);
__host__ __device__ ~DeviceContainer();
__host__ __device__ DeviceContainer(const DeviceContainer & other);
__host__ __device__ DeviceContainer & operator=(const DeviceContainer & other);
__host__ __device__ unsigned int getSize() const { return m_sizeData; }
__device__ int * getDataDevice() const { return mp_dev_data; }
__host__ int* getDataHost() const;
private:
int * mp_dev_data;
unsigned int m_sizeData;
};
__device__ DeviceContainer::DeviceContainer(unsigned int size) :
m_sizeData(size), mp_dev_data(nullptr)
{
mp_dev_data = new int[m_sizeData];
for(unsigned int i = 0; i < m_sizeData; ++i) {
mp_dev_data[i] = i;
}
}
__host__ __device__ DeviceContainer::DeviceContainer(const DeviceContainer & other) :
m_sizeData(other.m_sizeData)
{
#ifndef __CUDA_ARCH__
cudaSafeCall( cudaMalloc((void**)&mp_dev_data, m_sizeData * sizeof(int)) );
cudaSafeCall( cudaMemcpy(mp_dev_data, other.mp_dev_data, m_sizeData * sizeof(int), cudaMemcpyDeviceToDevice) );
#else
mp_dev_data = new int[m_sizeData];
memcpy(mp_dev_data, other.mp_dev_data, m_sizeData * sizeof(int));
#endif
}
__host__ __device__ DeviceContainer::~DeviceContainer()
{
#ifndef __CUDA_ARCH__
cudaSafeCall( cudaFree(mp_dev_data) );
#else
delete[] mp_dev_data;
#endif
mp_dev_data = nullptr;
}
__host__ __device__ DeviceContainer & DeviceContainer::operator=(const DeviceContainer & other)
{
m_sizeData = other.m_sizeData;
#ifndef __CUDA_ARCH__
cudaSafeCall( cudaMalloc((void**)&mp_dev_data, m_sizeData * sizeof(int)) );
cudaSafeCall( cudaMemcpy(mp_dev_data, other.mp_dev_data, m_sizeData * sizeof(int), cudaMemcpyDeviceToDevice) );
#else
mp_dev_data = new int[m_sizeData];
memcpy(mp_dev_data, other.mp_dev_data, m_sizeData * sizeof(int));
#endif
return *this;
}
__host__ int* DeviceContainer::getDataHost() const
{
int * pDataHost = new int[m_sizeData];
cudaSafeCall( cudaMemcpy(pDataHost, mp_dev_data, m_sizeData * sizeof(int), cudaMemcpyDeviceToHost) );
return pDataHost;
}
它只管理数组mp_dev_data
。
在构造期间创建并填充连续值的数组,这应该只能在设备上实现。 (请注意,实际上容器的大小可能彼此不同。)
我认为我需要提供一个复制构造函数和赋值运算符,因为我不知道在内核中填充数组的任何其他方法。 (见下文第3项问题。)
由于复制和删除也可以在主机上进行,因此__CUDA_ARCH__
用于确定我们正在编译的执行路径。在主机上使用cudaMemcpy
和cudaFree
,我们可以在设备上使用memcpy
和delete[]
。
用于创建对象的内核非常简单:
__global__ void createContainer(DeviceContainer * pContainer, unsigned int numContainer, unsigned int containerSize)
{
unsigned int offset = blockIdx.x * blockDim.x + threadIdx.x;
if(offset < numContainer)
{
pContainer[offset] = DeviceContainer(containerSize);
}
}
范围内的一维网格中的每个线程都会创建一个容器对象。
然后main函数在设备和主机上为容器(在本例中为90000)分配数组,调用内核并尝试使用这些对象:
void main()
{
const unsigned int numContainer = 90000;
const unsigned int containerSize = 5;
DeviceContainer * pDevContainer;
cudaSafeCall( cudaMalloc((void**)&pDevContainer, numContainer * sizeof(DeviceContainer)) );
dim3 blockSize(1024, 1, 1);
dim3 gridSize((numContainer + blockSize.x - 1)/blockSize.x , 1, 1);
createContainer<<<gridSize, blockSize>>>(pDevContainer, numContainer, containerSize);
cudaCheckError();
DeviceContainer * pHostContainer = (DeviceContainer *)malloc(numContainer * sizeof(DeviceContainer));
cudaSafeCall( cudaMemcpy(pHostContainer, pDevContainer, numContainer * sizeof(DeviceContainer), cudaMemcpyDeviceToHost) );
for(unsigned int i = 0; i < numContainer; ++i)
{
const DeviceContainer & dc = pHostContainer[i];
int * pData = dc.getDataHost();
for(unsigned int j = 0; j < dc.getSize(); ++j)
{
std::cout << pData[j];
}
std::cout << std::endl;
delete[] pData;
}
free(pHostContainer);
cudaSafeCall( cudaFree(pDevContainer) );
}
我必须使用malloc
在主机上创建数组,因为我不想拥有DeviceContainer
的默认构造函数。
我尝试通过内部只调用getDataHost()
的{{1}}来访问容器内的数据。
cudaMemcpy
和cudaSafeCall
是简单的宏,用于评估函数oder返回的cudaCheckError
主动轮询最后一个错误。为了完整起见:
cudaError
我对此代码有3个问题:
如果按照此处的说明执行,我会收到内核的“未指定的启动失败”。 Nsight调试器阻止我在#define cudaSafeCall(error) __cudaSafeCall(error, __FILE__, __LINE__)
#define cudaCheckError() __cudaCheckError(__FILE__, __LINE__)
inline void __cudaSafeCall(cudaError error, const char *file, const int line)
{
if (error != cudaSuccess)
{
std::cerr << "cudaSafeCall() returned:" << std::endl;
std::cerr << "\tFile: " << file << ",\nLine: " << line << " - CudaError " << error << ":" << std::endl;
std::cerr << "\t" << cudaGetErrorString(error) << std::endl;
system("PAUSE");
exit( -1 );
}
}
inline void __cudaCheckError(const char *file, const int line)
{
cudaError error = cudaDeviceSynchronize();
if (error != cudaSuccess)
{
std::cerr << "cudaCheckError() returned:" << std::endl;
std::cerr << "\tFile: " << file << ",\tLine: " << line << " - CudaError " << error << ":" << std::endl;
std::cerr << "\t" << cudaGetErrorString(error) << std::endl;
system("PAUSE");
exit( -1 );
}
}
行(在构造函数或赋值运算符中)并报告全局内存上的多个访问冲突。违规次数似乎在4到11之间是随机的,它们出现在非连续线程中,但总是在网格的上端附近(方框85和86)。
如果我将mp_dev_data = new int[m_sizeData];
减少到10,内核会顺利运行,但numContainer
中的cudaMamcpy
会因参数无效而失败 - 即使getDataHost()
不是0.(我怀疑赋值是错误的,内存已经被另一个对象删除了。)
即使我想知道如何正确实现mp_dev_data
并进行适当的内存管理,但就我而言,将其设置为不可复制且不可分配也就足够了。但是,我不知道如何在内核中正确填充容器数组。也许像是
DeviceContainer
这会导致在析构函数中删除DeviceContainer dc(5);
memcpy(&pContainer[offset], &dc, sizeof(DeviceContainer));
时出现问题。我需要手动管理内存删除,感觉相当脏。
我还尝试在内核代码中使用mp_dev_data
和malloc
,而不是free
和new
,但结果是相同的。
我很抱歉我无法以较短的方式构建我的问题。
TL; DR:如何实现一个在内核中动态分配内存的类,也可以在主机代码中使用?如何在内核中使用无法复制或分配的对象初始化数组?
感谢任何帮助。谢谢。
答案 0 :(得分:1)
显然答案是:我试图做的或多或少是不可能的。
在内核中使用new
或malloc
分配的内存不会放在全局内存中,而是放在主机无法访问的特殊堆内存中。
访问主机上所有内存的唯一选择是首先在全局内存中分配一个数组,该数组足以容纳堆上的所有元素,然后编写一个将所有元素从堆复制到全局内存的内核。 / p>
访问冲突是由有限的堆大小引起的(可以通过cudaDeviceSetLimit(cudaLimitMallocHeapSize, size_t size)
更改。