Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cycles: Add names to buffer allocations

Browse Source 
This is to help debug and track memory usage for generic buffers. We
have similar for textures already since those require a name, but for
buffers the name is only for debugging proposes.
This commit is contained in:
Mai Lavelle
2016-12-13 20:45:09 -05:00
parent 817873cc83
commit b78e543af9
14 changed files with 53 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
intern/cycles/device/device.cpp
View File

@@ -80,7 +80,7 @@ Device::~Device()
void Device::pixels_alloc(device_memory& mem) void Device::pixels_alloc(device_memory& mem)
{ {
mem_alloc(mem, MEM_READ_WRITE); mem_alloc("pixels", mem, MEM_READ_WRITE);
} }
void Device::pixels_copy_from(device_memory& mem, int y, int w, int h) void Device::pixels_copy_from(device_memory& mem, int y, int w, int h)

2
intern/cycles/device/device.h
View File

@@ -234,7 +234,7 @@ public:
Stats &stats; Stats &stats;
/* regular memory */ /* regular memory */
virtual void mem_alloc(device_memory& mem, MemoryType type) = 0; virtual void mem_alloc(const char *name, device_memory& mem, MemoryType type) = 0;
virtual void mem_copy_to(device_memory& mem) = 0; virtual void mem_copy_to(device_memory& mem) = 0;
virtual void mem_copy_from(device_memory& mem, virtual void mem_copy_from(device_memory& mem,
int y, int w, int h, int elem) = 0; int y, int w, int h, int elem) = 0;

10
intern/cycles/device/device_cpu.cpp
View File

@@ -231,8 +231,14 @@ public:
return (TaskScheduler::num_threads() == 1); return (TaskScheduler::num_threads() == 1);
} }
void mem_alloc(device_memory& mem, MemoryType /*type*/) void mem_alloc(const char *name, device_memory& mem, MemoryType /*type*/)
{ {
if(name) {
VLOG(1) << "Buffer allocate: " << name << ", "
<< string_human_readable_number(mem.memory_size()) << " bytes. ("
<< string_human_readable_size(mem.memory_size()) << ")";
}
mem.device_pointer = mem.data_pointer; mem.device_pointer = mem.data_pointer;
if(!mem.device_pointer) { if(!mem.device_pointer) {
@@ -437,7 +443,7 @@ public:
/* allocate buffer for kernel globals */ /* allocate buffer for kernel globals */
device_memory kgbuffer; device_memory kgbuffer;
kgbuffer.resize(sizeof(KernelGlobals)); kgbuffer.resize(sizeof(KernelGlobals));
mem_alloc(kgbuffer, MEM_READ_WRITE); mem_alloc("kernel_globals", kgbuffer, MEM_READ_WRITE);
KernelGlobals *kg = (KernelGlobals*)kgbuffer.device_pointer; KernelGlobals *kg = (KernelGlobals*)kgbuffer.device_pointer;
*kg = thread_kernel_globals_init(); *kg = thread_kernel_globals_init();

12
intern/cycles/device/device_cuda.cpp
View File

@@ -505,8 +505,14 @@ public:
} }
} }
void mem_alloc(device_memory& mem, MemoryType /*type*/) void mem_alloc(const char *name, device_memory& mem, MemoryType /*type*/)
{ {
if(name) {
VLOG(1) << "Buffer allocate: " << name << ", "
<< string_human_readable_number(mem.memory_size()) << " bytes. ("
<< string_human_readable_size(mem.memory_size()) << ")";
}
cuda_push_context(); cuda_push_context();
CUdeviceptr device_pointer; CUdeviceptr device_pointer;
size_t size = mem.memory_size(); size_t size = mem.memory_size();
@@ -658,7 +664,7 @@ public:
/* Data Storage */ /* Data Storage */
if(interpolation == INTERPOLATION_NONE) { if(interpolation == INTERPOLATION_NONE) {
if(has_bindless_textures) { if(has_bindless_textures) {
mem_alloc(mem, MEM_READ_ONLY); mem_alloc(NULL, mem, MEM_READ_ONLY);
mem_copy_to(mem); mem_copy_to(mem);
cuda_push_context(); cuda_push_context();
@@ -682,7 +688,7 @@ public:
cuda_pop_context(); cuda_pop_context();
} }
else { else {
mem_alloc(mem, MEM_READ_ONLY); mem_alloc(NULL, mem, MEM_READ_ONLY);
mem_copy_to(mem); mem_copy_to(mem);
cuda_push_context(); cuda_push_context();

4
intern/cycles/device/device_multi.cpp
View File

@@ -106,11 +106,11 @@ public:
return true; return true;
} }
void mem_alloc(device_memory& mem, MemoryType type) void mem_alloc(const char *name, device_memory& mem, MemoryType type)
{ {
foreach(SubDevice& sub, devices) { foreach(SubDevice& sub, devices) {
mem.device_pointer = 0; mem.device_pointer = 0;
sub.device->mem_alloc(mem, type); sub.device->mem_alloc(name, mem, type);
sub.ptr_map[unique_ptr] = mem.device_pointer; sub.ptr_map[unique_ptr] = mem.device_pointer;
} }

10
intern/cycles/device/device_network.cpp
View File

@@ -87,8 +87,14 @@ public:
snd.write(); snd.write();
} }
void mem_alloc(device_memory& mem, MemoryType type) void mem_alloc(const char *name, device_memory& mem, MemoryType type)
{ {
if(name) {
VLOG(1) << "Buffer allocate: " << name << ", "
<< string_human_readable_number(mem.memory_size()) << " bytes. ("
<< string_human_readable_size(mem.memory_size()) << ")";
}
thread_scoped_lock lock(rpc_lock); thread_scoped_lock lock(rpc_lock);
mem.device_pointer = ++mem_counter; mem.device_pointer = ++mem_counter;
@@ -481,7 +487,7 @@ protected:
mem.data_pointer = 0; mem.data_pointer = 0;
/* perform the allocation on the actual device */ /* perform the allocation on the actual device */
device->mem_alloc(mem, type); device->mem_alloc(NULL, mem, type);
/* store a mapping to/from client_pointer and real device pointer */ /* store a mapping to/from client_pointer and real device pointer */
pointer_mapping_insert(client_pointer, mem.device_pointer); pointer_mapping_insert(client_pointer, mem.device_pointer);

10
intern/cycles/device/device_split_kernel.cpp
View File

@@ -131,21 +131,21 @@ bool DeviceSplitKernel::path_trace(DeviceTask *task,
/* Allocate work_pool_wgs memory. */ /* Allocate work_pool_wgs memory. */
work_pool_wgs.resize(max_work_groups * sizeof(unsigned int)); work_pool_wgs.resize(max_work_groups * sizeof(unsigned int));
device->mem_alloc(work_pool_wgs, MEM_READ_WRITE); device->mem_alloc("work_pool_wgs", work_pool_wgs, MEM_READ_WRITE);
queue_index.resize(NUM_QUEUES * sizeof(int)); queue_index.resize(NUM_QUEUES * sizeof(int));
device->mem_alloc(queue_index, MEM_READ_WRITE); device->mem_alloc("queue_index", queue_index, MEM_READ_WRITE);
use_queues_flag.resize(sizeof(char)); use_queues_flag.resize(sizeof(char));
device->mem_alloc(use_queues_flag, MEM_READ_WRITE); device->mem_alloc("use_queues_flag", use_queues_flag, MEM_READ_WRITE);
ray_state.resize(num_global_elements); ray_state.resize(num_global_elements);
device->mem_alloc(ray_state, MEM_READ_WRITE); device->mem_alloc("ray_state", ray_state, MEM_READ_WRITE);
split_data.resize(split_data_buffer_size(num_global_elements, split_data.resize(split_data_buffer_size(num_global_elements,
current_max_closure, current_max_closure,
per_thread_output_buffer_size)); per_thread_output_buffer_size));
device->mem_alloc(split_data, MEM_READ_WRITE); device->mem_alloc("split_data", split_data, MEM_READ_WRITE);
} }
#define ENQUEUE_SPLIT_KERNEL(name, global_size, local_size) \ #define ENQUEUE_SPLIT_KERNEL(name, global_size, local_size) \

2
intern/cycles/device/opencl/opencl.h
View File

@@ -269,7 +269,7 @@ public:
virtual bool load_kernels(const DeviceRequestedFeatures& requested_features, virtual bool load_kernels(const DeviceRequestedFeatures& requested_features,
vector<OpenCLProgram*> &programs) = 0; vector<OpenCLProgram*> &programs) = 0;
void mem_alloc(device_memory& mem, MemoryType type); void mem_alloc(const char *name, device_memory& mem, MemoryType type);
void mem_copy_to(device_memory& mem); void mem_copy_to(device_memory& mem);
void mem_copy_from(device_memory& mem, int y, int w, int h, int elem); void mem_copy_from(device_memory& mem, int y, int w, int h, int elem);
void mem_zero(device_memory& mem); void mem_zero(device_memory& mem);

12
intern/cycles/device/opencl/opencl_base.cpp
View File

@@ -245,8 +245,14 @@ bool OpenCLDeviceBase::load_kernels(const DeviceRequestedFeatures& requested_fea
return true; return true;
} }
void OpenCLDeviceBase::mem_alloc(device_memory& mem, MemoryType type) void OpenCLDeviceBase::mem_alloc(const char *name, device_memory& mem, MemoryType type)
{ {
if(name) {
VLOG(1) << "Buffer allocate: " << name << ", "
<< string_human_readable_number(mem.memory_size()) << " bytes. ("
<< string_human_readable_size(mem.memory_size()) << ")";
}
size_t size = mem.memory_size(); size_t size = mem.memory_size();
cl_mem_flags mem_flag; cl_mem_flags mem_flag;
@@ -393,7 +399,7 @@ void OpenCLDeviceBase::const_copy_to(const char *name, void *host, size_t size)
device_vector<uchar> *data = new device_vector<uchar>(); device_vector<uchar> *data = new device_vector<uchar>();
data->copy((uchar*)host, size); data->copy((uchar*)host, size);
mem_alloc(*data, MEM_READ_ONLY); mem_alloc(name, *data, MEM_READ_ONLY);
i = const_mem_map.insert(ConstMemMap::value_type(name, data)).first; i = const_mem_map.insert(ConstMemMap::value_type(name, data)).first;
} }
else { else {
@@ -412,7 +418,7 @@ void OpenCLDeviceBase::tex_alloc(const char *name,
VLOG(1) << "Texture allocate: " << name << ", " VLOG(1) << "Texture allocate: " << name << ", "
<< string_human_readable_number(mem.memory_size()) << " bytes. (" << string_human_readable_number(mem.memory_size()) << " bytes. ("
<< string_human_readable_size(mem.memory_size()) << ")"; << string_human_readable_size(mem.memory_size()) << ")";
mem_alloc(mem, MEM_READ_ONLY); mem_alloc(NULL, mem, MEM_READ_ONLY);
mem_copy_to(mem); mem_copy_to(mem);
assert(mem_map.find(name) == mem_map.end()); assert(mem_map.find(name) == mem_map.end());
mem_map.insert(MemMap::value_type(name, mem.device_pointer)); mem_map.insert(MemMap::value_type(name, mem.device_pointer));

2
intern/cycles/device/opencl/opencl_split.cpp
View File

@@ -115,7 +115,7 @@ public:
/* Allocate buffer for kernel globals */ /* Allocate buffer for kernel globals */
device_memory kgbuffer; device_memory kgbuffer;
kgbuffer.resize(sizeof(KernelGlobals)); kgbuffer.resize(sizeof(KernelGlobals));
mem_alloc(kgbuffer, MEM_READ_WRITE); mem_alloc("kernel_globals", kgbuffer, MEM_READ_WRITE);
/* Keep rendering tiles until done. */ /* Keep rendering tiles until done. */
while(task->acquire_tile(this, tile)) { while(task->acquire_tile(this, tile)) {

4
intern/cycles/render/bake.cpp
View File

@@ -171,9 +171,9 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
/* needs to be up to data for attribute access */ /* needs to be up to data for attribute access */
device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
device->mem_alloc(d_input, MEM_READ_ONLY); device->mem_alloc("bake_input", d_input, MEM_READ_ONLY);
device->mem_copy_to(d_input); device->mem_copy_to(d_input);
device->mem_alloc(d_output, MEM_READ_WRITE); device->mem_alloc("bake_output", d_output, MEM_READ_WRITE);
DeviceTask task(DeviceTask::SHADER); DeviceTask task(DeviceTask::SHADER);
task.shader_input = d_input.device_pointer; task.shader_input = d_input.device_pointer;

4
intern/cycles/render/buffers.cpp
View File

@@ -129,13 +129,13 @@ void RenderBuffers::reset(Device *device, BufferParams& params_)
/* allocate buffer */ /* allocate buffer */
buffer.resize(params.width*params.height*params.get_passes_size()); buffer.resize(params.width*params.height*params.get_passes_size());
device->mem_alloc(buffer, MEM_READ_WRITE); device->mem_alloc("render_buffer", buffer, MEM_READ_WRITE);
device->mem_zero(buffer); device->mem_zero(buffer);
/* allocate rng state */ /* allocate rng state */
rng_state.resize(params.width, params.height); rng_state.resize(params.width, params.height);
device->mem_alloc(rng_state, MEM_READ_WRITE); device->mem_alloc("rng_state", rng_state, MEM_READ_WRITE);
} }
bool RenderBuffers::copy_from_device() bool RenderBuffers::copy_from_device()

4
intern/cycles/render/light.cpp
View File

@@ -57,9 +57,9 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
device->mem_alloc(d_input, MEM_READ_ONLY); device->mem_alloc("shade_background_pixels_input", d_input, MEM_READ_ONLY);
device->mem_copy_to(d_input); device->mem_copy_to(d_input);
device->mem_alloc(d_output, MEM_WRITE_ONLY); device->mem_alloc("shade_background_pixels_output", d_output, MEM_WRITE_ONLY);
DeviceTask main_task(DeviceTask::SHADER); DeviceTask main_task(DeviceTask::SHADER);
main_task.shader_input = d_input.device_pointer; main_task.shader_input = d_input.device_pointer;

4
intern/cycles/render/mesh_displace.cpp
View File

@@ -121,9 +121,9 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
/* needs to be up to data for attribute access */ /* needs to be up to data for attribute access */
device->const_copy_to("__data", &dscene->data, sizeof(dscene->data)); device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
device->mem_alloc(d_input, MEM_READ_ONLY); device->mem_alloc("displace_input", d_input, MEM_READ_ONLY);
device->mem_copy_to(d_input); device->mem_copy_to(d_input);
device->mem_alloc(d_output, MEM_WRITE_ONLY); device->mem_alloc("displace_output", d_output, MEM_WRITE_ONLY);
DeviceTask task(DeviceTask::SHADER); DeviceTask task(DeviceTask::SHADER);
task.shader_input = d_input.device_pointer; task.shader_input = d_input.device_pointer;