Differential D4481 Diff 14073 intern/cycles/device/opencl/opencl_split.cpp

Changeset View

Standalone View

intern/cycles/device/opencl/opencl_split.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines	static const string fast_compiled_kernels =
"queue_enqueue "		"queue_enqueue "
"shader_setup "		"shader_setup "
"shader_sort "		"shader_sort "
"enqueue_inactive "		"enqueue_inactive "
"next_iteration_setup "		"next_iteration_setup "
"indirect_subsurface "		"indirect_subsurface "
"buffer_update";		"buffer_update";

const string OpenCLDevice::get_opencl_program_name(bool single_program, const string& kernel_name)		const string OpenCLDevice::get_opencl_program_name(const string& kernel_name)
{		{
if (single_program) {
return "split";
}
else {
if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {		if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
return "split_bundle";		return "split_bundle";
}		}
else {		else {
return "split_" + kernel_name;		return "split_" + kernel_name;
}		}
}		}
}

const string OpenCLDevice::get_opencl_program_filename(bool single_program, const string& kernel_name)		const string OpenCLDevice::get_opencl_program_filename(const string& kernel_name)
{		{
if (single_program) {
return "kernel_split.cl";
}
else {
if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {		if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
return "kernel_split_bundle.cl";		return "kernel_split_bundle.cl";
}		}
else {		else {
return "kernel_" + kernel_name + ".cl";		return "kernel_" + kernel_name + ".cl";
}		}
}		}
}

string OpenCLDevice::get_build_options(const DeviceRequestedFeatures& requested_features, const string& opencl_program_name)		string OpenCLDevice::get_build_options(const DeviceRequestedFeatures& requested_features, const string& opencl_program_name)
{		{
/* first check for non-split kernel programs */		/* first check for non-split kernel programs */
if (opencl_program_name == "base" \|\| opencl_program_name == "denoising") {		if (opencl_program_name == "base" \|\| opencl_program_name == "denoising") {
return "";		return "";
}		}
else if (opencl_program_name == "bake") {		else if (opencl_program_name == "bake") {
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines	public:
explicit OpenCLSplitKernel(OpenCLDevice *device) : DeviceSplitKernel(device), device(device) {		explicit OpenCLSplitKernel(OpenCLDevice *device) : DeviceSplitKernel(device), device(device) {
}		}

virtual SplitKernelFunction* get_split_kernel_function(const string& kernel_name,		virtual SplitKernelFunction* get_split_kernel_function(const string& kernel_name,
const DeviceRequestedFeatures& requested_features)		const DeviceRequestedFeatures& requested_features)
{		{
OpenCLSplitKernelFunction* kernel = new OpenCLSplitKernelFunction(device, cached_memory);		OpenCLSplitKernelFunction* kernel = new OpenCLSplitKernelFunction(device, cached_memory);

bool single_program = OpenCLInfo::use_single_program();		const string program_name = device->get_opencl_program_name(kernel_name);
const string program_name = device->get_opencl_program_name(single_program, kernel_name);
kernel->program =		kernel->program =
OpenCLDevice::OpenCLProgram(device,		OpenCLDevice::OpenCLProgram(device,
program_name,		program_name,
device->get_opencl_program_filename(single_program, kernel_name),		device->get_opencl_program_filename(kernel_name),
device->get_build_options(requested_features, program_name));		device->get_build_options(requested_features, program_name));

kernel->program.add_kernel(ustring("path_trace_" + kernel_name));		kernel->program.add_kernel(ustring("path_trace_" + kernel_name));
kernel->program.load();		kernel->program.load();

if(!kernel->program.is_loaded()) {		if(!kernel->program.is_loaded()) {
delete kernel;		delete kernel;
return NULL;		return NULL;
▲ Show 20 Lines • Show All 361 Lines • ▼ Show 20 Lines	bool OpenCLDevice::load_kernels(const DeviceRequestedFeatures& requested_features)
}		}

if (requested_features.use_background_light) {		if (requested_features.use_background_light) {
background_program = OpenCLProgram(this, "background", "kernel_background.cl", get_build_options(requested_features, "background"));		background_program = OpenCLProgram(this, "background", "kernel_background.cl", get_build_options(requested_features, "background"));
background_program.add_kernel(ustring("background"));		background_program.add_kernel(ustring("background"));
programs.push_back(&background_program);		programs.push_back(&background_program);
}		}

bool single_program = OpenCLInfo::use_single_program();		#define ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(kernel_name) program_split.add_kernel(ustring("path_trace_"#kernel_name));
		#define ADD_SPLIT_KERNEL_PROGRAM(kernel_name) \
#define ADD_SPLIT_KERNEL_SINGLE_PROGRAM(kernel_name) program_split.add_kernel(ustring("path_trace_"#kernel_name));
#define ADD_SPLIT_KERNEL_SPLIT_PROGRAM(kernel_name) \
const string program_name_##kernel_name = "split_"#kernel_name; \		const string program_name_##kernel_name = "split_"#kernel_name; \
program_##kernel_name = \		program_##kernel_name = \
OpenCLDevice::OpenCLProgram(this, \		OpenCLDevice::OpenCLProgram(this, \
program_name_##kernel_name, \		program_name_##kernel_name, \
"kernel_"#kernel_name".cl", \		"kernel_"#kernel_name".cl", \
get_build_options(requested_features, program_name_##kernel_name)); \		get_build_options(requested_features, program_name_##kernel_name)); \
program_##kernel_name.add_kernel(ustring("path_trace_"#kernel_name)); \		program_##kernel_name.add_kernel(ustring("path_trace_"#kernel_name)); \
programs.push_back(&program_##kernel_name);		programs.push_back(&program_##kernel_name);

if (single_program) {
program_split = OpenCLDevice::OpenCLProgram(this,
"split" ,
"kernel_split.cl",
get_build_options(requested_features, "split"));

ADD_SPLIT_KERNEL_SINGLE_PROGRAM(state_buffer_size);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(data_init);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(path_init);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(scene_intersect);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(lamp_emission);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(do_volume);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(queue_enqueue);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(indirect_background);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_setup);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_sort);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_eval);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(holdout_emission_blurring_pathtermination_ao);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(subsurface_scatter);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(direct_lighting);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shadow_blocked_ao);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shadow_blocked_dl);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(enqueue_inactive);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(next_iteration_setup);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(indirect_subsurface);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(buffer_update);

programs.push_back(&program_split);
}
else {
/* Ordered with most complex kernels first, to reduce overall compile time. */		/* Ordered with most complex kernels first, to reduce overall compile time. */
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(subsurface_scatter);		ADD_SPLIT_KERNEL_PROGRAM(subsurface_scatter);
if (requested_features.use_volume) {		if (requested_features.use_volume) {
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(do_volume);		ADD_SPLIT_KERNEL_PROGRAM(do_volume);
}		}
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shadow_blocked_dl);		ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_dl);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shadow_blocked_ao);		ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_ao);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(holdout_emission_blurring_pathtermination_ao);		ADD_SPLIT_KERNEL_PROGRAM(holdout_emission_blurring_pathtermination_ao);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(lamp_emission);		ADD_SPLIT_KERNEL_PROGRAM(lamp_emission);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(direct_lighting);		ADD_SPLIT_KERNEL_PROGRAM(direct_lighting);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(indirect_background);		ADD_SPLIT_KERNEL_PROGRAM(indirect_background);
ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shader_eval);		ADD_SPLIT_KERNEL_PROGRAM(shader_eval);

/* Quick kernels bundled in a single program to reduce overhead of starting		/* Quick kernels bundled in a single program to reduce overhead of starting
* Blender processes. */		* Blender processes. */
program_split = OpenCLDevice::OpenCLProgram(this,		program_split = OpenCLDevice::OpenCLProgram(this,
"split_bundle" ,		"split_bundle" ,
"kernel_split_bundle.cl",		"kernel_split_bundle.cl",
get_build_options(requested_features, "split_bundle"));		get_build_options(requested_features, "split_bundle"));

ADD_SPLIT_KERNEL_SINGLE_PROGRAM(data_init);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(data_init);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(state_buffer_size);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(state_buffer_size);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(path_init);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(path_init);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(scene_intersect);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(scene_intersect);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(queue_enqueue);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(queue_enqueue);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_setup);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_setup);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_sort);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_sort);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(enqueue_inactive);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(enqueue_inactive);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(next_iteration_setup);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(next_iteration_setup);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(indirect_subsurface);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(indirect_subsurface);
ADD_SPLIT_KERNEL_SINGLE_PROGRAM(buffer_update);		ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(buffer_update);
programs.push_back(&program_split);		programs.push_back(&program_split);
}
#undef ADD_SPLIT_KERNEL_SPLIT_PROGRAM		#undef ADD_SPLIT_KERNEL_PROGRAM
#undef ADD_SPLIT_KERNEL_SINGLE_PROGRAM		#undef ADD_SPLIT_KERNEL_BUNDLE_PROGRAM

base_program = OpenCLProgram(this, "base", "kernel_base.cl", get_build_options(requested_features, "base"));		base_program = OpenCLProgram(this, "base", "kernel_base.cl", get_build_options(requested_features, "base"));
base_program.add_kernel(ustring("convert_to_byte"));		base_program.add_kernel(ustring("convert_to_byte"));
base_program.add_kernel(ustring("convert_to_half_float"));		base_program.add_kernel(ustring("convert_to_half_float"));
base_program.add_kernel(ustring("zero_buffer"));		base_program.add_kernel(ustring("zero_buffer"));
programs.push_back(&base_program);		programs.push_back(&base_program);

if (requested_features.use_baking) {		if (requested_features.use_baking) {
▲ Show 20 Lines • Show All 1,211 Lines • Show Last 20 Lines