Page MenuHome
Differential D6126 Diff 19187 intern/cycles/device/device_cuda.cpp

Changeset View

Standalone View

View Options

intern/cycles/device/device_cuda.cpp

Context not available.
CUDASplitKernel *split_kernel; CUDASplitKernel *split_kernel;
struct CUDAMem { struct CUDAMem {
CUDAMem() : texobject(0), array(0), map_host_pointer(0), free_map_host(false) CUDAMem() : texobject(0), array(0), use_mapped_host(false)
{ {
} }
CUtexObject texobject; CUtexObject texobject;
CUarray array; CUarray array;
void *map_host_pointer;
bool free_map_host; /* If true, a mapped host memory stored in shared_pointer is used. */
bool use_mapped_host;
}; };
typedef map<device_memory *, CUDAMem> CUDAMemMap; typedef map<device_memory *, CUDAMem> CUDAMemMap;
CUDAMemMap cuda_mem_map; CUDAMemMap cuda_mem_map;
Context not available.
} }
/* Already in host memory. */ /* Already in host memory. */
if (cmem->map_host_pointer) { if (cmem->use_mapped_host) {
continue; continue;
} }
Context not available.
cuMemGetInfo(&free, &total); cuMemGetInfo(&free, &total);
/* Move textures to host memory if needed. */ /* Move textures to host memory if needed. */
if (!move_texture_to_host && !is_image && (size + headroom) >= free) { if (!move_texture_to_host && !is_image && (size + headroom) >= free && can_map_host) {
move_textures_to_host(size + headroom - free, is_texture); move_textures_to_host(size + headroom - free, is_texture);
cuMemGetInfo(&free, &total); cuMemGetInfo(&free, &total);
} }
Context not available.
} }
/* Fall back to mapped host memory if needed and possible. */ /* Fall back to mapped host memory if needed and possible. */
void *map_host_pointer = 0;
bool free_map_host = false;
if (mem_alloc_result != CUDA_SUCCESS && can_map_host && void *shared_pointer = 0;
map_host_used + size < map_host_limit) {
if (mem_alloc_result != CUDA_SUCCESS && can_map_host) {
if (mem.shared_pointer) { if (mem.shared_pointer) {
/* Another device already allocated host memory. */ /* Another device already allocated host memory. */
mem_alloc_result = CUDA_SUCCESS; mem_alloc_result = CUDA_SUCCESS;
map_host_pointer = mem.shared_pointer; shared_pointer = mem.shared_pointer;
} }
else { else if (map_host_used + size < map_host_limit) {
/* Allocate host memory ourselves. */ /* Allocate host memory ourselves. */
mem_alloc_result = cuMemHostAlloc( mem_alloc_result = cuMemHostAlloc(
&map_host_pointer, size, CU_MEMHOSTALLOC_DEVICEMAP | CU_MEMHOSTALLOC_WRITECOMBINED); &shared_pointer, size, CU_MEMHOSTALLOC_DEVICEMAP | CU_MEMHOSTALLOC_WRITECOMBINED);
mem.shared_pointer = map_host_pointer;
free_map_host = true; assert(mem_alloc_result == CUDA_SUCCESS && shared_pointer != 0
|| mem_alloc_result != CUDA_SUCCESS && shared_pointer == 0);
} }
if (mem_alloc_result == CUDA_SUCCESS) { if (mem_alloc_result == CUDA_SUCCESS) {
cuda_assert(cuMemHostGetDevicePointer_v2(&device_pointer, mem.shared_pointer, 0)); cuda_assert(cuMemHostGetDevicePointer_v2(&device_pointer, shared_pointer, 0));
map_host_used += size; map_host_used += size;
status = " in host memory"; status = " in host memory";
/* Replace host pointer with our host allocation. Only works if
* CUDA memory layout is the same and has no pitch padding. Also
* does not work if we move textures to host during a render,
* since other devices might be using the memory. */
if (!move_texture_to_host && pitch_padding == 0 && mem.host_pointer &&
mem.host_pointer != mem.shared_pointer) {
memcpy(mem.shared_pointer, mem.host_pointer, size);
mem.host_free();
mem.host_pointer = mem.shared_pointer;
}
} }
else { else {
status = " failed, out of host memory"; status = " failed, out of host memory";
} }
} }
else if (mem_alloc_result != CUDA_SUCCESS) {
status = " failed, out of device and host memory";
}
if (mem_alloc_result != CUDA_SUCCESS) { if (mem_alloc_result != CUDA_SUCCESS) {
status = " failed, out of device and host memory";
cuda_assert(mem_alloc_result); cuda_assert(mem_alloc_result);
} }
Context not available.
/* Insert into map of allocations. */ /* Insert into map of allocations. */
CUDAMem *cmem = &cuda_mem_map[&mem]; CUDAMem *cmem = &cuda_mem_map[&mem];
cmem->map_host_pointer = map_host_pointer; if (shared_pointer != 0) {
cmem->free_map_host = free_map_host; ///* Replace host pointer with our host allocation. Only works if
sergeyUnsubmitted
Done
Inline Actions

We do not use such style of comments.
We are following /* in almost all the cases, sometimes its //.

sergey: We do not use such style of comments. We are following `/*` in almost all the cases, sometimes…
//* CUDA memory layout is the same and has no pitch padding. Also
//* does not work if we move textures to host during a render,
//* since other devices might be using the memory. */
if (!move_texture_to_host && pitch_padding == 0 && mem.host_pointer &&
mem.host_pointer != shared_pointer) {
memcpy(shared_pointer, mem.host_pointer, size);
///* A Call to device_memory::host_free() should be preceded by a call to device_memory::device_free()
//* for host memory allocated by a device to be handled properly.
//* Two exceptions are here and a call in OptiXDevice::generic_alloc(), where
//* the current host memory can be assumed to be allocated by device_memory::host_alloc(), not by a device */
mem.host_free();
mem.host_pointer = shared_pointer;
}
mem.shared_pointer = shared_pointer;
mem.shared_counter++;
cmem->use_mapped_host = true;
}
else {
cmem->use_mapped_host = false;
}
return cmem; return cmem;
} }
Context not available.
if (mem.host_pointer && mem.device_pointer) { if (mem.host_pointer && mem.device_pointer) {
CUDAContextScope scope(this); CUDAContextScope scope(this);
if (mem.host_pointer != mem.shared_pointer) { ///* If use_mapped_host of mem is false, the current device only uses device memory allocated by cuMemAlloc
cuda_assert(cuMemcpyHtoD( //* regardless of mem.host_pointer and mem.shared_pointer, and should copy data from mem.host_pointer.
cuda_device_ptr(mem.device_pointer), mem.host_pointer, mem.memory_size()));
if (cuda_mem_map[&mem].use_mapped_host == false || mem.host_pointer != mem.shared_pointer) {
cuda_assert(cuMemcpyHtoD(
cuda_device_ptr(mem.device_pointer), mem.host_pointer, mem.memory_size()));
} }
} }
} }
Context not available.
CUDAContextScope scope(this); CUDAContextScope scope(this);
const CUDAMem &cmem = cuda_mem_map[&mem]; const CUDAMem &cmem = cuda_mem_map[&mem];
if (cmem.map_host_pointer) { ///* If cmem.use_mapped_host is true, reference counting is used to safely free a mapped host memory. */
/* Free host memory. */
if (cmem.free_map_host) { if (cmem.use_mapped_host) {
cuMemFreeHost(cmem.map_host_pointer); assert(mem.shared_pointer);
if (mem.host_pointer == mem.shared_pointer) { if (mem.shared_pointer) {
mem.host_pointer = 0; assert(mem.shared_counter > 0);
if (--mem.shared_counter == 0) {
if (mem.host_pointer == mem.shared_pointer)
mem.host_pointer = 0;
cuMemFreeHost(mem.shared_pointer);
mem.shared_pointer = 0;
} }
mem.shared_pointer = 0;
} }
map_host_used -= mem.device_size; map_host_used -= mem.device_size;
} }
else { else {
Context not available.
memset(mem.host_pointer, 0, mem.memory_size()); memset(mem.host_pointer, 0, mem.memory_size());
} }
if (mem.device_pointer && (!mem.host_pointer || mem.host_pointer != mem.shared_pointer)) { ///* If use_mapped_host of mem is false, mem.device_pointer currently refers to device memory
//* regardless of mem.host_pointer and mem.shared_pointer.
if (mem.device_pointer
&& (cuda_mem_map[&mem].use_mapped_host == false || mem.host_pointer != mem.shared_pointer)) {
CUDAContextScope scope(this); CUDAContextScope scope(this);
cuda_assert(cuMemsetD8(cuda_device_ptr(mem.device_pointer), 0, mem.memory_size())); cuda_assert(cuMemsetD8(cuda_device_ptr(mem.device_pointer), 0, mem.memory_size()));
} }
Context not available.