Merge branch 'blender2.7'

Conflicts:
	intern/cycles/blender/addon/properties.py
	intern/cycles/device/opencl/opencl_split.cpp

10 files changed, 50 insertions, 154 deletions

diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 11f75b668a9..4933c849e0d 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -722,11 +722,6 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
         update=_devices_update_callback
     )
 
-    debug_opencl_kernel_single_program: BoolProperty(
-        name="Single Program",
-        default=False,
-        update=_devices_update_callback,
-    )
     del _devices_update_callback
 
     debug_use_opencl_debug: BoolProperty(name="Debug OpenCL", default=False)
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index d0cfb5c5e72..93b16727b9a 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -1932,7 +1932,6 @@ class CYCLES_RENDER_PT_debug(CyclesButtonsPanel, Panel):
         col = layout.column()
         col.label(text='OpenCL Flags:')
         col.prop(cscene, "debug_opencl_device_type", text="Device")
-        col.prop(cscene, "debug_opencl_kernel_single_program", text="Single Program")
         col.prop(cscene, "debug_use_opencl_debug", text="Debug")
         col.prop(cscene, "debug_opencl_mem_limit")
 
diff --git a/intern/cycles/blender/blender_python.cpp b/intern/cycles/blender/blender_python.cpp
index 6cff4c0745c..4a1eeeb65c1 100644
--- a/intern/cycles/blender/blender_python.cpp
+++ b/intern/cycles/blender/blender_python.cpp
@@ -104,7 +104,6 @@ bool debug_flags_sync_from_scene(BL::Scene b_scene)
 	/* Synchronize other OpenCL flags. */
 	flags.opencl.debug = get_boolean(cscene, "debug_use_opencl_debug");
 	flags.opencl.mem_limit = ((size_t)get_int(cscene, "debug_opencl_mem_limit"))*1024*1024;
-	flags.opencl.single_program = get_boolean(cscene, "debug_opencl_kernel_single_program");
 	return flags.opencl.device_type != opencl_device_type;
 }
 
diff --git a/intern/cycles/device/opencl/opencl.h b/intern/cycles/device/opencl/opencl.h
index 6e5eab1a265..4ecf71e116e 100644
--- a/intern/cycles/device/opencl/opencl.h
+++ b/intern/cycles/device/opencl/opencl.h
@@ -95,7 +95,6 @@ public:
 	                              cl_device_id device_id);
 	static void get_usable_devices(vector<OpenCLPlatformDevice> *usable_devices,
 	                               bool force_all = false);
-	static bool use_single_program();
 
 	/* ** Some handy shortcuts to low level cl*GetInfo() functions. ** */
 
@@ -371,9 +370,9 @@ public:
 	bool load_kernels(const DeviceRequestedFeatures& requested_features);
 
 	/* Get the name of the opencl program for the given kernel */
-	const string get_opencl_program_name(bool single_program, const string& kernel_name);
+	const string get_opencl_program_name(const string& kernel_name);
 	/* Get the program file name to compile (*.cl) for the given kernel */
-	const string get_opencl_program_filename(bool single_program, const string& kernel_name);
+	const string get_opencl_program_filename(const string& kernel_name);
 	string get_build_options(const DeviceRequestedFeatures& requested_features, const string& opencl_program_name);
 
 	void mem_alloc(device_memory& mem);
diff --git a/intern/cycles/device/opencl/opencl_split.cpp b/intern/cycles/device/opencl/opencl_split.cpp
index 7012bf744ea..b575b008fe0 100644
--- a/intern/cycles/device/opencl/opencl_split.cpp
+++ b/intern/cycles/device/opencl/opencl_split.cpp
@@ -53,33 +53,23 @@ static const string fast_compiled_kernels =
 	"indirect_subsurface "
 	"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";
+	if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
+		return "split_bundle";
 	}
 	else {
-		if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
-			return "split_bundle";
-		}
-		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";
+	if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
+		return "kernel_split_bundle.cl";
 	}
 	else {
-		if (fast_compiled_kernels.find(kernel_name) != std::string::npos) {
-			return "kernel_split_bundle.cl";
-		}
-		else {
-			return "kernel_" + kernel_name + ".cl";
-		}
+		return "kernel_" + kernel_name + ".cl";
 	}
 }
 
@@ -280,12 +270,11 @@ public:
 	{
 		OpenCLSplitKernelFunction* kernel = new OpenCLSplitKernelFunction(device, cached_memory);
 
-		bool single_program = OpenCLInfo::use_single_program();
-		const string program_name = device->get_opencl_program_name(single_program, kernel_name);
+		const string program_name = device->get_opencl_program_name(kernel_name);
 		kernel->program =
 			OpenCLDevice::OpenCLProgram(device,
 			                            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));
 
 		kernel->program.add_kernel(ustring("path_trace_" + kernel_name));
@@ -663,10 +652,8 @@ bool OpenCLDevice::load_kernels(const DeviceRequestedFeatures& requested_feature
 		programs.push_back(&background_program);
 	}
 
-	bool single_program = OpenCLInfo::use_single_program();
-
-#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) \
+#define ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(kernel_name) program_split.add_kernel(ustring("path_trace_"#kernel_name));
+#define ADD_SPLIT_KERNEL_PROGRAM(kernel_name) \
 		const string program_name_##kernel_name = "split_"#kernel_name; \
 		program_##kernel_name = \
 			OpenCLDevice::OpenCLProgram(this, \
@@ -676,71 +663,41 @@ bool OpenCLDevice::load_kernels(const DeviceRequestedFeatures& requested_feature
 		program_##kernel_name.add_kernel(ustring("path_trace_"#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. */
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(subsurface_scatter);
-		if (requested_features.use_volume) {
-			ADD_SPLIT_KERNEL_SPLIT_PROGRAM(do_volume);
-		}
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shadow_blocked_dl);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shadow_blocked_ao);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(holdout_emission_blurring_pathtermination_ao);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(lamp_emission);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(direct_lighting);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(indirect_background);
-		ADD_SPLIT_KERNEL_SPLIT_PROGRAM(shader_eval);
-
-		/* Quick kernels bundled in a single program to reduce overhead of starting
-		 * Blender processes. */
-		program_split = OpenCLDevice::OpenCLProgram(this,
-		                                            "split_bundle" ,
-		                                            "kernel_split_bundle.cl",
-		                                            get_build_options(requested_features, "split_bundle"));
-
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(data_init);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(state_buffer_size);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(path_init);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(scene_intersect);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(queue_enqueue);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_setup);
-		ADD_SPLIT_KERNEL_SINGLE_PROGRAM(shader_sort);
-		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);
-	}
-#undef ADD_SPLIT_KERNEL_SPLIT_PROGRAM
-#undef ADD_SPLIT_KERNEL_SINGLE_PROGRAM
+	/* Ordered with most complex kernels first, to reduce overall compile time. */
+	ADD_SPLIT_KERNEL_PROGRAM(subsurface_scatter);
+	if (requested_features.use_volume) {
+		ADD_SPLIT_KERNEL_PROGRAM(do_volume);
+	}
+	ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_dl);
+	ADD_SPLIT_KERNEL_PROGRAM(shadow_blocked_ao);
+	ADD_SPLIT_KERNEL_PROGRAM(holdout_emission_blurring_pathtermination_ao);
+	ADD_SPLIT_KERNEL_PROGRAM(lamp_emission);
+	ADD_SPLIT_KERNEL_PROGRAM(direct_lighting);
+	ADD_SPLIT_KERNEL_PROGRAM(indirect_background);
+	ADD_SPLIT_KERNEL_PROGRAM(shader_eval);
+
+	/* Quick kernels bundled in a single program to reduce overhead of starting
+		* Blender processes. */
+	program_split = OpenCLDevice::OpenCLProgram(this,
+												"split_bundle" ,
+												"kernel_split_bundle.cl",
+												get_build_options(requested_features, "split_bundle"));
+
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(data_init);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(state_buffer_size);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(path_init);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(scene_intersect);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(queue_enqueue);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_setup);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(shader_sort);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(enqueue_inactive);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(next_iteration_setup);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(indirect_subsurface);
+	ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(buffer_update);
+	programs.push_back(&program_split);
+
+#undef ADD_SPLIT_KERNEL_PROGRAM
+#undef ADD_SPLIT_KERNEL_BUNDLE_PROGRAM
 
 	base_program = OpenCLProgram(this, "base", "kernel_base.cl", get_build_options(requested_features, "base"));
 	base_program.add_kernel(ustring("convert_to_byte"));
diff --git a/intern/cycles/device/opencl/opencl_util.cpp b/intern/cycles/device/opencl/opencl_util.cpp
index 8ef622fad01..ef0deaeff62 100644
--- a/intern/cycles/device/opencl/opencl_util.cpp
+++ b/intern/cycles/device/opencl/opencl_util.cpp
@@ -691,11 +691,6 @@ bool OpenCLInfo::use_debug()
 	return DebugFlags().opencl.debug;
 }
 
-bool OpenCLInfo::use_single_program()
-{
-	return DebugFlags().opencl.single_program;
-}
-
 bool OpenCLInfo::kernel_use_advanced_shading(const string& platform)
 {
 	/* keep this in sync with kernel_types.h! */
diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt
index 7332346a787..a35eb102c9c 100644
--- a/intern/cycles/kernel/CMakeLists.txt
+++ b/intern/cycles/kernel/CMakeLists.txt
@@ -41,7 +41,6 @@ set(SRC_OPENCL_KERNELS
 	kernels/opencl/kernel_displace.cl
 	kernels/opencl/kernel_background.cl
 	kernels/opencl/kernel_state_buffer_size.cl
-	kernels/opencl/kernel_split.cl
 	kernels/opencl/kernel_split_bundle.cl
 	kernels/opencl/kernel_data_init.cl
 	kernels/opencl/kernel_path_init.cl
diff --git a/intern/cycles/kernel/kernels/opencl/kernel_split.cl b/intern/cycles/kernel/kernels/opencl/kernel_split.cl
deleted file mode 100644
index 4cbda1bc2e7..00000000000
--- a/intern/cycles/kernel/kernels/opencl/kernel_split.cl
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2011-2017 Blender Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "kernel/kernel_compat_opencl.h"  // PRECOMPILED
-#include "kernel/split/kernel_split_common.h"  // PRECOMPILED
-
-#include "kernel/kernels/opencl/kernel_state_buffer_size.cl"
-#include "kernel/kernels/opencl/kernel_data_init.cl"
-#include "kernel/kernels/opencl/kernel_path_init.cl"
-
-#include "kernel/kernels/opencl/kernel_scene_intersect.cl"
-#include "kernel/kernels/opencl/kernel_lamp_emission.cl"
-#include "kernel/kernels/opencl/kernel_do_volume.cl"
-#include "kernel/kernels/opencl/kernel_indirect_background.cl"
-#include "kernel/kernels/opencl/kernel_queue_enqueue.cl"
-#include "kernel/kernels/opencl/kernel_shader_setup.cl"
-#include "kernel/kernels/opencl/kernel_shader_sort.cl"
-#include "kernel/kernels/opencl/kernel_shader_eval.cl"
-#include "kernel/kernels/opencl/kernel_holdout_emission_blurring_pathtermination_ao.cl"
-#include "kernel/kernels/opencl/kernel_subsurface_scatter.cl"
-#include "kernel/kernels/opencl/kernel_direct_lighting.cl"
-#include "kernel/kernels/opencl/kernel_shadow_blocked_ao.cl"
-#include "kernel/kernels/opencl/kernel_shadow_blocked_dl.cl"
-#include "kernel/kernels/opencl/kernel_enqueue_inactive.cl"
-#include "kernel/kernels/opencl/kernel_next_iteration_setup.cl"
-#include "kernel/kernels/opencl/kernel_indirect_subsurface.cl"
-#include "kernel/kernels/opencl/kernel_buffer_update.cl"
-
diff --git a/intern/cycles/util/util_debug.cpp b/intern/cycles/util/util_debug.cpp
index e8929c32394..b4cc69411ed 100644
--- a/intern/cycles/util/util_debug.cpp
+++ b/intern/cycles/util/util_debug.cpp
@@ -90,8 +90,7 @@ void DebugFlags::CUDA::reset()
 
 DebugFlags::OpenCL::OpenCL()
   : device_type(DebugFlags::OpenCL::DEVICE_ALL),
-    debug(false),
-    single_program(false)
+    debug(false)
 {
 	reset();
 }
@@ -123,7 +122,6 @@ void DebugFlags::OpenCL::reset()
 	}
 	/* Initialize other flags from environment variables. */
 	debug = (getenv("CYCLES_OPENCL_DEBUG") != NULL);
-	single_program = (getenv("CYCLES_OPENCL_SINGLE_PROGRAM") != NULL);
 }
 
 DebugFlags::DebugFlags()
@@ -179,7 +177,6 @@ std::ostream& operator <<(std::ostream &os,
 	os << "OpenCL flags:\n"
 	   << "  Device type    : " << opencl_device_type << "\n"
 	   << "  Debug          : " << string_from_bool(debug_flags.opencl.debug) << "\n"
-	   << "  Single program : " << string_from_bool(debug_flags.opencl.single_program) << "\n"
 	   << "  Memory limit   : " << string_human_readable_size(debug_flags.opencl.mem_limit) << "\n";
 	return os;
 }
diff --git a/intern/cycles/util/util_debug.h b/intern/cycles/util/util_debug.h
index 9b5eb2f9fbd..e8c272cdb80 100644
--- a/intern/cycles/util/util_debug.h
+++ b/intern/cycles/util/util_debug.h
@@ -126,9 +126,6 @@ public:
 		/* Use debug version of the kernel. */
 		bool debug;
 
-		/* Use single program */
-		bool single_program;
-
 		/* TODO(mai): Currently this is only for OpenCL, but we should have it implemented for all devices. */
 		/* Artificial memory limit in bytes (0 if disabled). */
 		size_t mem_limit;