Compile the D3D11 VS and PS on separate threads at GL link time

src/common/angleutils.cpp

@@ -29,7 +29,8 @@ size_t FormatStringIntoVector(const char *fmt, va_list vararg, std::vector<char>
 
 std::string FormatString(const char *fmt, va_list vararg)
 {
-    static std::vector<char> buffer(512);
+    // Note: this needs to be thread-safe, since the D3D11 renderer uses some multithreading
+    std::vector<char> buffer(512);
 
     size_t len = FormatStringIntoVector(fmt, vararg, buffer);
     return std::string(&buffer[0], len);

src/libANGLE/features.h

@@ -37,4 +37,9 @@
 #define ANGLE_SHADER_DEBUG_INFO ANGLE_DISABLED
 #endif
 
+// Should we compile the D3D vertex and pixel shaders on separate threads at glLinkProgram() time?
+#if !defined(ANGLE_MULTITHREADED_D3D_SHADER_COMPILE)
+#define ANGLE_MULTITHREADED_D3D_SHADER_COMPILE ANGLE_ENABLED
+#endif
+
 #endif // LIBANGLE_FEATURES_H_

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -20,6 +20,14 @@
 #include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
 
+#if ANGLE_MULTITHREADED_D3D_SHADER_COMPILE == ANGLE_ENABLED
+// We do not want to set _HAS_EXCEPTIONS=1 for Clang builds, nor turn on exception handlers.
+// We therefore must disable C4530 to allow <future> to compile.
+#pragma warning(disable: 4530) // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
+#include <eh.h> // To allow <future> to compile when _HAS_EXCEPTIONS=0.
+#include <future> // For std::async
+#endif // ANGLE_MULTITHREADED_D3D_SHADER_COMPILE == ANGLE_ENABLED
+
 namespace rx
 {
 
@@ -946,6 +954,7 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::VertexFormat i
     }
     else if (!infoLog)
     {
+        // This isn't thread-safe, so we should ensure that we always pass in an infoLog if using multiple threads.
         std::vector<char> tempCharBuffer(tempInfoLog.getLength() + 3);
         tempInfoLog.getLog(tempInfoLog.getLength(), NULL, &tempCharBuffer[0]);
         ERR("Error compiling dynamic vertex executable:\n%s\n", &tempCharBuffer[0]);
@@ -961,18 +970,49 @@ LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog, gl::Shade
     ShaderD3D *vertexShaderD3D = ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
     ShaderD3D *fragmentShaderD3D = ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
 
-    gl::VertexFormat defaultInputLayout[gl::MAX_VERTEX_ATTRIBS];
-    GetDefaultInputLayoutFromShader(vertexShader->getActiveAttributes(), defaultInputLayout);
-    ShaderExecutableD3D *defaultVertexExecutable = NULL;
-    gl::Error error = getVertexExecutableForInputLayout(defaultInputLayout, &defaultVertexExecutable, &infoLog);
-    if (error.isError())
+    gl::Error vertexShaderResult(GL_NO_ERROR);
+    gl::InfoLog tempVertexShaderInfoLog;
+
+#if ANGLE_MULTITHREADED_D3D_SHADER_COMPILE == ANGLE_ENABLED
+    // Use an async task to begin compiling the vertex shader asynchronously on its own task.
+    std::future<ShaderExecutableD3D*> vertexShaderTask = std::async([this, vertexShader, &tempVertexShaderInfoLog, &vertexShaderResult]()
     {
-        return LinkResult(false, error);
-    }
+#endif // ANGLE_MULTITHREADED_D3D_SHADER_COMPILE
+
+        gl::VertexFormat defaultInputLayout[gl::MAX_VERTEX_ATTRIBS];
+        GetDefaultInputLayoutFromShader(vertexShader->getActiveAttributes(), defaultInputLayout);
+        ShaderExecutableD3D *defaultVertexExecutable = NULL;
+        vertexShaderResult = getVertexExecutableForInputLayout(defaultInputLayout, &defaultVertexExecutable, &tempVertexShaderInfoLog);
 
+#if ANGLE_MULTITHREADED_D3D_SHADER_COMPILE == ANGLE_ENABLED
+        return defaultVertexExecutable;
+    });
+#endif // ANGLE_MULTITHREADED_D3D_SHADER_COMPILE
+
+    // Continue to compile the pixel shader on the main thread
     std::vector<GLenum> defaultPixelOutput = GetDefaultOutputLayoutFromShader(getPixelShaderKey());
     ShaderExecutableD3D *defaultPixelExecutable = NULL;
-    error = getPixelExecutableForOutputLayout(defaultPixelOutput, &defaultPixelExecutable, &infoLog);
+    gl::Error error = getPixelExecutableForOutputLayout(defaultPixelOutput, &defaultPixelExecutable, &infoLog);
+
+#if ANGLE_MULTITHREADED_D3D_SHADER_COMPILE == ANGLE_ENABLED
+    // Call .get() on the vertex shader compilation. This waits until the task is complete before returning
+    ShaderExecutableD3D *defaultVertexExecutable = vertexShaderTask.get();
+#endif // ANGLE_MULTITHREADED_D3D_SHADER_COMPILE
+
+    // Combine the temporary infoLog with the real one
+    if (tempVertexShaderInfoLog.getLength() > 0)
+    {
+        std::vector<char> tempCharBuffer(tempVertexShaderInfoLog.getLength() + 3);
+        tempVertexShaderInfoLog.getLog(tempVertexShaderInfoLog.getLength(), NULL, &tempCharBuffer[0]);
+        infoLog.append(&tempCharBuffer[0]);
+    }
+
+    if (vertexShaderResult.isError())
+    {
+        return LinkResult(false, vertexShaderResult);
+    }
+
+    // If the pixel shader compilation failed, then return error
     if (error.isError())
     {
         return LinkResult(false, error);