Change log for June 2, 2019 Vulkan 1.1.110 spec update:

  * Update release number to 110.

Github Issues:

  * Fix typo (public pull request 972).
  * Rename Pastel driver ID to SwiftShader (public pull request 974).

New Extensions:

  * `<<VK_EXT_fragment_shader_interlock>>`
  * `<<VK_NV_shader_sm_builtins>>`

ChangeLog.txt

@@ -8,6 +8,22 @@ public pull requests that have been accepted.
 
 -----------------------------------------------------
 
+Change log for June 2, 2019 Vulkan 1.1.110 spec update:
+
+  * Update release number to 110.
+
+Github Issues:
+
+  * Fix typo (public pull request 972).
+  * Rename Pastel driver ID to SwiftShader (public pull request 974).
+
+New Extensions:
+
+  * `<<VK_EXT_fragment_shader_interlock>>`
+  * `<<VK_NV_shader_sm_builtins>>`
+
+-----------------------------------------------------
+
 Change log for May 24, 2019 Vulkan 1.1.109 spec update:
 
   * Update release number to 109.

Makefile

@@ -121,7 +121,7 @@ VERBOSE =
 # ADOCOPTS options for asciidoc->HTML5 output
 
 NOTEOPTS     = -a editing-notes -a implementation-guide
-PATCHVERSION = 109
+PATCHVERSION = 110
 ifneq (,$(findstring VK_VERSION_1_1,$(VERSIONS)))
 SPECREVISION = 1.1.$(PATCHVERSION)
 else

appendices/VK_EXT_fragment_shader_interlock.txt

@@ -0,0 +1,78 @@
+include::meta/VK_EXT_fragment_shader_interlock.txt[]
+
+*Last Modified Data*::
+    2019-05-02
+*Interactions and External Dependencies*::
+  - This extension requires the
+    https://www.khronos.org/registry/spir-v/extensions/EXT/SPV_EXT_fragment_shader_interlock.html[+SPV_EXT_fragment_shader_interlock+]
+    SPIR-V extension.
+  - This extension requires the
+    https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_fragment_shader_interlock.txt[+GL_ARB_fragment_shader_interlock+],
+    extensions for GLSL source languages.
+*Contributors*::
+  - Daniel Koch, NVIDIA
+  - Graeme Leese, Broadcom
+  - Jan-Harald Fredriksen, Arm
+  - Jason Ekstrand, Intel
+  - Jeff Bolz, NVIDIA
+  - Ruihao Zhang, Qualcomm
+  - Slawomir Grajewski, Intel
+  - Spencer Fricke, Samsung
+
+This extension adds support for the code:FragmentShaderPixelInterlockEXT,
+code:FragmentShaderSampleInterlockEXT, and
+code:FragmentShaderShadingRateInterlockEXT capabilities from the
++SPV_EXT_fragment_shader_interlock+ extension to Vulkan.
+
+Enabling these capabilities provides a critical section for fragment shaders
+to avoid overlapping pixels being processed at the same time, and certain
+guarantees about the ordering of fragment shader invocations of fragments of
+overlapping pixels.
+
+This extension can be useful for algorithms that need to access per-pixel
+data structures via shader loads and stores.
+Algorithms using this extension can access per-pixel data structures in
+critical sections without other invocations accessing the same per-pixel
+data.
+Additionally, the ordering guarantees are useful for cases where the API
+ordering of fragments is meaningful.
+For example, applications may be able to execute programmable blending
+operations in the fragment shader, where the destination buffer is read via
+image loads and the final value is written via image stores.
+
+=== New Object Types
+
+None.
+
+=== New Enum Constants
+
+  * Extending elink:VkStructureType:
+  ** ename:VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT
+
+=== New Enums
+
+None.
+
+=== New Structures
+
+  * Extending slink:VkPhysicalDeviceFeatures2:
+  ** slink:VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
+
+=== New Functions
+
+None.
+
+=== New SPIR-V Capabilities
+
+  * <<spirvenv-capabilities-table-fragmentShaderInterlock,FragmentShaderInterlockEXT>>
+  * <<spirvenv-capabilities-table-fragmentShaderInterlock,FragmentShaderPixelInterlockEXT>>
+  * <<spirvenv-capabilities-table-fragmentShaderInterlock,FragmentShaderShadingRateInterlockEXT>>
+
+=== Issues
+
+None.
+
+=== Version History
+
+  * Revision 1, 2019-05-24 (Piers Daniell)
+    - Internal revisions

appendices/VK_NV_shader_sm_builtins.txt

@@ -0,0 +1,86 @@
+include::meta/VK_NV_shader_sm_builtins.txt[]
+
+*Last Modified Date*::
+    2019-05-28
+
+*Interactions and External Dependencies*::
+ - This extension requires
+   http://htmlpreview.github.io/?https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/NV/SPV_NV_shader_sm_builtins.html[+SPV_NV_shader_sm_builtins+].
+ - This extension enables
+   https://github.com/KhronosGroup/GLSL/blob/master/extensions/nv/GLSL_NV_shader_sm_builtins.txt[+GL_NV_shader_sm_builtins+]
+   for GLSL source languages.
+
+*Contributors*::
+  - Jeff Bolz, NVIDIA
+  - Eric Werness, NVIDIA
+
+=== Description
+
+This extension provides the ability to determine device-specific properties
+on NVIDIA GPUs.
+It provides the number of streaming multiprocessors (SMs), the maximum
+number warps (subgroups) that can run on an SM, and shader builtins to
+enable invocations to identify which SM and warp a shader invocation is
+executing on.
+
+This extension enables support for the SPIR-V code:ShaderSMBuiltinsNV
+capability.
+
+These properties and built-ins should: typically only be used for debugging
+purposes.
+
+
+=== New Object Types
+
+None.
+
+=== New Enum Constants
+
+  * Extending elink:VkStructureType:
+  ** ename:VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV
+  ** ename:VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV
+
+=== New Enums
+
+None.
+
+=== New Structures
+
+  * slink:VkPhysicalDeviceShaderSMBuiltinsFeaturesNV
+  * slink:VkPhysicalDeviceShaderSMBuiltinsPropertiesNV
+
+=== New Functions
+
+None.
+
+=== New or Modified Built-In Variables
+
+ * <<interfaces-builtin-variables-warpspersmnv,code:WarpsPerSMNV>>
+ * <<interfaces-builtin-variables-smcountnv,code:SMCountNV>>
+ * <<interfaces-builtin-variables-warpidnv,code:WarpIDNV>>
+ * <<interfaces-builtin-variables-smidnv,code:SMIDNV>>
+
+=== New SPIR-V Capabilities
+
+ * <<spirvenv-capabilities-table-shadersmbuiltins,code:ShaderSMBuiltinsNV>>
+
+=== Issues
+. What should we call this extension?
++
+--
+RESOLVED: Using NV_shader_sm_builtins.
+Other options considered included:
+
+  * NV_shader_smid - but SMID is really easy to typo/confuse as SIMD.
+  * NV_shader_sm_info - but *Info* is typically reserved for input
+    structures
+
+--
+
+
+=== Version History
+
+  * Revision 1, 2019-05-28 (Daniel Koch)
+    - Internal revisions
+
+

appendices/memorymodel.txt

@@ -139,6 +139,14 @@ least inclusive:
   * code:QueueFamilyKHR identifes all shader invocations that execute on any
     queue in a given queue family, including those from different shader
     launches.
+ifdef::VK_EXT_fragment_shader_interlock[]
+  * code:FragmentInterlock identifies sets of fragment shader invocations
+    that overlap as defined in <<shaders-fragment-shader-interlock,Fragment
+    Shader Interlock>>.
+    This scope does not exist as an enum in SPIR-V, it is only implicitly
+    used as a memory scope by code:OpBeginInvocationInterlockEXT and
+    code:OpEndInvocationInterlockEXT.
+endif::VK_EXT_fragment_shader_interlock[]
   * code:Workgroup identifies all invocations in a single workgroup.
   * code:Subgroup identifies all invocations in a single subgroup.
   * code:Invocation identifies a single invocation.
@@ -392,6 +400,22 @@ A synchronizes-with B if all of the following are true:
 NOTE: This is similar to the barrier-barrier synchronization above, but with
 a control barrier filling the role of the relaxed atomics.
 
+ifdef::VK_EXT_fragment_shader_interlock[]
+
+Let F be an ordering of fragment shader invocations, such that invocation
+F~1~ is ordered before invocation F~2~ if and only if F~1~ and F~2~ overlap
+as described in <<shaders-fragment-shader-interlock,Fragment Shader
+Interlock>> and F~1~ executes the interlocked code before F~2~.
+
+If A is an code:OpEndInvocationInterlockEXT instruction and B is an
+code:OpBeginInvocationInterlockEXT instruction, then A synchronizes-with B
+if the agent that executes A is ordered before the agent that executes B in
+F. A and B are both considered to have code:FragmentInterlock memory scope
+and semantics of UniformMemory and ImageMemory, and A is considered to have
+Release semantics and B is considered to have Acquire semantics.
+
+endif::VK_EXT_fragment_shader_interlock[]
+
 No other release and acquire barriers synchronize-with each other.
 
 [[memory-model-system-synchronizes-with]]
@@ -508,6 +532,11 @@ The memory domains defined in Vulkan include:
     corresponding to the code:Device scope
   * _queue family instance_ - accessible by shader agents in a single queue
     family, corresponding to the code:QueueFamilyKHR scope.
+ifdef::VK_EXT_fragment_shader_interlock[]
+  * _fragment interlock instance_ - accessible by fragment shader agents
+    that <<shaders-fragment-shader-interlock,overlap>>, corresponding to the
+    code:FragmentInterlock scope.
+endif::VK_EXT_fragment_shader_interlock[]
   * _workgroup instance_ - accessible by shader agents in the same
     workgroup, corresponding to the code:Workgroup scope.
   * _subgroup instance_ - accessible by shader agents in the same subgroup,
@@ -516,11 +545,18 @@ The memory domains defined in Vulkan include:
 NOTE: These do not correspond to storage classes or device-local and
 host-local slink:VkDeviceMemory allocations, rather they indicate whether a
 write can be made visible only to agents in the same subgroup, same
-workgroup, in any shader invocation, or anywhere on the device, or host.
-The shader, queue family instance, workgroup instance, and subgroup instance
-domains are only used for shader-based availability/visibility operatons, in
-other cases writes can be made available from/visible to the shader via the
-device domain.
+workgroup,
+ifdef::VK_EXT_fragment_shader_interlock[]
+overlapping fragment shader invocation,
+endif::VK_EXT_fragment_shader_interlock[]
+in any shader invocation, or anywhere on the device, or host.
+The shader, queue family instance,
+ifdef::VK_EXT_fragment_shader_interlock[]
+fragment interlock instance,
+endif::VK_EXT_fragment_shader_interlock[]
+workgroup instance, and subgroup instance domains are only used for
+shader-based availability/visibility operatons, in other cases writes can be
+made available from/visible to the shader via the device domain.
 
 _Availability operations_, _visibility operations_, and _memory domain
 operations_ alter the state of the write operations that happen-before them,
@@ -656,6 +692,9 @@ as follows:
 
   * code:Device scope uses the shader domain
   * code:QueueFamilyKHR scope uses the queue family instance domain
+ifdef::VK_EXT_fragment_shader_interlock[]
+  * code:FragmentInterlock scope uses the fragment interlock instance domain
+endif::VK_EXT_fragment_shader_interlock[]
   * code:Workgroup scope uses the workgroup instance domain
   * code:Subgroup uses the subgroup instance domain
   * code:Invocation perform no availability/visibility operations.
@@ -690,10 +729,13 @@ The implicit visibility operation is program-ordered between read and all
 other operations program-ordered before the read.
 
 NOTE: Although reads with per-instruction visibility only perform visibility
-ops from the shader or workgroup instance or subgroup instance domain, they
-will also see writes that were made visible via the device domain, i.e.
-those writes previously performed by non-shader agents and made visible via
-API commands.
+ops from the shader or
+ifdef::VK_EXT_fragment_shader_interlock[]
+fragment interlock instance or
+endif::VK_EXT_fragment_shader_interlock[]
+workgroup instance or subgroup instance domain, they will also see writes
+that were made visible via the device domain, i.e. those writes previously
+performed by non-shader agents and made visible via API commands.
 
 NOTE: It is expected that all invocations in a subgroup execute on the same
 processor with the same path to memory, and thus availability and visibility

appendices/spirvenv.txt

@@ -278,6 +278,18 @@ ifdef::VK_INTEL_shader_integer_functions2[]
 [[spirvenv-capabilities-table-shaderIntegerFunctions2]]
 | code:ShaderIntegerFunctions2INTEL  | <<features-shaderIntegerFunctions2,shaderIntegerFunctions2>>
 endif::VK_INTEL_shader_integer_functions2[]
+ifdef::VK_NV_shader_sm_builtins[]
+[[spirvenv-capabilities-table-shadersmbuiltins]]
+| code:ShaderSMBuiltinsNV    | <<features-features-shadersmbuiltins,shaderSMBuiltins>>
+endif::VK_NV_shader_sm_builtins[]
+ifdef::VK_EXT_fragment_shader_interlock[]
+[[spirvenv-capabilities-table-fragmentShaderInterlock]]
+| code:FragmentShaderSampleInterlockEXT  | <<features-features-fragmentShaderSampleInterlock,fragmentShaderSampleInterlock>>
+| code:FragmentShaderPixelInterlockEXT  | <<features-features-fragmentShaderPixelInterlock,fragmentShaderPixelInterlock>>
+ifdef::VK_NV_shading_rate_image[]
+| code:FragmentShaderShadingRateInterlockEXT  | <<features-features-fragmentShaderShadingRateInterlock,fragmentShaderShadingRateInterlock>>, <<features-shadingRateImage,shadingRateImage>>
+endif::VK_NV_shading_rate_image[]
+endif::VK_EXT_fragment_shader_interlock[]
 |====
 
 ifdef::VK_VERSION_1_1,VK_KHR_variable_pointers[]
@@ -471,6 +483,16 @@ The application can: pass a SPIR-V module to flink:vkCreateShaderModule that
 uses the `SPV_NV_cooperative_matrix` SPIR-V extension.
 endif::VK_NV_cooperative_matrix[]
 
+ifdef::VK_NV_shader_sm_builtins[]
+The application can: pass a SPIR-V module to flink:vkCreateShaderModule that
+uses the `SPV_NV_shader_sm_builtins` SPIR-V extension.
+endif::VK_NV_shader_sm_builtins[]
+
+ifdef::VK_EXT_fragment_shader_interlock[]
+The application can: pass a SPIR-V module to flink:vkCreateShaderModule that
+uses the `SPV_EXT_fragment_shader_interlock` SPIR-V extension.
+endif::VK_EXT_fragment_shader_interlock[]
+
 The application must: not pass a SPIR-V module containing any of the
 following to flink:vkCreateShaderModule: