[Bf-blender-cvs] [ac7aefd] master: Cycles: Use special debug panel to fine-tune debug flags

Sergey Sharybin noreply at git.blender.org
Tue Jan 12 12:31:35 CET 2016


Commit: ac7aefd7c2bc0e87b2787e374d414f18b7887baa
Author: Sergey Sharybin
Date:   Tue Jan 12 16:00:48 2016 +0500
Branches: master
https://developer.blender.org/rBac7aefd7c2bc0e87b2787e374d414f18b7887baa

Cycles: Use special debug panel to fine-tune debug flags

This panel is only visible when debug_value is set to 256 and has no
affect in other cases. However, if debug value is not set to this
value, environment variables will be used to control which features
are enabled, so there's no visible changes to anyone in fact.

There are some changes needed to prevent devices re-enumeration on
every Cycles session create.

Reviewers: juicyfruit, lukasstockner97, dingto, brecht

Reviewed By: lukasstockner97, dingto

Differential Revision: https://developer.blender.org/D1720

===================================================================

M	intern/cycles/blender/addon/engine.py
M	intern/cycles/blender/addon/properties.py
M	intern/cycles/blender/addon/ui.py
M	intern/cycles/blender/blender_python.cpp
M	intern/cycles/device/device.cpp
M	intern/cycles/device/device.h
M	intern/cycles/device/device_cpu.cpp
M	intern/cycles/device/device_opencl.cpp
M	intern/cycles/util/CMakeLists.txt
A	intern/cycles/util/util_debug.cpp
M	intern/cycles/util/util_debug.h
M	intern/cycles/util/util_system.cpp

===================================================================

diff --git a/intern/cycles/blender/addon/engine.py b/intern/cycles/blender/addon/engine.py
index 030f0db..19fa23b 100644
--- a/intern/cycles/blender/addon/engine.py
+++ b/intern/cycles/blender/addon/engine.py
@@ -88,6 +88,11 @@ def create(engine, data, scene, region=None, v3d=None, rv3d=None, preview_osl=Fa
     if rv3d:
         rv3d = rv3d.as_pointer()
 
+    if bpy.app.debug_value == 256:
+        _cycles.debug_flags_update(scene)
+    else:
+        _cycles.debug_flags_reset()
+
     engine.session = _cycles.create(engine.as_pointer(), userpref, data, scene, region, v3d, rv3d, preview_osl)
 
 
diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index a64a033..0d96dab 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -550,6 +550,46 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
             min=0.0, max=1.0,
             )
 
+        # Various fine-tuning debug flags
+
+        def devices_update_callback(self, context):
+            import _cycles
+            scene = context.scene.as_pointer()
+            return _cycles.debug_flags_update(scene)
+
+        cls.debug_use_cpu_avx2 = BoolProperty(name="AVX2", default=True)
+        cls.debug_use_cpu_avx = BoolProperty(name="AVX", default=True)
+        cls.debug_use_cpu_sse41 = BoolProperty(name="SSE41", default=True)
+        cls.debug_use_cpu_sse3 = BoolProperty(name="SSE3", default=True)
+        cls.debug_use_cpu_sse2 = BoolProperty(name="SSE2", default=True)
+
+        cls.debug_opencl_kernel_type = EnumProperty(
+            name="OpenCL Kernel Type",
+            default='DEFAULT',
+            items=(
+                ('DEFAULT', "Default", ""),
+                ('MEGA', "Mega", ""),
+                ('SPLIT', "Split", ""),
+                ),
+            update=devices_update_callback
+            )
+
+        cls.debug_opencl_device_type = EnumProperty(
+            name="OpenCL Device Type",
+            default='ALL',
+            items=(
+                ('NONE', "None", ""),
+                ('ALL', "All", ""),
+                ('DEFAULT', "Default", ""),
+                ('CPU', "CPU", ""),
+                ('GPU', "GPU", ""),
+                ('ACCELLERATOR', "Accellerator", ""),
+                ),
+            update=devices_update_callback
+            )
+
+        cls.debug_use_opencl_debug = BoolProperty(name="Debug OpenCL", default=False)
+
     @classmethod
     def unregister(cls):
         del bpy.types.Scene.cycles
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index 5f3406ec..76251e1 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -1459,6 +1459,39 @@ class CyclesRender_PT_bake(CyclesButtonsPanel, Panel):
             row.prop(cbk, "normal_b", text="")
 
 
+class CyclesRender_PT_debug(CyclesButtonsPanel, Panel):
+    bl_label = "Debug"
+    bl_context = "render"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'CYCLES'}
+
+    @classmethod
+    def poll(cls, context):
+        return bpy.app.debug_value == 256
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        cscene = scene.cycles
+
+        col = layout.column()
+
+        col.label('CPU Flags:')
+        row = layout.row(align=True)
+        row.prop(cscene, "debug_use_cpu_sse2", toggle=True)
+        row.prop(cscene, "debug_use_cpu_sse3", toggle=True)
+        row.prop(cscene, "debug_use_cpu_sse41", toggle=True)
+        row.prop(cscene, "debug_use_cpu_avx", toggle=True)
+        row.prop(cscene, "debug_use_cpu_avx2", toggle=True)
+
+        col = layout.column()
+        col.label('OpenCL Flags:')
+        col.prop(cscene, "debug_opencl_kernel_type", text="Kernel")
+        col.prop(cscene, "debug_opencl_device_type", text="Device")
+        col.prop(cscene, "debug_use_opencl_debug", text="Debug")
+
+
 class CyclesParticle_PT_CurveSettings(CyclesButtonsPanel, Panel):
     bl_label = "Cycles Hair Settings"
     bl_context = "particle"
diff --git a/intern/cycles/blender/blender_python.cpp b/intern/cycles/blender/blender_python.cpp
index 6581d0b..acc6f4c 100644
--- a/intern/cycles/blender/blender_python.cpp
+++ b/intern/cycles/blender/blender_python.cpp
@@ -37,13 +37,89 @@
 
 CCL_NAMESPACE_BEGIN
 
-static void *pylong_as_voidptr_typesafe(PyObject *object)
+namespace {
+
+/* Flag describing whether debug flags were synchronized from scene. */
+bool debug_flags_set = false;
+
+void *pylong_as_voidptr_typesafe(PyObject *object)
 {
 	if(object == Py_None)
 		return NULL;
 	return PyLong_AsVoidPtr(object);
 }
 
+/* Synchronize debug flags from a given Blender scene.
+ * Return truth when device list needs invalidation.
+ */
+bool debug_flags_sync_from_scene(BL::Scene b_scene)
+{
+	DebugFlagsRef flags = DebugFlags();
+	PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
+	/* Backup some settings for comparison. */
+	DebugFlags::OpenCL::DeviceType opencl_device_type = flags.opencl.device_type;
+	DebugFlags::OpenCL::KernelType opencl_kernel_type = flags.opencl.kernel_type;
+	/* Synchronize CPU flags. */
+	flags.cpu.avx2 = get_boolean(cscene, "debug_use_cpu_avx2");
+	flags.cpu.avx = get_boolean(cscene, "debug_use_cpu_avx");
+	flags.cpu.sse41 = get_boolean(cscene, "debug_use_cpu_sse41");
+	flags.cpu.sse3 = get_boolean(cscene, "debug_use_cpu_sse3");
+	flags.cpu.sse2 = get_boolean(cscene, "debug_use_cpu_sse2");
+	/* Synchronize OpenCL kernel type. */
+	switch(get_enum(cscene, "debug_opencl_kernel_type")) {
+		case 0:
+			flags.opencl.kernel_type = DebugFlags::OpenCL::KERNEL_DEFAULT;
+			break;
+		case 1:
+			flags.opencl.kernel_type = DebugFlags::OpenCL::KERNEL_MEGA;
+			break;
+		case 2:
+			flags.opencl.kernel_type = DebugFlags::OpenCL::KERNEL_SPLIT;
+			break;
+	}
+	/* Synchronize OpenCL device type. */
+	switch(get_enum(cscene, "debug_opencl_device_type")) {
+		case 0:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_NONE;
+			break;
+		case 1:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_ALL;
+			break;
+		case 2:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_DEFAULT;
+			break;
+		case 3:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_CPU;
+			break;
+		case 4:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_GPU;
+			break;
+		case 5:
+			flags.opencl.device_type = DebugFlags::OpenCL::DEVICE_ACCELERATOR;
+			break;
+	}
+	/* Synchronize other OpenCL flags. */
+	flags.opencl.debug = get_boolean(cscene, "debug_use_opencl_debug");
+	return flags.opencl.device_type != opencl_device_type ||
+	       flags.opencl.kernel_type != opencl_kernel_type;
+}
+
+/* Reset debug flags to default values.
+ * Return truth when device list needs invalidation.
+ */
+bool debug_flags_reset()
+{
+	DebugFlagsRef flags = DebugFlags();
+	/* Backup some settings for comparison. */
+	DebugFlags::OpenCL::DeviceType opencl_device_type = flags.opencl.device_type;
+	DebugFlags::OpenCL::KernelType opencl_kernel_type = flags.opencl.kernel_type;
+	flags.reset();
+	return flags.opencl.device_type != opencl_device_type ||
+	       flags.opencl.kernel_type != opencl_kernel_type;
+}
+
+}  /* namespace */
+
 void python_thread_state_save(void **python_thread_state)
 {
 	*python_thread_state = (void*)PyEval_SaveThread();
@@ -89,6 +165,9 @@ static PyObject *init_func(PyObject * /*self*/, PyObject *args)
 
 	BlenderSession::headless = headless;
 
+	VLOG(2) << "Debug flags initialized to:\n"
+	        << DebugFlags();
+
 	Py_RETURN_NONE;
 }
 
@@ -491,15 +570,49 @@ static PyObject *system_info_func(PyObject * /*self*/, PyObject * /*value*/)
 static PyObject *opencl_disable_func(PyObject * /*self*/, PyObject * /*value*/)
 {
 	VLOG(2) << "Disabling OpenCL platform.";
-#ifdef WIN32
-	putenv("CYCLES_OPENCL_TEST=NONE");
-#else
-	setenv("CYCLES_OPENCL_TEST", "NONE", 1);
-#endif
+	DebugFlags().opencl.device_type = DebugFlags::OpenCL::DEVICE_NONE;
 	Py_RETURN_NONE;
 }
 #endif
 
+static PyObject *debug_flags_update_func(PyObject * /*self*/, PyObject *args)
+{
+	PyObject *pyscene;
+	if(!PyArg_ParseTuple(args, "O", &pyscene)) {
+		return NULL;
+	}
+
+	PointerRNA sceneptr;
+	RNA_id_pointer_create((ID*)PyLong_AsVoidPtr(pyscene), &sceneptr);
+	BL::Scene b_scene(sceneptr);
+
+	if(debug_flags_sync_from_scene(b_scene)) {
+		VLOG(2) << "Tagging device list for update.";
+		Device::tag_update();
+	}
+
+	VLOG(2) << "Debug flags set to:\n"
+	        << DebugFlags();
+
+	debug_flags_set = true;
+
+	Py_RETURN_NONE;
+}
+
+static PyObject *debug_flags_reset_func(PyObject * /*self*/, PyObject * /*args*/)
+{
+	if(debug_flags_reset()) {
+		VLOG(2) << "Tagging device list for update.";
+		Device::tag_update();
+	}
+	if(debug_flags_set) {
+		VLOG(2) << "Debug flags reset to:\n"
+		        << DebugFlags();
+		debug_flags_set = false;
+	}
+	Py_RETURN_NONE;
+}
+
 static PyMethodDef methods[] = {
 	{"init", init_func, METH_VARARGS, ""},
 	{"create", create_func, METH_VARARGS, ""},
@@ -518,6 +631,8 @@ static PyMethodDef methods[] = {
 #ifdef WITH_OPENCL
 	{"opencl_disable", opencl_disable_func, METH_NOARGS, ""},
 #endif
+	{"debug_flags_update", debug_flags_update_func, METH_VARARGS, ""},
+	{"debug_flags_reset", debug_flags_reset_func, METH_NOARGS, ""},
 	{NULL, NULL, 0, NULL},
 };
 
diff --git a/intern/cycles/device/device.cpp b/intern/cycles/device/device.cpp
index 929f810..fd52b11 100644
--- a/intern/cycles/device/device.cpp
+++ b/intern/cycles/device/device.cpp
@@ -32,6 +32,9 @@
 
 CCL_NAMESPACE_BEGIN
 
+bool Device::need_types_update = true;
+bool Device::need_devices_update = true;
+
 /* Device Requested Features */
 
 std::ostream& operator <<(std::ostream &os,
@@ -278,9 +281,9 @@ string Device::string_from_type(DeviceType type)
 vector<DeviceType>& Device::available_types()
 {
 	static vector<DeviceType> types;
-	static bool types_init = false;
 
-	if(!types_init) {
+	if(need_types_update) {
+		types.clear();
 		types.push_back(DEVICE_CPU);
 
 #ifdef WITH_CUDA
@@ -300,7 +303,7 @@ vector<DeviceType>& Device::available_types()
 		types.push_back(DEVICE_MULTI);
 #endif
 
-		types_init = true;
+		need_types_update = false;
 	}
 
 	return types;
@@ -309,9 +312,9 @@ vector<DeviceType>&

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list