Add validations on ReadWrite storage texture format

This patch adds the check on the storage texture format with ReadWrite
storage texture access. Currently only R32Float, R32Uint and R32SInt are
allowed with ReadWrite storage texture access.

Bug: dawn:1972
Test: dawn_unittests
Change-Id: I63dd73b7f93cee037baa8cb94bddd5229ea9312c
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/146880
Reviewed-by: Corentin Wallez <[email protected]>
Kokoro: Kokoro <[email protected]>
Reviewed-by: Austin Eng <[email protected]>
Commit-Queue: Jiawei Shao <[email protected]>

Author: Jiawei-Shao

src/dawn/native/BindGroupLayoutInternal.cpp

@@ -86,6 +86,14 @@ MaybeError ValidateReadWriteStorageTextureAccess(
             UNREACHABLE();
     }
 
+    if (storageTextureBindingLayout.access == wgpu::StorageTextureAccess::ReadWrite) {
+        const Format* format = nullptr;
+        DAWN_TRY_ASSIGN(format, device->GetInternalFormat(storageTextureBindingLayout.format));
+        DAWN_INVALID_IF(!format->supportsReadWriteStorageUsage,
+                        "Texture format %s does not support storage texture access %s",
+                        storageTextureBindingLayout.format, wgpu::StorageTextureAccess::ReadWrite);
+    }
+
     return {};
 }
 

src/dawn/native/Format.cpp

@@ -178,13 +178,15 @@ FormatTable BuildFormatTable(const DeviceBase* device) {
                      bool supportsResolveTarget, uint32_t byteSize, SampleTypeBit sampleTypes,
                      uint8_t componentCount, uint8_t renderTargetPixelByteCost = 0,
                      uint8_t renderTargetComponentAlignment = 0,
+                     bool supportsReadWriteStorageUsage = false,
                      wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
             Format internalFormat;
             internalFormat.format = format;
             internalFormat.isRenderable = renderable;
             internalFormat.isCompressed = false;
             internalFormat.unsupportedReason = unsupportedReason;
             internalFormat.supportsStorageUsage = supportsStorageUsage;
+            internalFormat.supportsReadWriteStorageUsage = supportsReadWriteStorageUsage;
 
             if (supportsMultisample) {
                 ASSERT(renderable);
@@ -236,18 +238,20 @@ FormatTable BuildFormatTable(const DeviceBase* device) {
             AddFormat(internalFormat);
         };
 
-    auto AddColorFormat =
-        [&AddConditionalColorFormat](
-            wgpu::TextureFormat format, bool renderable, bool supportsStorageUsage,
-            bool supportsMultisample, bool supportsResolveTarget, uint32_t byteSize,
-            SampleTypeBit sampleTypes, uint8_t componentCount,
-            uint8_t renderTargetPixelByteCost = 0, uint8_t renderTargetComponentAlignment = 0,
-            wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
-            AddConditionalColorFormat(format, std::monostate{}, renderable, supportsStorageUsage,
-                                      supportsMultisample, supportsResolveTarget, byteSize,
-                                      sampleTypes, componentCount, renderTargetPixelByteCost,
-                                      renderTargetComponentAlignment, baseFormat);
-        };
+    auto AddColorFormat = [&AddConditionalColorFormat](
+                              wgpu::TextureFormat format, bool renderable,
+                              bool supportsStorageUsage, bool supportsMultisample,
+                              bool supportsResolveTarget, uint32_t byteSize,
+                              SampleTypeBit sampleTypes, uint8_t componentCount,
+                              uint8_t renderTargetPixelByteCost = 0,
+                              uint8_t renderTargetComponentAlignment = 0,
+                              bool supportsReadWriteStorageUsage = false,
+                              wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
+        AddConditionalColorFormat(
+            format, std::monostate{}, renderable, supportsStorageUsage, supportsMultisample,
+            supportsResolveTarget, byteSize, sampleTypes, componentCount, renderTargetPixelByteCost,
+            renderTargetComponentAlignment, supportsReadWriteStorageUsage, baseFormat);
+    };
 
     auto AddDepthFormat = [&AddFormat](wgpu::TextureFormat format, uint32_t byteSize,
                                        UnsupportedReason unsupportedReason) {
@@ -388,21 +392,22 @@ FormatTable BuildFormatTable(const DeviceBase* device) {
 
         // 4 bytes color formats
         SampleTypeBit sampleTypeFor32BitFloatFormats = device->HasFeature(Feature::Float32Filterable) ? kAnyFloat : SampleTypeBit::UnfilterableFloat;
-        AddColorFormat(wgpu::TextureFormat::R32Uint, true, true, false, false, 4, SampleTypeBit::Uint, 1, 4, 4);
-        AddColorFormat(wgpu::TextureFormat::R32Sint, true, true, false, false, 4, SampleTypeBit::Sint, 1, 4, 4);
-        AddColorFormat(wgpu::TextureFormat::R32Float, true, true, true, false, 4, sampleTypeFor32BitFloatFormats, 1, 4, 4);
+        bool SupportsReadWriteStorageUsage = device->HasFeature(Feature::ChromiumExperimentalReadWriteStorageTexture);
+        AddColorFormat(wgpu::TextureFormat::R32Uint, true, true, false, false, 4, SampleTypeBit::Uint, 1, 4, 4, SupportsReadWriteStorageUsage);
+        AddColorFormat(wgpu::TextureFormat::R32Sint, true, true, false, false, 4, SampleTypeBit::Sint, 1, 4, 4, SupportsReadWriteStorageUsage);
+        AddColorFormat(wgpu::TextureFormat::R32Float, true, true, true, false, 4, sampleTypeFor32BitFloatFormats, 1, 4, 4, SupportsReadWriteStorageUsage);
         AddColorFormat(wgpu::TextureFormat::RG16Uint, true, false, true, false, 4, SampleTypeBit::Uint, 2, 4, 2);
         AddColorFormat(wgpu::TextureFormat::RG16Sint, true, false, true, false, 4, SampleTypeBit::Sint, 2, 4, 2);
         AddColorFormat(wgpu::TextureFormat::RG16Float, true, false, true, true, 4, kAnyFloat, 2, 4, 2);
         AddColorFormat(wgpu::TextureFormat::RGBA8Unorm, true, true, true, true, 4, kAnyFloat, 4, 8, 1);
-        AddColorFormat(wgpu::TextureFormat::RGBA8UnormSrgb, true, false, true, true, 4, kAnyFloat, 4, 8, 1, wgpu::TextureFormat::RGBA8Unorm);
+        AddColorFormat(wgpu::TextureFormat::RGBA8UnormSrgb, true, false, true, true, 4, kAnyFloat, 4, 8, 1, false, wgpu::TextureFormat::RGBA8Unorm);
         AddColorFormat(wgpu::TextureFormat::RGBA8Snorm, false, true, false, false, 4, kAnyFloat, 4);
         AddColorFormat(wgpu::TextureFormat::RGBA8Uint, true, true, true, false, 4, SampleTypeBit::Uint, 4, 4, 1);
         AddColorFormat(wgpu::TextureFormat::RGBA8Sint, true, true, true, false, 4, SampleTypeBit::Sint, 4, 4, 1);
 
         bool BGRA8UnormSupportsStorageUsage = device->HasFeature(Feature::BGRA8UnormStorage);
         AddColorFormat(wgpu::TextureFormat::BGRA8Unorm, true, BGRA8UnormSupportsStorageUsage, true, true, 4, kAnyFloat, 4, 8, 1);
-        AddConditionalColorFormat(wgpu::TextureFormat::BGRA8UnormSrgb, device->IsCompatibilityMode() ? UnsupportedReason(CompatibilityMode{}) : Format::supported, true, false, true, true, 4, kAnyFloat, 4, 8, 1, wgpu::TextureFormat::BGRA8Unorm);
+        AddConditionalColorFormat(wgpu::TextureFormat::BGRA8UnormSrgb, device->IsCompatibilityMode() ? UnsupportedReason(CompatibilityMode{}) : Format::supported, true, false, true, true, 4, kAnyFloat, 4, 8, 1, false, wgpu::TextureFormat::BGRA8Unorm);
         AddColorFormat(wgpu::TextureFormat::RGB10A2Unorm, true, false, true, true, 4, kAnyFloat, 4, 8, 4);
 
         bool isRG11B10UfloatRenderable = device->HasFeature(Feature::RG11B10UfloatRenderable);

src/dawn/native/Format.h

@@ -112,6 +112,7 @@ struct Format {
     // A format can be known but not supported because it is part of a disabled extension.
     UnsupportedReason unsupportedReason;
     bool supportsStorageUsage = false;
+    bool supportsReadWriteStorageUsage = false;
     bool supportsMultisample = false;
     bool supportsResolveTarget = false;
     Aspect aspects{};

src/dawn/tests/unittests/validation/StorageTextureValidationTests.cpp

@@ -903,5 +903,24 @@ TEST_F(ReadWriteStorageTextureValidationTests, BindGroupLayoutWithStorageTexture
     DoBindGroupLayoutTest(kTestSpecs);
 }
 
+// Test that using read-only storage texture in BindGroupLayout is valid with all formats that
+// can be used as storage texture, while read-write storage texture access is only available on the
+// formats that support read-write storage texture access.
+TEST_F(ReadWriteStorageTextureValidationTests, ReadWriteStorageTextureFormat) {
+    for (wgpu::TextureFormat format : utils::kAllTextureFormats) {
+        if (!utils::TextureFormatSupportsStorageTexture(format, UseCompatibilityMode())) {
+            continue;
+        }
+
+        bool supportsReadWriteStorageTexture =
+            utils::TextureFormatSupportsReadWriteStorageTexture(format);
+        const std::vector<BindGroupLayoutTestSpec> kTestSpecs = {
+            {{wgpu::ShaderStage::Compute, wgpu::StorageTextureAccess::ReadOnly, true, format},
+             {wgpu::ShaderStage::Compute, wgpu::StorageTextureAccess::ReadWrite,
+              supportsReadWriteStorageTexture, format}}};
+        DoBindGroupLayoutTest(kTestSpecs);
+    }
+}
+
 }  // anonymous namespace
 }  // namespace dawn

src/dawn/utils/TextureUtils.cpp

@@ -192,6 +192,17 @@ bool TextureFormatSupportsResolveTarget(wgpu::TextureFormat textureFormat) {
     }
 }
 
+bool TextureFormatSupportsReadWriteStorageTexture(wgpu::TextureFormat format) {
+    switch (format) {
+        case wgpu::TextureFormat::R32Float:
+        case wgpu::TextureFormat::R32Sint:
+        case wgpu::TextureFormat::R32Uint:
+            return true;
+        default:
+            return false;
+    }
+}
+
 bool IsStencilOnlyFormat(wgpu::TextureFormat textureFormat) {
     return textureFormat == wgpu::TextureFormat::Stencil8;
 }

src/dawn/utils/TextureUtils.h

@@ -221,6 +221,7 @@ static constexpr std::array<wgpu::TextureFormat, 2> kDepthAndStencilFormats = {
 };
 
 bool TextureFormatSupportsStorageTexture(wgpu::TextureFormat format, bool isCompatibilityMode);
+bool TextureFormatSupportsReadWriteStorageTexture(wgpu::TextureFormat format);
 
 bool IsBCTextureFormat(wgpu::TextureFormat textureFormat);
 bool IsETC2TextureFormat(wgpu::TextureFormat textureFormat);