| // Copyright 2022 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <memory> |
| #include <string_view> |
| |
| #include "dawn/tests/DawnTest.h" |
| #include "dawn/tests/mocks/platform/CachingInterfaceMock.h" |
| #include "dawn/utils/ComboRenderPipelineDescriptor.h" |
| #include "dawn/utils/WGPUHelpers.h" |
| |
| namespace dawn { |
| namespace { |
| |
| using ::testing::NiceMock; |
| |
| // TODO(dawn:549) Add some sort of pipeline descriptor repository to test more caching. |
| |
| static constexpr std::string_view kComputeShaderDefault = R"( |
| @compute @workgroup_size(1) fn main() {} |
| )"; |
| |
| static constexpr std::string_view kComputeShaderMultipleEntryPoints = R"( |
| @compute @workgroup_size(16) fn main() {} |
| @compute @workgroup_size(64) fn main2() {} |
| )"; |
| |
| static constexpr std::string_view kVertexShaderDefault = R"( |
| @vertex fn main() -> @builtin(position) vec4f { |
| return vec4f(0.0, 0.0, 0.0, 0.0); |
| } |
| )"; |
| |
| static constexpr std::string_view kVertexShaderMultipleEntryPoints = R"( |
| @vertex fn main() -> @builtin(position) vec4f { |
| return vec4f(1.0, 0.0, 0.0, 1.0); |
| } |
| |
| @vertex fn main2() -> @builtin(position) vec4f { |
| return vec4f(0.5, 0.5, 0.5, 1.0); |
| } |
| )"; |
| |
| static constexpr std::string_view kFragmentShaderDefault = R"( |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(0.1, 0.2, 0.3, 0.4); |
| } |
| )"; |
| |
| static constexpr std::string_view kFragmentShaderMultipleOutput = R"( |
| struct FragmentOut { |
| @location(0) fragColor0 : vec4f, |
| @location(1) fragColor1 : vec4f, |
| } |
| |
| @fragment fn main() -> FragmentOut { |
| var output : FragmentOut; |
| output.fragColor0 = vec4f(0.1, 0.2, 0.3, 0.4); |
| output.fragColor1 = vec4f(0.5, 0.6, 0.7, 0.8); |
| return output; |
| } |
| )"; |
| |
| static constexpr std::string_view kFragmentShaderBindGroup00Uniform = R"( |
| struct S { |
| value : f32 |
| }; |
| |
| @group(0) @binding(0) var<uniform> uBuffer : S; |
| |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(uBuffer.value, 0.2, 0.3, 0.4); |
| } |
| )"; |
| |
| static constexpr std::string_view kFragmentShaderBindGroup01Uniform = R"( |
| struct S { |
| value : f32 |
| }; |
| |
| @group(0) @binding(1) var<uniform> uBuffer : S; |
| |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(uBuffer.value, 0.2, 0.3, 0.4); |
| } |
| )"; |
| |
| class PipelineCachingTests : public DawnTest { |
| protected: |
| std::unique_ptr<platform::Platform> CreateTestPlatform() override { |
| return std::make_unique<DawnCachingMockPlatform>(&mMockCache); |
| } |
| |
| struct EntryCounts { |
| unsigned pipeline; |
| unsigned shaderModule; |
| }; |
| const EntryCounts counts = { |
| // pipeline caching is only implemented on D3D12/Vulkan |
| IsD3D12() || IsVulkan() ? 1u : 0u, |
| // One blob per shader module |
| 1u, |
| }; |
| NiceMock<CachingInterfaceMock> mMockCache; |
| }; |
| |
| class SinglePipelineCachingTests : public PipelineCachingTests {}; |
| |
| // Tests that pipeline creation works fine even if the cache is disabled. |
| // Note: This tests needs to use more than 1 device since the frontend cache on each device |
| // will prevent going out to the blob cache. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineNoCache) { |
| mMockCache.Disable(); |
| |
| // First time should create and since cache is disabled, it should not write out to the |
| // cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), device.CreateComputePipeline(&desc)); |
| } |
| |
| // Second time should create fine with no cache hits since cache is disabled. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), device.CreateComputePipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation on the same device uses frontend cache when possible. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineFrontedCache) { |
| wgpu::ComputePipelineDescriptor desc; |
| desc.layout = utils::MakeBasicPipelineLayout(device, nullptr); |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| |
| // First creation should create a cache entry. |
| wgpu::ComputePipeline pipeline; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| pipeline = device.CreateComputePipeline(&desc)); |
| |
| // Second creation on the same device should just return from frontend cache and should not |
| // call out to the blob cache. |
| EXPECT_CALL(mMockCache, LoadData).Times(0); |
| wgpu::ComputePipeline samePipeline; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), |
| samePipeline = device.CreateComputePipeline(&desc)); |
| EXPECT_EQ(pipeline.Get() == samePipeline.Get(), !UsesWire()); |
| } |
| |
| // Tests that pipeline creation hits the cache when it is enabled. |
| // Note: This test needs to use more than 1 device since the frontend cache on each device |
| // will prevent going out to the blob cache. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineBlobCache) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| |
| // Second time should create using the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule + counts.pipeline), Add(0), |
| device.CreateComputePipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation hits the cache when using the same pipeline but with explicit |
| // layout. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineBlobCacheExplictLayout) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| |
| // Cache should hit: use the same pipeline but with explicit pipeline layout. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| desc.layout = utils::MakeBasicPipelineLayout(device, {}); |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule + counts.pipeline), Add(0), |
| device.CreateComputePipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation wouldn't hit the cache if the pipelines are not exactly the same. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineBlobCacheShaderNegativeCases) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| |
| // Cache should not hit: different shader module. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = |
| utils::CreateShaderModule(device, kComputeShaderMultipleEntryPoints.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| |
| // Cache should not hit: same shader module but different shader entry point. |
| { |
| wgpu::Device device = CreateDevice(); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = |
| utils::CreateShaderModule(device, kComputeShaderMultipleEntryPoints.data()); |
| desc.compute.entryPoint = "main2"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation does not hits the cache when it is enabled but we use different |
| // isolation keys. |
| TEST_P(SinglePipelineCachingTests, ComputePipelineBlobCacheIsolationKey) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice("isolation key 1"); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| |
| // Second time should also create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice("isolation key 2"); |
| wgpu::ComputePipelineDescriptor desc; |
| desc.compute.module = utils::CreateShaderModule(device, kComputeShaderDefault.data()); |
| desc.compute.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(counts.shaderModule + counts.pipeline), |
| device.CreateComputePipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation works fine even if the cache is disabled. |
| // Note: This tests needs to use more than 1 device since the frontend cache on each device |
| // will prevent going out to the blob cache. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineNoCache) { |
| mMockCache.Disable(); |
| |
| // First time should create and since cache is disabled, it should not write out to the |
| // cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Second time should create fine with no cache hits since cache is disabled. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation on the same device uses frontend cache when possible. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineFrontedCache) { |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.layout = utils::MakeBasicPipelineLayout(device, nullptr); |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| |
| // First creation should create a cache entry. |
| wgpu::RenderPipeline pipeline; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| pipeline = device.CreateRenderPipeline(&desc)); |
| |
| // Second creation on the same device should just return from frontend cache and should not |
| // call out to the blob cache. |
| EXPECT_CALL(mMockCache, LoadData).Times(0); |
| wgpu::RenderPipeline samePipeline; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(0), |
| samePipeline = device.CreateRenderPipeline(&desc)); |
| EXPECT_EQ(pipeline.Get() == samePipeline.Get(), !UsesWire()); |
| } |
| |
| // Tests that pipeline creation hits the cache when it is enabled. |
| // Note: This test needs to use more than 1 device since the frontend cache on each device |
| // will prevent going out to the blob cache. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCache) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Second time should create using the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule + counts.pipeline), Add(0), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation hits the cache when using the same pipeline but with explicit |
| // layout. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheExplictLayout) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should hit: use the same pipeline but with explicit pipeline layout. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| desc.layout = utils::MakeBasicPipelineLayout(device, {}); |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule + counts.pipeline), Add(0), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation wouldn't hit the cache if the pipelines have different state set in |
| // the descriptor. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheDescriptorNegativeCases) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should hit for shaders, but not pipeline: different pipeline descriptor state. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.EnableDepthStencil(); |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule), Add(counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation wouldn't hit the cache if the pipelines are not exactly the same in |
| // terms of shader. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheShaderNegativeCases) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should not hit for different vertex shader module, |
| // Cache should still hit for the same fragment shader module. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = |
| utils::CreateShaderModule(device, kVertexShaderMultipleEntryPoints.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule), |
| Add(counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should not hit: same shader module but different shader entry point. |
| // Cache should still hit for the same shader module. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = |
| utils::CreateShaderModule(device, kVertexShaderMultipleEntryPoints.data()); |
| desc.vertex.entryPoint = "main2"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule), |
| Add(counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation wouldn't hit the cache if the pipelines are not exactly the same |
| // (fragment color targets differences). |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheNegativeCasesFragmentColorTargets) { |
| // In compat, all targets must have the same writeMask |
| DAWN_TEST_UNSUPPORTED_IF(IsCompatibilityMode()); |
| |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.cFragment.targetCount = 2; |
| desc.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| desc.cTargets[1].writeMask = wgpu::ColorWriteMask::None; |
| desc.cTargets[1].format = wgpu::TextureFormat::RGBA8Unorm; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderMultipleOutput.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should not hit for the pipeline: different fragment color target state (sparse). |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.cFragment.targetCount = 2; |
| desc.cTargets[0].format = wgpu::TextureFormat::Undefined; |
| desc.cTargets[1].writeMask = wgpu::ColorWriteMask::None; |
| desc.cTargets[1].format = wgpu::TextureFormat::RGBA8Unorm; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderMultipleOutput.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule), Add(counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should not hit: different fragment color target state (trailing empty). |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.cFragment.targetCount = 2; |
| desc.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| desc.cTargets[1].writeMask = wgpu::ColorWriteMask::None; |
| desc.cTargets[1].format = wgpu::TextureFormat::Undefined; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderMultipleOutput.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule), Add(counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| // Tests that pipeline creation hits the cache for shaders, but not the pipeline if the |
| // shaders aren't impacted by the layout. This test is a bit change detecting - but all |
| // cached backends currently remap shader bindings based on the layout. It can be split |
| // per-backend as needed. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheLayout) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderBindGroup00Uniform.data()); |
| desc.cFragment.entryPoint = "main"; |
| desc.layout = utils::MakePipelineLayout( |
| device, { |
| utils::MakeBindGroupLayout( |
| device, |
| { |
| {0, wgpu::ShaderStage::Fragment, wgpu::BufferBindingType::Uniform}, |
| }), |
| }); |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should hit for the shaders, but not for the pipeline: different layout. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderBindGroup00Uniform.data()); |
| desc.cFragment.entryPoint = "main"; |
| desc.layout = utils::MakePipelineLayout( |
| device, |
| { |
| utils::MakeBindGroupLayout( |
| device, |
| { |
| {0, wgpu::ShaderStage::Fragment, wgpu::BufferBindingType::Uniform}, |
| {1, wgpu::ShaderStage::Fragment, |
| // Note: OpenGL pipeline uses an internal uniform buffer which can be |
| // impacted by the extra uniform buffer binding layout, resulting in a |
| // shader module cache miss. |
| (IsOpenGL() || IsOpenGLES()) ? wgpu::BufferBindingType::ReadOnlyStorage |
| : wgpu::BufferBindingType::Uniform}, |
| }), |
| }); |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule), Add(counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should hit for the shaders, but not for the pipeline: different layout (dynamic). |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderBindGroup00Uniform.data()); |
| desc.cFragment.entryPoint = "main"; |
| desc.layout = utils::MakePipelineLayout( |
| device, { |
| utils::MakeBindGroupLayout(device, |
| { |
| {0, wgpu::ShaderStage::Fragment, |
| wgpu::BufferBindingType::Uniform, true}, |
| }), |
| }); |
| EXPECT_CACHE_STATS(mMockCache, Hit(2 * counts.shaderModule), Add(counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Cache should not hit for the fragment shader, but should hit for the pipeline. |
| // On Metal and Vulkan, the shader is different but compiles to the same due to binding number |
| // remapping. On other backends, the compiled shader is different and so is the pipeline. |
| { |
| wgpu::Device device = CreateDevice(); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = |
| utils::CreateShaderModule(device, kFragmentShaderBindGroup01Uniform.data()); |
| desc.cFragment.entryPoint = "main"; |
| desc.layout = utils::MakePipelineLayout( |
| device, { |
| utils::MakeBindGroupLayout( |
| device, |
| { |
| {1, wgpu::ShaderStage::Fragment, wgpu::BufferBindingType::Uniform}, |
| }), |
| }); |
| if (IsMetal() || IsVulkan()) { |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule + counts.pipeline), |
| Add(counts.shaderModule), device.CreateRenderPipeline(&desc)); |
| } else { |
| EXPECT_CACHE_STATS(mMockCache, Hit(counts.shaderModule), |
| Add(counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| } |
| |
| // Tests that pipeline creation does not hits the cache when it is enabled but we use different |
| // isolation keys. |
| TEST_P(SinglePipelineCachingTests, RenderPipelineBlobCacheIsolationKey) { |
| // First time should create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice("isolation key 1"); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| |
| // Second time should also create and write out to the cache. |
| { |
| wgpu::Device device = CreateDevice("isolation key 2"); |
| utils::ComboRenderPipelineDescriptor desc; |
| desc.vertex.module = utils::CreateShaderModule(device, kVertexShaderDefault.data()); |
| desc.vertex.entryPoint = "main"; |
| desc.cFragment.module = utils::CreateShaderModule(device, kFragmentShaderDefault.data()); |
| desc.cFragment.entryPoint = "main"; |
| EXPECT_CACHE_STATS(mMockCache, Hit(0), Add(2 * counts.shaderModule + counts.pipeline), |
| device.CreateRenderPipeline(&desc)); |
| } |
| } |
| |
| DAWN_INSTANTIATE_TEST(SinglePipelineCachingTests, |
| D3D11Backend(), |
| D3D12Backend(), |
| D3D12Backend({"use_dxc"}), |
| MetalBackend(), |
| OpenGLBackend(), |
| OpenGLESBackend(), |
| VulkanBackend()); |
| |
| } // anonymous namespace |
| } // namespace dawn |
