Add-support-for-SPV_NV_compute_shader_derivatives

SPIRV/GLSL.ext.NV.h

@@ -33,7 +33,7 @@ enum Op;
 enum Capability;
 
 static const int GLSLextNVVersion = 100;
-static const int GLSLextNVRevision = 6;
+static const int GLSLextNVRevision = 7;
 
 //SPV_NV_sample_mask_override_coverage
 const char* const E_SPV_NV_sample_mask_override_coverage = "SPV_NV_sample_mask_override_coverage";
@@ -57,4 +57,7 @@ const char* const E_SPV_NV_shader_subgroup_partitioned = "SPV_NV_shader_subgroup
 //SPV_NV_fragment_shader_barycentric
 const char* const E_SPV_NV_fragment_shader_barycentric = "SPV_NV_fragment_shader_barycentric";
 
+//SPV_NV_compute_shader_derivatives
+const char* const E_SPV_NV_compute_shader_derivatives = "SPV_NV_compute_shader_derivatives";
+
 #endif  // #ifndef GLSLextNV_H
\ No newline at end of file

SPIRV/GlslangToSpv.cpp

@@ -1300,6 +1300,17 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl
         builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
                                                                            glslangIntermediate->getLocalSize(1),
                                                                            glslangIntermediate->getLocalSize(2));
+#ifdef NV_EXTENSIONS
+        if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
+            builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
+            builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
+        } else if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupLinear) {
+            builder.addCapability(spv::CapabilityComputeDerivativeGroupLinearNV);
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupLinearNV);
+            builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
+        }
+#endif
         break;
 
     default:
@@ -4093,7 +4104,13 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
     if (cracked.lod) {
         params.lod = arguments[2 + extraArgs];
         ++extraArgs;
-    } else if (glslangIntermediate->getStage() != EShLangFragment) {
+    } else if (glslangIntermediate->getStage() != EShLangFragment
+#ifdef NV_EXTENSIONS
+        // NV_compute_shader_derivatives layout qualifiers allow for implicit LODs
+           && !(glslangIntermediate->getStage() == EShLangCompute &&
+                (glslangIntermediate->getLayoutDerivativeModeNone() != glslang::LayoutDerivativeNone))
+#endif
+        ) {
         // we need to invent the default lod for an explicit lod instruction for a non-fragment stage
         noImplicitLod = true;
     }

SPIRV/doc.cpp

@@ -166,6 +166,12 @@ const char* ExecutionModeString(int mode)
     case 32: return "Bad";
 
     case 4446:  return "PostDepthCoverage";
+
+#ifdef NV_EXTENSIONS
+    case ExecutionModeDerivativeGroupQuadsNV:   return "DerivativeGroupQuadsNV";
+    case ExecutionModeDerivativeGroupLinearNV:  return "DerivativeGroupLinearNV";
+#endif
+
     case ExecutionModeCeiling:
     default: return "Bad";
     }
@@ -823,13 +829,15 @@ const char* CapabilityString(int info)
 
     case CapabilitySampleMaskPostDepthCoverage:  return "SampleMaskPostDepthCoverage";
 #ifdef NV_EXTENSIONS
-    case CapabilityGeometryShaderPassthroughNV:  return "GeometryShaderPassthroughNV";
-    case CapabilityShaderViewportIndexLayerNV:   return "ShaderViewportIndexLayerNV";
-    case CapabilityShaderViewportMaskNV:         return "ShaderViewportMaskNV";
-    case CapabilityShaderStereoViewNV:           return "ShaderStereoViewNV";
-    case CapabilityPerViewAttributesNV:          return "PerViewAttributesNV";
-    case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV";
-    case CapabilityFragmentBarycentricNV:        return "FragmentBarycentricNV";
+    case CapabilityGeometryShaderPassthroughNV:     return "GeometryShaderPassthroughNV";
+    case CapabilityShaderViewportIndexLayerNV:      return "ShaderViewportIndexLayerNV";
+    case CapabilityShaderViewportMaskNV:            return "ShaderViewportMaskNV";
+    case CapabilityShaderStereoViewNV:              return "ShaderStereoViewNV";
+    case CapabilityPerViewAttributesNV:             return "PerViewAttributesNV";
+    case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
+    case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
+    case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
+    case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
 #endif
 
     case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";

Test/spv.computeShaderDerivatives.comp

+#version 450
+#extension GL_NV_compute_shader_derivatives : require
+
+layout (local_size_x = 2, local_size_y = 4) in;
+layout(derivative_group_quadsNV) in;
+
+buffer block {
+  float fDerivativeX;
+  float fDerivativeY;
+  float fDerivativeWidth;
+  float fCoarseDerivativeX;
+  float fCoarseDerivativeY;
+  float fCoarseDerivativeWidth;
+  float fFineDerivativeX;
+  float fFineDerivativeY;
+  float fFineDerivativeWidth;
+  
+  float fX;
+  float fY;
+  
+  
+  vec2 v2DerivativeX;
+  vec2 v2DerivativeY;
+  vec2 v2DerivativeWidth;
+  vec2 v2CoarseDerivativeX;
+  vec2 v2CoarseDerivativeY;
+  vec2 v2CoarseDerivativeWidth;
+  vec2 v2FineDerivativeX;
+  vec2 v2FineDerivativeY;
+  vec2 v2FineDerivativeWidth;
+  
+  vec2 v2X;
+  vec2 v2Y;
+  
+  
+  vec3 v3DerivativeX;
+  vec3 v3DerivativeY;
+  vec3 v3DerivativeWidth;
+  vec3 v3CoarseDerivativeX;
+  vec3 v3CoarseDerivativeY;
+  vec3 v3CoarseDerivativeWidth;
+  vec3 v3FineDerivativeX;
+  vec3 v3FineDerivativeY;
+  vec3 v3FineDerivativeWidth;
+  
+  vec3 v3X;
+  vec3 v3Y;
+  
+  
+  vec4 v4DerivativeX;
+  vec4 v4DerivativeY;
+  vec4 v4DerivativeWidth;
+  vec4 v4CoarseDerivativeX;
+  vec4 v4CoarseDerivativeY;
+  vec4 v4CoarseDerivativeWidth;
+  vec4 v4FineDerivativeX;
+  vec4 v4FineDerivativeY;
+  vec4 v4FineDerivativeWidth;
+  
+  vec4 v4X;
+  vec4 v4Y;
+};
+
+void main(){
+    fDerivativeX = dFdx(fX);
+    fDerivativeY = dFdy(fY);
+    fDerivativeWidth = fwidth(fX);
+    fCoarseDerivativeX = dFdxCoarse(fX);
+    fCoarseDerivativeY = dFdyCoarse(fY);
+    fCoarseDerivativeWidth = fwidthCoarse(fX);
+    fFineDerivativeX = dFdxFine(fX);
+    fFineDerivativeY = dFdyFine(fY);
+    fFineDerivativeWidth = fwidthFine(fX);
+
+    v2DerivativeX = dFdx(v2X);
+    v2DerivativeY = dFdy(v2Y);
+    v2DerivativeWidth = fwidth(v2X);
+    v2CoarseDerivativeX = dFdxCoarse(v2X);
+    v2CoarseDerivativeY = dFdyCoarse(v2Y);
+    v2CoarseDerivativeWidth = fwidthCoarse(v2X);
+    v2FineDerivativeX = dFdxFine(v2X);
+    v2FineDerivativeY = dFdyFine(v2Y);
+    v2FineDerivativeWidth = fwidthFine(v2X);
+
+
+    v3DerivativeX = dFdx(v3X);
+    v3DerivativeY = dFdy(v3Y);
+    v3DerivativeWidth = fwidth(v3X);
+    v3CoarseDerivativeX = dFdxCoarse(v3X);
+    v3CoarseDerivativeY = dFdyCoarse(v3Y);
+    v3CoarseDerivativeWidth = fwidthCoarse(v3X);
+    v3FineDerivativeX = dFdxFine(v3X);
+    v3FineDerivativeY = dFdyFine(v3Y);
+    v3FineDerivativeWidth = fwidthFine(v3X);
+
+
+    v4DerivativeX = dFdx(v4X);
+    v4DerivativeY = dFdy(v4Y);
+    v4DerivativeWidth = fwidth(v4X);
+    v4CoarseDerivativeX = dFdxCoarse(v4X);
+    v4CoarseDerivativeY = dFdyCoarse(v4Y);
+    v4CoarseDerivativeWidth = fwidthCoarse(v4X);
+    v4FineDerivativeX = dFdxFine(v4X);
+    v4FineDerivativeY = dFdyFine(v4Y);
+    v4FineDerivativeWidth = fwidthFine(v4X);
+}

Test/spv.computeShaderDerivatives2.comp

+#version 320 es
+#extension GL_NV_compute_shader_derivatives : require
+
+layout (local_size_x = 2, local_size_y = 4) in;
+layout(derivative_group_linearNV) in;
+
+buffer block {
+  float fDerivativeX;
+  float fDerivativeY;
+  float fDerivativeWidth;
+  float fCoarseDerivativeX;
+  float fCoarseDerivativeY;
+  float fCoarseDerivativeWidth;
+  float fFineDerivativeX;
+  float fFineDerivativeY;
+  float fFineDerivativeWidth;
+  
+  float fX;
+  float fY;
+  
+  
+  vec2 v2DerivativeX;
+  vec2 v2DerivativeY;
+  vec2 v2DerivativeWidth;
+  vec2 v2CoarseDerivativeX;
+  vec2 v2CoarseDerivativeY;
+  vec2 v2CoarseDerivativeWidth;
+  vec2 v2FineDerivativeX;
+  vec2 v2FineDerivativeY;
+  vec2 v2FineDerivativeWidth;
+  
+  vec2 v2X;
+  vec2 v2Y;
+  
+  
+  vec3 v3DerivativeX;
+  vec3 v3DerivativeY;
+  vec3 v3DerivativeWidth;
+  vec3 v3CoarseDerivativeX;
+  vec3 v3CoarseDerivativeY;
+  vec3 v3CoarseDerivativeWidth;
+  vec3 v3FineDerivativeX;
+  vec3 v3FineDerivativeY;
+  vec3 v3FineDerivativeWidth;
+  
+  vec3 v3X;
+  vec3 v3Y;
+  
+  
+  vec4 v4DerivativeX;
+  vec4 v4DerivativeY;
+  vec4 v4DerivativeWidth;
+  vec4 v4CoarseDerivativeX;
+  vec4 v4CoarseDerivativeY;
+  vec4 v4CoarseDerivativeWidth;
+  vec4 v4FineDerivativeX;
+  vec4 v4FineDerivativeY;
+  vec4 v4FineDerivativeWidth;
+  
+  vec4 v4X;
+  vec4 v4Y;
+};
+
+void main(){
+    fDerivativeX = dFdx(fX);
+    fDerivativeY = dFdy(fY);
+    fDerivativeWidth = fwidth(fX);
+    fCoarseDerivativeX = dFdxCoarse(fX);
+    fCoarseDerivativeY = dFdyCoarse(fY);
+    fCoarseDerivativeWidth = fwidthCoarse(fX);
+    fFineDerivativeX = dFdxFine(fX);
+    fFineDerivativeY = dFdyFine(fY);
+    fFineDerivativeWidth = fwidthFine(fX);
+
+    v2DerivativeX = dFdx(v2X);
+    v2DerivativeY = dFdy(v2Y);
+    v2DerivativeWidth = fwidth(v2X);
+    v2CoarseDerivativeX = dFdxCoarse(v2X);
+    v2CoarseDerivativeY = dFdyCoarse(v2Y);
+    v2CoarseDerivativeWidth = fwidthCoarse(v2X);
+    v2FineDerivativeX = dFdxFine(v2X);
+    v2FineDerivativeY = dFdyFine(v2Y);
+    v2FineDerivativeWidth = fwidthFine(v2X);
+
+
+    v3DerivativeX = dFdx(v3X);
+    v3DerivativeY = dFdy(v3Y);
+    v3DerivativeWidth = fwidth(v3X);
+    v3CoarseDerivativeX = dFdxCoarse(v3X);
+    v3CoarseDerivativeY = dFdyCoarse(v3Y);
+    v3CoarseDerivativeWidth = fwidthCoarse(v3X);
+    v3FineDerivativeX = dFdxFine(v3X);
+    v3FineDerivativeY = dFdyFine(v3Y);
+    v3FineDerivativeWidth = fwidthFine(v3X);
+
+
+    v4DerivativeX = dFdx(v4X);
+    v4DerivativeY = dFdy(v4Y);
+    v4DerivativeWidth = fwidth(v4X);
+    v4CoarseDerivativeX = dFdxCoarse(v4X);
+    v4CoarseDerivativeY = dFdyCoarse(v4Y);
+    v4CoarseDerivativeWidth = fwidthCoarse(v4X);
+    v4FineDerivativeX = dFdxFine(v4X);
+    v4FineDerivativeY = dFdyFine(v4Y);
+    v4FineDerivativeWidth = fwidthFine(v4X);
+}

glslang/Include/Types.h

@@ -1066,7 +1066,9 @@ struct TShaderQualifiers {
     int numViews;             // multiview extenstions
 
 #ifdef NV_EXTENSIONS
-    bool layoutOverrideCoverage;    // true if layout override_coverage set
+    bool layoutOverrideCoverage;        // true if layout override_coverage set
+    bool layoutDerivativeGroupQuads;    // true if layout derivative_group_quadsNV set
+    bool layoutDerivativeGroupLinear;   // true if layout derivative_group_linearNV set
 #endif
 
     void init()
@@ -1092,6 +1094,9 @@ struct TShaderQualifiers {
         numViews = TQualifier::layoutNotSet;
 #ifdef NV_EXTENSIONS
         layoutOverrideCoverage = false;
+        layoutDerivativeGroupQuads = false;
+        layoutDerivativeGroupLinear = false;
+
 #endif
     }
 
@@ -1136,6 +1141,10 @@ struct TShaderQualifiers {
 #ifdef NV_EXTENSIONS
         if (src.layoutOverrideCoverage)
             layoutOverrideCoverage = src.layoutOverrideCoverage;
+        if (src.layoutDerivativeGroupQuads)
+            layoutDerivativeGroupQuads = src.layoutDerivativeGroupQuads;
+        if (src.layoutDerivativeGroupLinear)
+            layoutDerivativeGroupLinear = src.layoutDerivativeGroupLinear;
 #endif
     }
 };

glslang/MachineIndependent/ParseHelper.cpp

@@ -4623,6 +4623,18 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
             return;
         }
     }
+    if (language == EShLangCompute) {
+        if (id.compare(0, 17, "derivative_group_") == 0) {
+            requireExtensions(loc, 1, &E_GL_NV_compute_shader_derivatives, "compute shader derivatives");
+            if (id == "derivative_group_quadsnv") {
+                publicType.shaderQualifiers.layoutDerivativeGroupQuads = true;
+                return;
+            } else if (id == "derivative_group_linearnv") {
+                publicType.shaderQualifiers.layoutDerivativeGroupLinear = true;
+                return;
+            }
+        }
+    }
 #else
     }
 #endif
@@ -7027,6 +7039,36 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con
             error(loc, "can only apply to 'out'", "blend equation", "");
     }
 
+#ifdef NV_EXTENSIONS
+    if (publicType.shaderQualifiers.layoutDerivativeGroupQuads &&
+        publicType.shaderQualifiers.layoutDerivativeGroupLinear) {
+        error(loc, "cannot be both specified", "derivative_group_quadsNV and derivative_group_linearNV", "");
+    }
+
+    if (publicType.shaderQualifiers.layoutDerivativeGroupQuads) {
+        if (publicType.qualifier.storage == EvqVaryingIn) {
+            if ((intermediate.getLocalSize(0) & 1) ||
+                (intermediate.getLocalSize(1) & 1))
+                error(loc, "requires local_size_x and local_size_y to be multiple of two", "derivative_group_quadsNV", "");
+            else
+                intermediate.setLayoutDerivativeMode(LayoutDerivativeGroupQuads);
+        }
+        else
+            error(loc, "can only apply to 'in'", "derivative_group_quadsNV", "");
+    }
+    if (publicType.shaderQualifiers.layoutDerivativeGroupLinear) {
+        if (publicType.qualifier.storage == EvqVaryingIn) {
+            if((intermediate.getLocalSize(0) *
+                intermediate.getLocalSize(1) *
+                intermediate.getLocalSize(2)) % 4 != 0)
+                error(loc, "requires total group size to be multiple of four", "derivative_group_linearNV", "");
+            else
+                intermediate.setLayoutDerivativeMode(LayoutDerivativeGroupLinear);
+        }
+        else
+            error(loc, "can only apply to 'in'", "derivative_group_linearNV", "");
+    }
+#endif 
     const TQualifier& qualifier = publicType.qualifier;
 
     if (qualifier.isAuxiliary() ||

glslang/MachineIndependent/Versions.cpp

@@ -236,6 +236,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_NV_shader_noperspective_interpolation]    = EBhDisable;
     extensionBehavior[E_GL_NV_shader_subgroup_partitioned]           = EBhDisable;
     extensionBehavior[E_GL_NV_fragment_shader_barycentric]           = EBhDisable;
+    extensionBehavior[E_GL_NV_compute_shader_derivatives]            = EBhDisable;
 #endif
 
     // AEP
@@ -407,6 +408,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_NV_conservative_raster_underestimation 1\n"
             "#define GL_NV_shader_subgroup_partitioned 1\n"
             "#define GL_NV_fragment_shader_barycentric 1\n"
+            "#define GL_NV_compute_shader_derivatives 1\n"
 #endif
             "#define GL_KHX_shader_explicit_arithmetic_types 1\n"
             "#define GL_KHX_shader_explicit_arithmetic_types_int8 1\n"

glslang/MachineIndependent/Versions.h

@@ -208,6 +208,7 @@ const char* const E_GL_NV_conservative_raster_underestimation   = "GL_NV_conserv
 const char* const E_GL_NV_shader_noperspective_interpolation    = "GL_NV_shader_noperspective_interpolation";
 const char* const E_GL_NV_shader_subgroup_partitioned           = "GL_NV_shader_subgroup_partitioned";
 const char* const E_GL_NV_fragment_shader_barycentric           = "GL_NV_fragment_shader_barycentric";
+const char* const E_GL_NV_compute_shader_derivatives            = "GL_NV_compute_shader_derivatives";
 // Arrays of extensions for the above viewportEXTs duplications
 
 const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_NV_viewport_array2 };

glslang/MachineIndependent/localintermediate.h

@@ -206,6 +206,17 @@ class TSymbolTable;
 class TSymbol;
 class TVariable;
 
+#ifdef NV_EXTENSIONS
+//
+// Texture and Sampler transformation mode.
+//
+enum ComputeDerivativeMode {
+    LayoutDerivativeNone,         // default layout as SPV_NV_compute_shader_derivatives not enabled
+    LayoutDerivativeGroupQuads,   // derivative_group_quadsNV
+    LayoutDerivativeGroupLinear,  // derivative_group_linearNV
+};
+#endif
+
 //
 // Set of helper functions to help parse and build the tree.
 //
@@ -225,6 +236,7 @@ public:
 #ifdef NV_EXTENSIONS
         layoutOverrideCoverage(false),
         geoPassthroughEXT(false),
+        computeDerivativeMode(LayoutDerivativeNone),
 #endif
         autoMapBindings(false),
         autoMapLocations(false),
@@ -622,6 +634,8 @@ public:
     bool getLayoutOverrideCoverage() const { return layoutOverrideCoverage; }
     void setGeoPassthroughEXT() { geoPassthroughEXT = true; }
     bool getGeoPassthroughEXT() const { return geoPassthroughEXT; }
+    void setLayoutDerivativeMode(ComputeDerivativeMode mode) { computeDerivativeMode = mode; }
+    ComputeDerivativeMode getLayoutDerivativeModeNone() const { return computeDerivativeMode; }
 #endif
 
     const char* addSemanticName(const TString& name)
@@ -725,6 +739,7 @@ protected:
 #ifdef NV_EXTENSIONS
     bool layoutOverrideCoverage;
     bool geoPassthroughEXT;
+    ComputeDerivativeMode computeDerivativeMode;
 #endif
 
     // Base shift values

gtests/Spv.FromFile.cpp

@@ -503,6 +503,8 @@ INSTANTIATE_TEST_CASE_P(
     "spv.atomicInt64.comp",
     "spv.fragmentShaderBarycentric.frag",
     "spv.fragmentShaderBarycentric2.frag",
+    "spv.computeShaderDerivatives.comp",
+    "spv.computeShaderDerivatives2.comp",
 })),
 FileNameAsCustomTestSuffix
 );