Stub out the PLS API.

Adds validation that using the additions for PLS is disallowed if the
extension is not enabled, along with tests for that validation.

Bug: dawn:1704

Change-Id: I93a3357a9e0ab5d3bfc67af7fddda10d30f52c82
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/145884
Reviewed-by: Austin Eng <[email protected]>
Commit-Queue: Corentin Wallez <[email protected]>
Kokoro: Kokoro <[email protected]>

Author: Kangz

dawn.json

@@ -1796,6 +1796,7 @@
             {"value": 10, "name": "RG11B10 ufloat renderable"},
             {"value": 11, "name": "BGRA8 unorm storage"},
             {"value": 12, "name": "float32 filterable"},
+
             {"value": 1002, "name": "dawn internal usages", "tags": ["dawn"]},
             {"value": 1003, "name": "dawn multi planar formats", "tags": ["dawn"]},
             {"value": 1004, "name": "dawn native", "tags": ["dawn", "native"]},
@@ -1811,6 +1812,8 @@
             {"value": 1014, "name": "chromium experimental subgroups", "tags": ["dawn"]},
             {"value": 1015, "name": "chromium experimental subgroup uniform control flow", "tags": ["dawn"]},
             {"value": 1016, "name": "chromium experimental read write storage texture", "tags": ["dawn"]},
+            {"value": 1017, "name": "pixel local storage coherent", "tags": ["dawn"]},
+            {"value": 1018, "name": "pixel local storage non coherent", "tags": ["dawn"]},
 
             {"value": 1100, "name": "shared texture memory vk dedicated allocation", "tags": ["dawn", "native"]},
             {"value": 1101, "name": "shared texture memory a hardware buffer", "tags": ["dawn", "native"]},
@@ -2005,6 +2008,26 @@
             {"name": "bind group layouts", "type": "bind group layout", "annotation": "const*", "length": "bind group layout count"}
         ]
     },
+    "pipeline layout pixel local storage": {
+        "category": "structure",
+        "tags": ["dawn"],
+        "chained": "in",
+        "chain roots": ["pipeline layout descriptor"],
+        "members": [
+            {"name": "total pixel local storage size", "type": "size_t"},
+            {"name": "storage attachment count", "type": "size_t", "default": 0},
+            {"name": "storage attachments", "type": "pipeline layout storage attachment", "annotation": "const*", "length": "storage attachment count"}
+        ]
+    },
+    "pipeline layout storage attachment": {
+        "category": "structure",
+        "tags": ["dawn"],
+        "extensible": "in",
+        "members": [
+            {"name": "offset", "type": "uint64_t", "default": 0},
+            {"name": "format", "type": "texture format"}
+        ]
+    },
     "pipeline statistic name": {
         "category": "enum",
         "values": [
@@ -2390,6 +2413,29 @@
             {"name": "max draw count", "type": "uint64_t", "default": 50000000}
         ]
     },
+    "render pass pixel local storage": {
+        "category": "structure",
+        "tags": ["dawn"],
+        "chained": "in",
+        "chain roots": ["render pass descriptor"],
+        "members": [
+            {"name": "total pixel local storage size", "type": "size_t"},
+            {"name": "storage attachment count", "type": "size_t", "default": 0},
+            {"name": "storage attachments", "type": "render pass storage attachment", "annotation": "const*", "length": "storage attachment count"}
+        ]
+    },
+    "render pass storage attachment": {
+        "category": "structure",
+        "tags": ["dawn"],
+        "extensible": "in",
+        "members": [
+            {"name": "offset", "type": "uint64_t", "default": 0},
+            {"name": "storage", "type": "texture view"},
+            {"name": "load op", "type": "load op"},
+            {"name": "store op", "type": "store op"},
+            {"name": "clear value", "type": "color"}
+        ]
+    },
     "render pass encoder": {
         "category": "object",
         "no autolock": true,
@@ -2540,6 +2586,10 @@
                     {"name": "query index", "type": "uint32_t"}
                 ]
             },
+            {
+                "name": "pixel local storage barrier",
+                "tags": ["dawn"]
+            },
             {
                 "name": "end"
             },
@@ -3008,6 +3058,8 @@
             {"value": 1011, "name": "request adapter options get GL proc", "tags": ["dawn", "native"]},
             {"value": 1012, "name": "dawn multisample state render to single sampled", "tags": ["dawn"]},
             {"value": 1013, "name": "dawn render pass color attachment render to single sampled", "tags": ["dawn"]},
+            {"value": 1014, "name": "render pass pixel local storage", "tags": ["dawn"]},
+            {"value": 1015, "name": "pipeline layout pixel local storage", "tags": ["dawn"]},
 
             {"value": 1100, "name": "shared texture memory vk image descriptor", "tags": ["dawn", "native"]},
             {"value": 1101, "name": "shared texture memory vk dedicated allocation descriptor", "tags": ["dawn", "native"]},
@@ -3251,7 +3303,8 @@
             {"value": 4, "name": "texture binding"},
             {"value": 8, "name": "storage binding"},
             {"value": 16, "name": "render attachment"},
-            {"value": 32, "name": "transient attachment", "tags": ["dawn"]}
+            {"value": 32, "name": "transient attachment", "tags": ["dawn"]},
+            {"value": 64, "name": "storage attachment", "tags": ["dawn"]}
         ]
     },
     "texture view descriptor": {

docs/dawn/features/pixel_local_storage.md

@@ -0,0 +1 @@
+TODO(dawn:1704): Fill out this feature doc once we know what the feature looks like.

src/dawn/native/CommandEncoder.cpp

@@ -497,8 +497,9 @@ MaybeError ValidateRenderPassDescriptor(DeviceBase* device,
                                         uint32_t* sampleCount,
                                         uint32_t* implicitSampleCount,
                                         UsageValidationMode usageValidationMode) {
-    DAWN_TRY(ValidateSingleSType(descriptor->nextInChain,
-                                 wgpu::SType::RenderPassDescriptorMaxDrawCount));
+    DAWN_TRY(
+        ValidateSTypes(descriptor->nextInChain, {{wgpu::SType::RenderPassDescriptorMaxDrawCount},
+                                                 {wgpu::SType::RenderPassPixelLocalStorage}}));
 
     uint32_t maxColorAttachments = device->GetLimits().v1.maxColorAttachments;
     DAWN_INVALID_IF(
@@ -592,6 +593,14 @@ MaybeError ValidateRenderPassDescriptor(DeviceBase* device,
             descriptor->colorAttachmentCount, *implicitSampleCount);
     }
 
+    const RenderPassPixelLocalStorage* pls = nullptr;
+    FindInChain(descriptor->nextInChain, &pls);
+    if (pls != nullptr) {
+        DAWN_TRY(ValidateHasPLSFeature(device));
+
+        // TODO(dawn:1704): Validate limits, formats, offsets don't collide and the total size.
+    }
+
     return {};
 }
 

src/dawn/native/CommandValidation.cpp

@@ -544,4 +544,13 @@ MaybeError ValidateColorAttachmentBytesPerSample(DeviceBase* device,
     return {};
 }
 
+MaybeError ValidateHasPLSFeature(const DeviceBase* device) {
+    DAWN_INVALID_IF(
+        !(device->HasFeature(Feature::PixelLocalStorageCoherent) ||
+          device->HasFeature(Feature::PixelLocalStorageNonCoherent)),
+        "Pixel Local Storage feature used without either of the pixel-local-storage-coherent or "
+        "pixel-local-storage-non-coherent features enabled.");
+    return {};
+}
+
 }  // namespace dawn::native

src/dawn/native/CommandValidation.h

@@ -99,6 +99,8 @@ using ColorAttachmentFormats = StackVector<const Format*, kMaxColorAttachments>;
 MaybeError ValidateColorAttachmentBytesPerSample(DeviceBase* device,
                                                  const ColorAttachmentFormats& formats);
 
+MaybeError ValidateHasPLSFeature(const DeviceBase* device);
+
 }  // namespace dawn::native
 
 #endif  // SRC_DAWN_NATIVE_COMMANDVALIDATION_H_

src/dawn/native/Commands.cpp

@@ -125,6 +125,12 @@ void FreeCommands(CommandIterator* commands) {
                 cmd->~ClearBufferCmd();
                 break;
             }
+            case Command::PixelLocalStorageBarrier: {
+                PixelLocalStorageBarrierCmd* cmd =
+                    commands->NextCommand<PixelLocalStorageBarrierCmd>();
+                cmd->~PixelLocalStorageBarrierCmd();
+                break;
+            }
             case Command::InsertDebugMarker: {
                 InsertDebugMarkerCmd* cmd = commands->NextCommand<InsertDebugMarkerCmd>();
                 commands->NextData<char>(cmd->length + 1);
@@ -288,6 +294,10 @@ void SkipCommand(CommandIterator* commands, Command type) {
             commands->NextCommand<ClearBufferCmd>();
             break;
 
+        case Command::PixelLocalStorageBarrier:
+            commands->NextCommand<PixelLocalStorageBarrierCmd>();
+            break;
+
         case Command::InsertDebugMarker: {
             InsertDebugMarkerCmd* cmd = commands->NextCommand<InsertDebugMarkerCmd>();
             commands->NextData<char>(cmd->length + 1);

src/dawn/native/Commands.h

@@ -55,6 +55,7 @@ enum class Command {
     EndRenderPass,
     ExecuteBundles,
     InsertDebugMarker,
+    PixelLocalStorageBarrier,
     PopDebugGroup,
     PushDebugGroup,
     ResolveQuerySet,
@@ -266,6 +267,8 @@ struct InsertDebugMarkerCmd {
     uint32_t length;
 };
 
+struct PixelLocalStorageBarrierCmd {};
+
 struct PopDebugGroupCmd {};
 
 struct PushDebugGroupCmd {

src/dawn/native/Features.cpp

@@ -157,6 +157,23 @@ static constexpr FeatureEnumAndInfoList kFeatureNameAndInfoList = {{
       "https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/"
       "EGL_ANGLE_display_texture_share_group.txt",
       FeatureInfo::FeatureState::Stable}},
+    {Feature::PixelLocalStorageCoherent,
+     {"pixel-local-storage-coherent",
+      "Supports passing information between invocation in a render pass that cover the same pixel."
+      "This helps more efficiently implement algorithms that would otherwise require ping-ponging"
+      "between render targets. The coherent version of this extension means that no barrier calls"
+      "are needed to prevent data races between fragment shaders on the same pixel.",
+      "https://bugs.chromium.org/p/dawn/issues/detail?id=1704",
+      FeatureInfo::FeatureState::Experimental}},
+    {Feature::PixelLocalStorageNonCoherent,
+     {"pixel-local-storage-non-coherent",
+      "Supports passing information between invocation in a render pass that cover the same pixel."
+      "This helps more efficiently implement algorithms that would otherwise require ping-ponging"
+      "between render targets. The non-coherent version of this extension means that barrier calls"
+      "are needed to prevent data races between fragment shaders on the same pixels (note that "
+      "overlapping fragments from the same draw cannot be made data race free).",
+      "https://bugs.chromium.org/p/dawn/issues/detail?id=1704",
+      FeatureInfo::FeatureState::Experimental}},
     {Feature::SharedTextureMemoryVkDedicatedAllocation,
      {"shared-texture-memory-vk-dedicated-allocation",
       "Support specifying whether a Vulkan allocation for shared texture memory is a dedicated "
@@ -288,6 +305,10 @@ Feature FromAPIFeature(wgpu::FeatureName feature) {
             return Feature::D3D11MultithreadProtected;
         case wgpu::FeatureName::ANGLETextureSharing:
             return Feature::ANGLETextureSharing;
+        case wgpu::FeatureName::PixelLocalStorageCoherent:
+            return Feature::PixelLocalStorageCoherent;
+        case wgpu::FeatureName::PixelLocalStorageNonCoherent:
+            return Feature::PixelLocalStorageNonCoherent;
         case wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation:
             return Feature::SharedTextureMemoryVkDedicatedAllocation;
         case wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer:
@@ -376,6 +397,10 @@ wgpu::FeatureName ToAPIFeature(Feature feature) {
             return wgpu::FeatureName::D3D11MultithreadProtected;
         case Feature::ANGLETextureSharing:
             return wgpu::FeatureName::ANGLETextureSharing;
+        case Feature::PixelLocalStorageCoherent:
+            return wgpu::FeatureName::PixelLocalStorageCoherent;
+        case Feature::PixelLocalStorageNonCoherent:
+            return wgpu::FeatureName::PixelLocalStorageNonCoherent;
         case Feature::SharedTextureMemoryVkDedicatedAllocation:
             return wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation;
         case Feature::SharedTextureMemoryAHardwareBuffer:

src/dawn/native/Features.h

@@ -56,6 +56,8 @@ enum class Feature {
     DualSourceBlending,
     D3D11MultithreadProtected,
     ANGLETextureSharing,
+    PixelLocalStorageCoherent,
+    PixelLocalStorageNonCoherent,
 
     SharedTextureMemoryVkDedicatedAllocation,
     SharedTextureMemoryAHardwareBuffer,

src/dawn/native/PipelineLayout.cpp

@@ -23,6 +23,8 @@
 #include "dawn/common/Numeric.h"
 #include "dawn/common/ityp_stack_vec.h"
 #include "dawn/native/BindGroupLayout.h"
+#include "dawn/native/ChainUtils.h"
+#include "dawn/native/CommandValidation.h"
 #include "dawn/native/Device.h"
 #include "dawn/native/ObjectContentHasher.h"
 #include "dawn/native/ObjectType_autogen.h"
@@ -33,7 +35,14 @@ namespace dawn::native {
 MaybeError ValidatePipelineLayoutDescriptor(DeviceBase* device,
                                             const PipelineLayoutDescriptor* descriptor,
                                             PipelineCompatibilityToken pipelineCompatibilityToken) {
-    DAWN_INVALID_IF(descriptor->nextInChain != nullptr, "nextInChain is not nullptr.");
+    const PipelineLayoutPixelLocalStorage* pls = nullptr;
+    FindInChain(descriptor->nextInChain, &pls);
+    if (pls != nullptr) {
+        DAWN_TRY(ValidateHasPLSFeature(device));
+
+        // TODO(dawn:1704): Validate limits, formats, offsets don't collide and the total size.
+    }
+
     DAWN_INVALID_IF(descriptor->bindGroupLayoutCount > kMaxBindGroups,
                     "bindGroupLayoutCount (%i) is larger than the maximum allowed (%i).",
                     descriptor->bindGroupLayoutCount, kMaxBindGroups);