Disable GPU threaded optimizations option

We can disable indirectly by enabling verbose GL debug output.

Author: lawnjelly

core/os/os.h

@@ -159,6 +159,8 @@ class OS {
 
 	HasServerFeatureCallback has_server_feature_callback;
 	RenderThreadMode _render_thread_mode;
+	bool _disable_gpu_threaded_optimizations = false;
+	bool _allow_gpu_threaded_optimizations = false;
 
 	// functions used by main to initialize/deinitialize the OS
 	void add_logger(Logger *p_logger);
@@ -678,6 +680,12 @@ class OS {
 	virtual void benchmark_end_measure(const String &p_what);
 	virtual void benchmark_dump();
 
+	// Internal.
+	// Disabling takes action to prevent GPU driver threaded optimizations to help prevent jitter.
+	// Allow overrides "disable" and can be specified via the command line.
+	bool _is_gpu_threaded_optimization_disabled() const { return _disable_gpu_threaded_optimizations; }
+	void _set_gpu_threaded_optimization_allowed(bool p_allow) { _allow_gpu_threaded_optimizations = p_allow; }
+
 	virtual void process_and_drop_events() {}
 	OS();
 	virtual ~OS();

doc/classes/ProjectSettings.xml

@@ -1637,6 +1637,11 @@
 		<member name="rendering/limits/time/time_rollover_secs" type="float" setter="" getter="" default="3600">
 			Shaders have a time variable that constantly increases. At some point, it needs to be rolled back to zero to avoid precision errors on shader animations. This setting specifies when (in seconds).
 		</member>
+		<member name="rendering/misc/compatibility/driver_disable_threaded_optimizations" type="bool" setter="" getter="" default="true">
+			If [code]true[/code], attempts to disable the threaded optimization feature from the NVIDIA drivers, which are known to cause stuttering in most OpenGL applications.
+			This is done by enabling minimal OpenGL debug logging, and ignoring the output, which can force the driver to disable threaded optimization.
+			[b]Note:[/b] This setting only works on Windows, as threaded optimization is disabled by default on other platforms.
+		</member>
 		<member name="rendering/misc/lossless_compression/force_png" type="bool" setter="" getter="" default="false">
 			If [code]true[/code], the texture importer will import lossless textures using the PNG format. Otherwise, it will default to using WebP.
 		</member>

drivers/gles2/rasterizer_gles2.cpp

@@ -85,6 +85,12 @@
 #endif
 
 #ifdef CAN_DEBUG
+
+// We offer the option to disable GPU threaded optimizations indirectly by forcing debug output.
+// We aren't actually interested in the strings in this case so we try and make the call as cheap as possible.
+static void GLAPIENTRY _gl_debug_print_dummy(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
+}
+
 static void GLAPIENTRY _gl_debug_print(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
 	if (type == _EXT_DEBUG_TYPE_OTHER_ARB) {
 		return;
@@ -216,6 +222,17 @@ Error RasterizerGLES2::is_viable() {
 void RasterizerGLES2::initialize() {
 	print_verbose("Using GLES2 video driver");
 
+	// Use dummy OpenGL logging to indirectly disable threaded optimization if desired.
+	bool disable_threaded_optimization = OS::get_singleton()->_is_gpu_threaded_optimization_disabled();
+	if (disable_threaded_optimization) {
+		String video_adapter = VisualServer::get_singleton()->get_video_adapter_name().to_lower();
+
+		// Only disable for nvidia currently.
+		if (video_adapter.find("nvidia") == -1) {
+			disable_threaded_optimization = false;
+		}
+	}
+
 #ifdef GLAD_ENABLED
 	if (OS::get_singleton()->is_stdout_verbose()) {
 		if (GLAD_GL_ARB_debug_output) {
@@ -225,6 +242,14 @@ void RasterizerGLES2::initialize() {
 		} else {
 			print_line("OpenGL debugging not supported!");
 		}
+	} else if (disable_threaded_optimization) {
+		if (GLAD_GL_ARB_debug_output) {
+			glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+			glDebugMessageCallbackARB(_gl_debug_print_dummy, nullptr);
+			glEnable(_EXT_DEBUG_OUTPUT);
+		} else {
+			print_line("Disabling GPU threaded optimization via OpenGL debugging not supported by this driver.");
+		}
 	}
 #endif // GLAD_ENABLED
 
@@ -243,6 +268,9 @@ void RasterizerGLES2::initialize() {
 			GL_DEBUG_TYPE_OTHER_ARB, 1,
 			GL_DEBUG_SEVERITY_HIGH_ARB, 5, "hello");
 		*/
+	} else if (disable_threaded_optimization && GLAD_GL_ARB_debug_output) {
+		// Try to enable the minimum debug output to disable threaded optimization.
+		glDebugMessageControlARB(_EXT_DEBUG_SOURCE_API_ARB, _EXT_DEBUG_TYPE_ERROR_ARB, _EXT_DEBUG_SEVERITY_HIGH_ARB, 0, nullptr, GL_TRUE);
 	}
 #else
 	if (OS::get_singleton()->is_stdout_verbose()) {
@@ -257,6 +285,18 @@ void RasterizerGLES2::initialize() {
 			callback(_gl_debug_print, NULL);
 			glEnable(_EXT_DEBUG_OUTPUT);
 		}
+	} else if (disable_threaded_optimization) {
+		DebugMessageCallbackARB callback = (DebugMessageCallbackARB)eglGetProcAddress("glDebugMessageCallback");
+		if (!callback) {
+			callback = (DebugMessageCallbackARB)eglGetProcAddress("glDebugMessageCallbackKHR");
+		}
+
+		if (callback) {
+			print_line("godot: ENABLING GL DEBUG dummy output");
+			glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+			callback(_gl_debug_print_dummy, NULL);
+			glEnable(_EXT_DEBUG_OUTPUT);
+		}
 	}
 #endif // GLES_OVER_GL
 #endif // CAN_DEBUG

drivers/gles3/rasterizer_gles3.cpp

@@ -74,6 +74,11 @@ RasterizerScene *RasterizerGLES3::get_scene() {
 #endif
 
 #ifdef GLAD_ENABLED
+// We offer the option to disable GPU threaded optimizations indirectly by forcing debug output.
+// We aren't actually interested in the strings in this case so we try and make the call as cheap as possible.
+static void GLAPIENTRY _gl_debug_print_dummy(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
+}
+
 // Restricting to GLAD as only used in initialize() with GLAD_GL_ARB_debug_output
 static void GLAPIENTRY _gl_debug_print(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
 	if (type == _EXT_DEBUG_TYPE_OTHER_ARB) {
@@ -158,6 +163,17 @@ Error RasterizerGLES3::is_viable() {
 void RasterizerGLES3::initialize() {
 	print_verbose("Using GLES3 video driver");
 
+	// Use dummy OpenGL logging to indirectly disable threaded optimization if desired.
+	bool disable_threaded_optimization = OS::get_singleton()->_is_gpu_threaded_optimization_disabled();
+	if (disable_threaded_optimization) {
+		String video_adapter = VisualServer::get_singleton()->get_video_adapter_name().to_lower();
+
+		// Only disable for nvidia currently.
+		if (video_adapter.find("nvidia") == -1) {
+			disable_threaded_optimization = false;
+		}
+	}
+
 #ifdef GLAD_ENABLED
 	if (OS::get_singleton()->is_stdout_verbose()) {
 		if (GLAD_GL_ARB_debug_output) {
@@ -167,6 +183,14 @@ void RasterizerGLES3::initialize() {
 		} else {
 			print_line("OpenGL debugging not supported!");
 		}
+	} else if (disable_threaded_optimization) {
+		if (GLAD_GL_ARB_debug_output) {
+			glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+			glDebugMessageCallbackARB(_gl_debug_print_dummy, nullptr);
+			glEnable(_EXT_DEBUG_OUTPUT);
+		} else {
+			print_line("Disabling GPU threaded optimization via OpenGL debugging not supported by this driver.");
+		}
 	}
 #endif // GLAD_ENABLED
 

main/main.cpp

@@ -332,6 +332,7 @@ void Main::print_help(const char *p_binary) {
 	OS::get_singleton()->print("  --disable-vsync-via-compositor   Disable vsync via the OS' window compositor (Windows only).\n");
 	OS::get_singleton()->print("  --enable-delta-smoothing         When vsync is enabled, enabled frame delta smoothing.\n");
 	OS::get_singleton()->print("  --disable-delta-smoothing        Disable frame delta smoothing.\n");
+	OS::get_singleton()->print("  --allow-gpu-threaded             Override the 'driver_disable_threaded_optimizations' project setting.\n");
 	OS::get_singleton()->print("  --tablet-driver                  Tablet input driver (");
 	for (int i = 0; i < OS::get_singleton()->get_tablet_driver_count(); i++) {
 		if (i != 0) {
@@ -935,6 +936,8 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 				OS::get_singleton()->print("Missing editor PID argument, aborting.\n");
 				goto error;
 			}
+		} else if (I->get() == "--allow-gpu-multithread") {
+			OS::get_singleton()->_set_gpu_threaded_optimization_allowed(true);
 		} else if (I->get() == "--disable-render-loop") {
 			disable_render_loop = true;
 		} else if (I->get() == "--fixed-fps") {
@@ -1246,6 +1249,7 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 		rtm = GLOBAL_DEF("rendering/threads/thread_model", OS::RENDER_THREAD_SAFE);
 	}
 	GLOBAL_DEF("rendering/threads/thread_safe_bvh", false);
+	GLOBAL_DEF_RST("rendering/misc/compatibility/driver_disable_threaded_optimizations", true);
 
 	if (rtm >= 0 && rtm < 3) {
 #ifdef NO_THREADS

platform/windows/os_windows.cpp

@@ -1351,6 +1351,10 @@ int OS_Windows::get_current_video_driver() const {
 }
 
 Error OS_Windows::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
+	if (!Engine::get_singleton()->is_editor_hint()) {
+		_disable_gpu_threaded_optimizations = _allow_gpu_threaded_optimizations ? false : GLOBAL_GET("rendering/misc/compatibility/driver_disable_threaded_optimizations");
+	}
+
 	main_loop = NULL;
 	outside = true;
 	window_has_focus = true;