Vulkan: Uber-shader generated code optimization

.gitattributes

-*                  text=auto
-*.sln              eol=crlf
-*.vcxproj          eol=crlf
-*.vcxproj.filters  eol=crlf
-*.bat              eol=crlf
-*.rc               eol=crlf
-**/compiled/*.h    eol=crlf
-*.sh               eol=lf
-*.gn               eol=lf
+*                    text=auto
+*.sln                eol=crlf
+*.vcxproj            eol=crlf
+*.vcxproj.filters    eol=crlf
+*.bat                eol=crlf
+*.rc                 eol=crlf
+**/compiled/*.h      eol=crlf
+**/shaders/gen/*.inc eol=lf
+*.sh                 eol=lf
+*.gn                 eol=lf

scripts/run_code_generation_hashes.json

@@ -76,7 +76,7 @@
   "Vulkan format:src/libANGLE/renderer/vulkan/vk_format_map.json":
     "0c14ee33bcec99ee02eb6b39da046bc0",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py":
-    "1238d8d25cb48875863f96a2577a13b1",
+    "9a93f403b41bf6659f94e841d55b73b4",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/FullScreenQuad.vert":
     "1743adf55153edf91363fa7b4350d859",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/PushConstantColor.frag":

src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py

@@ -47,6 +47,29 @@ struct ShaderBlob
 }};
 
 {shader_tables_cpp}
+
+angle::Result GetShader(Context *context,
+                        RefCounted<ShaderAndSerial> *shaders,
+                        const ShaderBlob *shaderBlobs,
+                        size_t shadersCount,
+                        uint32_t shaderFlags,
+                        RefCounted<ShaderAndSerial> **shaderOut)
+{{
+    ASSERT(shaderFlags < shadersCount);
+    RefCounted<ShaderAndSerial> &shader = shaders[shaderFlags];
+    *shaderOut                          = &shader;
+
+    if (shader.get().valid())
+    {{
+        return angle::Result::Continue();
+    }}
+
+    // Create shader lazily. Access will need to be locked for multi-threading.
+    const ShaderBlob &shaderCode = shaderBlobs[shaderFlags];
+    ASSERT(shaderCode.code != nullptr);
+
+    return InitShaderAndSerial(context, &shader.get(), shaderCode.code, shaderCode.codeSize);
+}}
 }}  // anonymous namespace
 
 
@@ -472,21 +495,8 @@ def get_get_function_cpp(shader_and_variation):
 
     definition = 'angle::Result ShaderLibrary::%s' % function_name
     definition += '(Context *context, uint32_t shaderFlags, RefCounted<ShaderAndSerial> **shaderOut)\n{\n'
-    definition += 'ASSERT(shaderFlags < ArraySize(%s));\n' % constant_table_name
-
-    definition += ''.join(['ASSERT((shaderFlags & %s::k%sMask) >= %s::k%s &&' %
-        (namespace_name, enums[e][0], namespace_name, enums[e][1][0]) +
-        '(shaderFlags & %s::k%sMask) <= %s::k%s);\n' %
-        (namespace_name, enums[e][0], namespace_name, enums[e][1][-1])
-        for e in range(len(enums))])
-
-    definition += 'RefCounted<ShaderAndSerial> &shader = %s[shaderFlags];\n' % member_table_name
-    definition += '*shaderOut              = &shader;\n\n'
-    definition += 'if (shader.get().valid())\n{\nreturn angle::Result::Continue();\n}\n\n'
-    definition += '// Create shader lazily. Access will need to be locked for multi-threading.\n'
-    definition += 'const ShaderBlob &shaderCode = %s[shaderFlags];\n' % constant_table_name
-    definition += 'return InitShaderAndSerial(context, &shader.get(), shaderCode.code, shaderCode.codeSize);\n'
-    definition += '}\n'
+    definition += 'return GetShader(context, %s, %s, ArraySize(%s), shaderFlags, shaderOut);\n}\n' % (
+            member_table_name, constant_table_name, constant_table_name)
 
     return definition
 

src/libANGLE/renderer/vulkan/shaders/src/README.md → src/libANGLE/renderer/vulkan/shaders/README.md

@@ -2,7 +2,8 @@
 
 To build multiple variations of a shader, add a file named X.json corresponding to shader file X.  A
 variation is generated by building the shader with different definitions (a la glslang_validator's
--DName=1).  These definitions come from flags and enumerations defined in the json file.
+-DName=1).  These definitions come from flags and enumerations defined in the json file.  Without a
+.json file, the shader is generated as is (1 variation).
 
 There are multiple possible fields in the json file:
 

src/libANGLE/renderer/vulkan/shaders/gen/FullScreenQuad.vert.00000000.inc

@@ -34,22 +34,22 @@ const uint32_t kFullScreenQuad_vert_00000000[] = {
 	0x0000001c,0x0000001b,0x0003003e,0x0000001e,0x00000019,0x00050041,0x0000001f,0x00000020,
 	0x0000001e,0x0000001c,0x0004003d,0x00000007,0x00000021,0x00000020,0x00050041,0x00000022,
 	0x00000023,0x0000000d,0x0000000f,0x0003003e,0x00000023,0x00000021,0x000100fd,0x00010038
-};
-
-#if 0  // Generated from:
-#version 450 core
-
-const vec4 kQuadVertices[]= {
-    vec4(- 1, 1, 0, 1),
-    vec4(- 1, - 1, 0, 1),
-    vec4(1, - 1, 0, 1),
-    vec4(- 1, 1, 0, 1),
-    vec4(1, - 1, 0, 1),
-    vec4(1, 1, 0, 1),
-};
-
-void main()
-{
-    gl_Position = kQuadVertices[gl_VertexIndex];
-}
-#endif  // Preprocessed code
+};
+
+#if 0  // Generated from:
+#version 450 core
+
+const vec4 kQuadVertices[]= {
+    vec4(- 1, 1, 0, 1),
+    vec4(- 1, - 1, 0, 1),
+    vec4(1, - 1, 0, 1),
+    vec4(- 1, 1, 0, 1),
+    vec4(1, - 1, 0, 1),
+    vec4(1, 1, 0, 1),
+};
+
+void main()
+{
+    gl_Position = kQuadVertices[gl_VertexIndex];
+}
+#endif  // Preprocessed code

src/libANGLE/renderer/vulkan/shaders/gen/PushConstantColor.frag.00000000.inc

@@ -17,19 +17,19 @@ const uint32_t kPushConstantColor_frag_00000000[] = {
 	0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,
 	0x0000000f,0x00000010,0x0000000c,0x0000000e,0x0004003d,0x00000007,0x00000011,0x00000010,
 	0x0003003e,0x00000009,0x00000011,0x000100fd,0x00010038
-};
-
-#if 0  // Generated from:
-#version 450 core
-
-layout(push_constant)uniform block {
-    vec4 colorIn;
-};
-
-layout(location = 0)out vec4 colorOut;
-
-void main()
-{
-    colorOut = colorIn;
-}
-#endif  // Preprocessed code
+};
+
+#if 0  // Generated from:
+#version 450 core
+
+layout(push_constant)uniform block {
+    vec4 colorIn;
+};
+
+layout(location = 0)out vec4 colorOut;
+
+void main()
+{
+    colorOut = colorIn;
+}
+#endif  // Preprocessed code

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.cpp

@@ -32,6 +32,29 @@ constexpr ShaderBlob kFullScreenQuad_vert_shaders[] = {
 constexpr ShaderBlob kPushConstantColor_frag_shaders[] = {
     {kPushConstantColor_frag_00000000, sizeof(kPushConstantColor_frag_00000000)},
 };
+
+angle::Result GetShader(Context *context,
+                        RefCounted<ShaderAndSerial> *shaders,
+                        const ShaderBlob *shaderBlobs,
+                        size_t shadersCount,
+                        uint32_t shaderFlags,
+                        RefCounted<ShaderAndSerial> **shaderOut)
+{
+    ASSERT(shaderFlags < shadersCount);
+    RefCounted<ShaderAndSerial> &shader = shaders[shaderFlags];
+    *shaderOut                          = &shader;
+
+    if (shader.get().valid())
+    {
+        return angle::Result::Continue();
+    }
+
+    // Create shader lazily. Access will need to be locked for multi-threading.
+    const ShaderBlob &shaderCode = shaderBlobs[shaderFlags];
+    ASSERT(shaderCode.code != nullptr);
+
+    return InitShaderAndSerial(context, &shader.get(), shaderCode.code, shaderCode.codeSize);
+}
 }  // anonymous namespace
 
 ShaderLibrary::ShaderLibrary() {}
@@ -54,36 +77,16 @@ angle::Result ShaderLibrary::getFullScreenQuad_vert(Context *context,
                                                     uint32_t shaderFlags,
                                                     RefCounted<ShaderAndSerial> **shaderOut)
 {
-    ASSERT(shaderFlags < ArraySize(kFullScreenQuad_vert_shaders));
-    RefCounted<ShaderAndSerial> &shader = mFullScreenQuad_vert_shaders[shaderFlags];
-    *shaderOut                          = &shader;
-
-    if (shader.get().valid())
-    {
-        return angle::Result::Continue();
-    }
-
-    // Create shader lazily. Access will need to be locked for multi-threading.
-    const ShaderBlob &shaderCode = kFullScreenQuad_vert_shaders[shaderFlags];
-    return InitShaderAndSerial(context, &shader.get(), shaderCode.code, shaderCode.codeSize);
+    return GetShader(context, mFullScreenQuad_vert_shaders, kFullScreenQuad_vert_shaders,
+                     ArraySize(kFullScreenQuad_vert_shaders), shaderFlags, shaderOut);
 }
 
 angle::Result ShaderLibrary::getPushConstantColor_frag(Context *context,
                                                        uint32_t shaderFlags,
                                                        RefCounted<ShaderAndSerial> **shaderOut)
 {
-    ASSERT(shaderFlags < ArraySize(kPushConstantColor_frag_shaders));
-    RefCounted<ShaderAndSerial> &shader = mPushConstantColor_frag_shaders[shaderFlags];
-    *shaderOut                          = &shader;
-
-    if (shader.get().valid())
-    {
-        return angle::Result::Continue();
-    }
-
-    // Create shader lazily. Access will need to be locked for multi-threading.
-    const ShaderBlob &shaderCode = kPushConstantColor_frag_shaders[shaderFlags];
-    return InitShaderAndSerial(context, &shader.get(), shaderCode.code, shaderCode.codeSize);
+    return GetShader(context, mPushConstantColor_frag_shaders, kPushConstantColor_frag_shaders,
+                     ArraySize(kPushConstantColor_frag_shaders), shaderFlags, shaderOut);
 }
 
 }  // namespace vk