| // Copyright 2017 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 <algorithm> |
| |
| #include "dawn/common/Assert.h" |
| #include "dawn/common/Constants.h" |
| #include "dawn/common/Math.h" |
| #include "dawn/common/Range.h" |
| #include "dawn/native/Format.h" |
| #include "dawn/native/d3d12/TextureCopySplitter.h" |
| #include "dawn/native/d3d12/UtilsD3D12.h" |
| #include "dawn/native/d3d12/d3d12_platform.h" |
| #include "dawn/utils/TestUtils.h" |
| #include "dawn/webgpu_cpp_print.h" |
| #include "gtest/gtest.h" |
| |
| namespace dawn::native::d3d12 { |
| namespace { |
| |
| // Suffix operator for TexelCount |
| constexpr TexelCount operator""_tc(uint64_t v) { |
| return TexelCount{v}; |
| } |
| // Suffix operator for BlockCount |
| constexpr BlockCount operator""_bc(uint64_t v) { |
| return BlockCount{v}; |
| } |
| |
| struct TextureSpec { |
| TexelOrigin3D origin; |
| TexelExtent3D copySize; |
| TypedTexelBlockInfo blockInfo; |
| }; |
| |
| struct BufferSpec { |
| uint64_t offset; // byte offset into buffer to copy to/from |
| uint32_t bytesPerRow; // bytes per block row (multiples of 256), aka row pitch |
| BlockCount rowsPerImage; // bock rows per image slice (user-defined) |
| }; |
| |
| // Check that each copy region fits inside the buffer footprint |
| void ValidateFootprints(const TextureSpec& textureSpec, |
| const BufferSpec& bufferSpec, |
| const TextureCopySubresource& copySubresource, |
| wgpu::TextureDimension dimension) { |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| const auto& copy = copySubresource.copies[i]; |
| // TODO(425944899): Rework this function to work in blocks, not texels |
| const TexelExtent3D& copySize = blockInfo.ToTexel(copy.copySize); |
| const TexelOrigin3D& bufferOffset = blockInfo.ToTexel(copy.bufferOffset); |
| const TexelExtent3D& bufferSize = blockInfo.ToTexel(copy.bufferSize); |
| ASSERT_LE(bufferOffset.x + copySize.width, bufferSize.width); |
| ASSERT_LE(bufferOffset.y + copySize.height, bufferSize.height); |
| ASSERT_LE(bufferOffset.z + copySize.depthOrArrayLayers, bufferSize.depthOrArrayLayers); |
| |
| BlockCount widthInBlocks = blockInfo.ToBlockWidth(textureSpec.copySize.width); |
| BlockCount heightInBlocks = blockInfo.ToBlockHeight(textureSpec.copySize.height); |
| uint64_t minimumRequiredBufferSize = |
| bufferSpec.offset + |
| // TOOD(425944899): add overload of RequiredBytesInCopy that accepts strong types |
| utils::RequiredBytesInCopy( |
| bufferSpec.bytesPerRow, static_cast<uint32_t>(bufferSpec.rowsPerImage), |
| static_cast<uint32_t>(widthInBlocks), static_cast<uint32_t>(heightInBlocks), |
| static_cast<uint32_t>(textureSpec.copySize.depthOrArrayLayers), blockInfo.byteSize); |
| |
| // The last pixel (buffer footprint) of each copy region depends on its |
| // bufferOffset and copySize. It is not the last pixel where the bufferSize |
| // ends. |
| ASSERT_EQ(bufferOffset.x % blockInfo.width, 0_tc); |
| ASSERT_EQ(copySize.width % blockInfo.width, 0_tc); |
| TexelCount footprintWidth = bufferOffset.x + copySize.width; |
| ASSERT_EQ(footprintWidth % blockInfo.width, 0_tc); |
| BlockCount footprintWidthInBlocks = blockInfo.ToBlockWidth(footprintWidth); |
| |
| ASSERT_EQ(bufferOffset.y % blockInfo.height, 0_tc); |
| ASSERT_EQ(copySize.height % blockInfo.height, 0_tc); |
| TexelCount footprintHeight = bufferOffset.y + copySize.height; |
| ASSERT_EQ(footprintHeight % blockInfo.height, 0_tc); |
| BlockCount footprintHeightInBlocks = blockInfo.ToBlockHeight(footprintHeight); |
| |
| uint64_t bufferSizeForFootprint = |
| copy.alignedOffset + |
| utils::RequiredBytesInCopy( |
| bufferSpec.bytesPerRow, |
| static_cast<uint32_t>(blockInfo.ToBlockHeight(bufferSize.height)), |
| static_cast<uint32_t>(footprintWidthInBlocks), |
| static_cast<uint32_t>(footprintHeightInBlocks), |
| static_cast<uint32_t>(blockInfo.ToBlockDepth(bufferSize.depthOrArrayLayers)), |
| blockInfo.byteSize); |
| |
| // The buffer footprint of each copy region should not exceed the minimum |
| // required buffer size. Otherwise, pixels accessed by copy may be OOB. |
| ASSERT_LE(bufferSizeForFootprint, minimumRequiredBufferSize); |
| } |
| } |
| |
| // Check that the offset is aligned to D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT (512) |
| void ValidateOffset(const TextureCopySubresource& copySubresource, bool relaxed) { |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| if (!relaxed) { |
| ASSERT_TRUE(Align(copySubresource.copies[i].alignedOffset, |
| D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT) == |
| copySubresource.copies[i].alignedOffset); |
| } |
| } |
| } |
| |
| template <typename T> |
| bool InclusiveRangesOverlap(T minA, T maxA, T minB, T maxB) { |
| return (minA <= minB && minB <= maxA) || (minB <= minA && minA <= maxB); |
| } |
| |
| // Check that no pair of copy regions intersect each other |
| void ValidateDisjoint(const TextureSpec& textureSpec, |
| const TextureCopySubresource& copySubresource) { |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| const auto& a = copySubresource.copies[i]; |
| // TODO(425944899): Rework this function to work in blocks, not texels |
| const TexelExtent3D& copySizeA = blockInfo.ToTexel(a.copySize); |
| const TexelOrigin3D& textureOffsetA = blockInfo.ToTexel(a.textureOffset); |
| for (uint32_t j = i + 1; j < copySubresource.count; ++j) { |
| const auto& b = copySubresource.copies[j]; |
| // If textureOffset.x is 0, and copySize.width is 2, we are copying pixel 0 and |
| // 1. We never touch pixel 2 on x-axis. So the copied range on x-axis should be |
| // [textureOffset.x, textureOffset.x + copySize.width - 1] and both ends are |
| // included. |
| const TexelExtent3D& copySizeB = blockInfo.ToTexel(b.copySize); |
| const TexelOrigin3D& textureOffsetB = blockInfo.ToTexel(b.textureOffset); |
| bool overlapX = |
| InclusiveRangesOverlap(textureOffsetA.x, textureOffsetA.x + copySizeA.width - 1_tc, |
| textureOffsetB.x, textureOffsetB.x + copySizeB.width - 1_tc); |
| bool overlapY = InclusiveRangesOverlap( |
| textureOffsetA.y, textureOffsetA.y + copySizeA.height - 1_tc, textureOffsetB.y, |
| textureOffsetB.y + copySizeB.height - 1_tc); |
| bool overlapZ = InclusiveRangesOverlap( |
| textureOffsetA.z, textureOffsetA.z + copySizeA.depthOrArrayLayers - 1_tc, |
| textureOffsetB.z, textureOffsetB.z + copySizeB.depthOrArrayLayers - 1_tc); |
| ASSERT_TRUE(!overlapX || !overlapY || !overlapZ); |
| } |
| } |
| } |
| |
| // Check that the union of the copy regions exactly covers the texture region |
| void ValidateTextureBounds(const TextureSpec& textureSpec, |
| const TextureCopySubresource& copySubresource) { |
| ASSERT_GT(copySubresource.count, 0u); |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| |
| // TODO(425944899): Rework this function to work in blocks, not texels |
| const TexelExtent3D& copySize0 = blockInfo.ToTexel(copySubresource.copies[0].copySize); |
| const TexelOrigin3D& textureOffset0 = |
| blockInfo.ToTexel(copySubresource.copies[0].textureOffset); |
| TexelCount minX = textureOffset0.x; |
| TexelCount minY = textureOffset0.y; |
| TexelCount minZ = textureOffset0.z; |
| TexelCount maxX = textureOffset0.x + copySize0.width; |
| TexelCount maxY = textureOffset0.y + copySize0.height; |
| TexelCount maxZ = textureOffset0.z + copySize0.depthOrArrayLayers; |
| |
| for (uint32_t i = 1; i < copySubresource.count; ++i) { |
| const auto& copy = copySubresource.copies[i]; |
| const TexelOrigin3D& textureOffset = blockInfo.ToTexel(copy.textureOffset); |
| minX = std::min(minX, textureOffset.x); |
| minY = std::min(minY, textureOffset.y); |
| minZ = std::min(minZ, textureOffset.z); |
| const TexelExtent3D& copySize = blockInfo.ToTexel(copy.copySize); |
| maxX = std::max(maxX, textureOffset.x + copySize.width); |
| maxY = std::max(maxY, textureOffset.y + copySize.height); |
| maxZ = std::max(maxZ, textureOffset.z + copySize.depthOrArrayLayers); |
| } |
| |
| ASSERT_EQ(minX, textureSpec.origin.x); |
| ASSERT_EQ(minY, textureSpec.origin.y); |
| ASSERT_EQ(minZ, textureSpec.origin.z); |
| ASSERT_EQ(maxX, textureSpec.origin.x + textureSpec.copySize.width); |
| ASSERT_EQ(maxY, textureSpec.origin.y + textureSpec.copySize.height); |
| ASSERT_EQ(maxZ, textureSpec.origin.z + textureSpec.copySize.depthOrArrayLayers); |
| } |
| |
| // Validate that the number of pixels copied is exactly equal to the number of pixels in the |
| // texture region |
| void ValidatePixelCount(const TextureSpec& textureSpec, |
| const TextureCopySubresource& copySubresource) { |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| TexelCount totalCopiedTexels{0}; |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| const auto& copy = copySubresource.copies[i]; |
| // TODO(425944899): Rework this function to work in blocks, not texels |
| const TexelExtent3D& copySize = blockInfo.ToTexel(copy.copySize); |
| TexelCount copiedTexels = copySize.width * copySize.height * copySize.depthOrArrayLayers; |
| ASSERT_GT(copiedTexels, 0_tc); |
| totalCopiedTexels += copiedTexels; |
| } |
| ASSERT_EQ(totalCopiedTexels, textureSpec.copySize.width * textureSpec.copySize.height * |
| textureSpec.copySize.depthOrArrayLayers); |
| } |
| |
| // Check that every buffer offset is at the correct pixel location |
| void ValidateBufferOffset(const TextureSpec& textureSpec, |
| const BufferSpec& bufferSpec, |
| const TextureCopySubresource& copySubresource, |
| wgpu::TextureDimension dimension, |
| bool relaxed) { |
| ASSERT_GT(copySubresource.count, 0u); |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| const auto& copy = copySubresource.copies[i]; |
| const BlockOrigin3D& bufferOffset = copy.bufferOffset; |
| const BlockOrigin3D& textureOffset = copy.textureOffset; |
| // Note that for relaxed, the row pitch (bytesPerRow) is not required to be 256 bytes, |
| // but Dawn currently doesn't do anything about this. |
| BlockCount rowPitchInBlocks = blockInfo.BytesToBlocks(bufferSpec.bytesPerRow); |
| BlockCount slicePitchInBlocks = rowPitchInBlocks * bufferSpec.rowsPerImage; |
| BlockCount absoluteOffsetInBlocks = blockInfo.BytesToBlocks(copy.alignedOffset) + |
| bufferOffset.x + bufferOffset.y * rowPitchInBlocks; |
| |
| // There is one empty row at most in a 2D copy region. However, it is not true for |
| // a 3D texture copy region when we are copying the last row of each slice. We may |
| // need to offset a lot rows and copy.bufferOffset.y may be big. |
| if (dimension == wgpu::TextureDimension::e2D) { |
| ASSERT_LE(bufferOffset.y, BlockCount{1}); |
| } |
| ASSERT_EQ(bufferOffset.z, 0_bc); |
| |
| ASSERT_GE(absoluteOffsetInBlocks, blockInfo.BytesToBlocks(bufferSpec.offset)); |
| |
| BlockCount relativeOffsetInBlocks = |
| absoluteOffsetInBlocks - blockInfo.BytesToBlocks(bufferSpec.offset); |
| |
| BlockCount zBlocks = relativeOffsetInBlocks / slicePitchInBlocks; |
| BlockCount yBlocks = (relativeOffsetInBlocks % slicePitchInBlocks) / rowPitchInBlocks; |
| BlockCount xBlocks = relativeOffsetInBlocks % rowPitchInBlocks; |
| |
| ASSERT_EQ(textureOffset.x - blockInfo.ToBlockWidth(textureSpec.origin.x), xBlocks); |
| ASSERT_EQ(textureOffset.y - blockInfo.ToBlockHeight(textureSpec.origin.y), yBlocks); |
| ASSERT_EQ(textureOffset.z - blockInfo.ToBlockDepth(textureSpec.origin.z), zBlocks); |
| } |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const TextureSpec& textureSpec) { |
| os << "TextureSpec(" << "[origin=(" << textureSpec.origin.x << ", " << textureSpec.origin.y |
| << ", " << textureSpec.origin.z << "), copySize=(" << textureSpec.copySize.width << ", " |
| << textureSpec.copySize.height << ", " << textureSpec.copySize.depthOrArrayLayers |
| << ")], blockBytes=" << textureSpec.blockInfo.byteSize |
| << ", blockWidth=" << textureSpec.blockInfo.width |
| << ", blockHeight=" << textureSpec.blockInfo.height << ")"; |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const BufferSpec& bufferSpec) { |
| os << "BufferSpec(offset=" << bufferSpec.offset << ", bytesPerRow=" << bufferSpec.bytesPerRow |
| << ", rowsPerImage=" << bufferSpec.rowsPerImage << ")"; |
| return os; |
| } |
| std::ostream& operator<<(std::ostream& os, const TextureCopySubresource& copySubresource) { |
| os << "CopySplit\n"; |
| for (uint32_t i = 0; i < copySubresource.count; ++i) { |
| const auto& copy = copySubresource.copies[i]; |
| auto& textureOffset = copy.textureOffset; |
| auto& bufferOffset = copy.bufferOffset; |
| auto& copySize = copy.copySize; |
| os << " " << i << ": Texture at (" << textureOffset.x << ", " << textureOffset.y << ", " |
| << textureOffset.z << "), size (" << copySize.width << ", " << copySize.height << ", " |
| << copySize.depthOrArrayLayers << ")\n"; |
| os << " " << i << ": Buffer at (" << bufferOffset.x << ", " << bufferOffset.y << ", " |
| << bufferOffset.z << "), footprint (" << copySize.width << ", " << copySize.height |
| << ", " << copySize.depthOrArrayLayers << ")\n"; |
| } |
| return os; |
| } |
| |
| // Define base texture sizes and offsets to test with: some aligned, some unaligned |
| constexpr TextureSpec kBaseTextureSpecs[] = { |
| // 1x1 2D copies |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {31_tc, 16_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| // 2x1, 1x2, and 2x2 |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| // 1024x1024 2D and 3D |
| {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {256_tc, 512_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {64_tc, 48_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {64_tc, 48_tc, 16_tc}, |
| .copySize = {1024_tc, 1024_tc, 1024_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| // Non-power of two texture dims |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {257_tc, 31_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {17_tc, 93_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {59_tc, 13_tc, 0_tc}, |
| .copySize = {257_tc, 31_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {17_tc, 73_tc, 0_tc}, |
| .copySize = {17_tc, 93_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| {.origin = {17_tc, 73_tc, 59_tc}, |
| .copySize = {17_tc, 93_tc, 99_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}, |
| // 4x4 block size 2D copies |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}}, |
| // 4x4 block size 2D copies of 1024x1024 textures |
| {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {256_tc, 512_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 48_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 48_tc, 16_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {256_tc, 512_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {64_tc, 48_tc, 0_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {4, 16_tc, 4_tc}}, |
| {.origin = {64_tc, 48_tc, 16_tc}, |
| .copySize = {1024_tc, 1024_tc, 1_tc}, |
| .blockInfo = {16, 4_tc, 4_tc}}, |
| // 4x4 block size 3D copies |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 2_tc}, .blockInfo = {8, 4_tc, 4_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 2_tc}, .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 8_tc}, .blockInfo = {16, 4_tc, 4_tc}}, |
| {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 4_tc, 8_tc}, .blockInfo = {8, 4_tc, 4_tc}}, |
| }; |
| |
| // Define base buffer sizes to work with: some offsets aligned, some unaligned. bytesPerRow |
| // is the minimum required |
| std::array<BufferSpec, 15> BaseBufferSpecs(const TextureSpec& textureSpec) { |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| uint32_t bytesPerRow = |
| Align(blockInfo.ToBytes(blockInfo.ToBlockWidth(textureSpec.copySize.width)), |
| kTextureBytesPerRowAlignment); |
| |
| auto alignNonPow2 = [](uint32_t value, uint32_t size) -> uint32_t { |
| return value == 0 ? 0 : ((value - 1) / size + 1) * size; |
| }; |
| |
| BlockCount copyHeight = blockInfo.ToBlockHeight(textureSpec.copySize.height); |
| |
| return { |
| BufferSpec{alignNonPow2(0, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(256, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(512, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(1024, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(1024, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc}, |
| |
| BufferSpec{alignNonPow2(32, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(64, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(64, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc}, |
| |
| BufferSpec{alignNonPow2(31, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(257, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(384, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(511, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(513, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(1023, blockInfo.byteSize), bytesPerRow, copyHeight}, |
| BufferSpec{alignNonPow2(1023, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc}, |
| }; |
| } |
| |
| // Define a list of values to set properties in the spec structs |
| constexpr uint32_t kCheckValues[] = {1, 2, 3, 4, 5, 6, 7, 8, // small values |
| 16, 32, 64, 128, 256, 512, 1024, 2048, // powers of 2 |
| 15, 31, 63, 127, 257, 511, 1023, 2047, // misalignments |
| 17, 33, 65, 129, 257, 513, 1025, 2049}; |
| |
| struct CopySplitTestParam { |
| wgpu::TextureDimension dimension; |
| bool relaxed; |
| }; |
| |
| class CopySplitTest : public testing::TestWithParam<CopySplitTestParam> { |
| protected: |
| void DoTest(const TextureSpec& textureSpec, |
| const BufferSpec& bufferSpec, |
| wgpu::TextureDimension dimension, |
| bool relaxed) { |
| const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo; |
| DAWN_ASSERT(textureSpec.copySize.width % blockInfo.width == 0_tc && |
| textureSpec.copySize.height % blockInfo.height == 0_tc); |
| |
| // Add trace so that failures emit the input test specs |
| std::stringstream trace; |
| trace << textureSpec << ", " << bufferSpec; |
| SCOPED_TRACE(trace.str()); |
| |
| // This code emulates RecordBufferTextureCopyWithBufferHandle |
| |
| BlockCount blocksPerRow = blockInfo.BytesToBlocks(bufferSpec.bytesPerRow); |
| BlockCount rowsPerImage{bufferSpec.rowsPerImage}; |
| BlockOrigin3D origin = blockInfo.ToBlock(textureSpec.origin); |
| BlockExtent3D copySize = blockInfo.ToBlock(textureSpec.copySize); |
| |
| switch (dimension) { |
| case wgpu::TextureDimension::e1D: { |
| // Skip test cases that are clearly for 2D/3D. Validation would catch |
| // these cases before reaching the TextureCopySplitter. |
| if (textureSpec.origin.z > 0_tc || textureSpec.copySize.depthOrArrayLayers > 1_tc) { |
| return; |
| } |
| TextureCopySubresource copySubresource = Compute2DTextureCopySubresource( |
| origin, copySize, blockInfo, bufferSpec.offset, blocksPerRow, relaxed); |
| ValidateCopySplit(textureSpec, bufferSpec, copySubresource, dimension, relaxed); |
| break; |
| } |
| case wgpu::TextureDimension::e2D: { |
| if (relaxed) { |
| // Emulate Record2DBufferTextureCopyWithRelaxedOffsetAndPitch |
| TextureCopySubresource copySubresource = Compute2DTextureCopySubresource( |
| origin, copySize, blockInfo, bufferSpec.offset, blocksPerRow, relaxed); |
| |
| for ([[maybe_unused]] BlockCount copyLayer : |
| Range(copySize.depthOrArrayLayers)) { |
| // Since Compute2DTextureCopySubresource returns a single copy subresource |
| // to be used for each layer, we need to update the texture spec to validate |
| // for a single layer. |
| |
| // Unlike Record2DBufferTextureCopyWithRelaxedOffsetAndPitch, we don't need |
| // to compute a running buffer offset per layer, since ValidateFootprints |
| // assumes no extra offset on top of BufferSpec.offset. |
| |
| // Modify texture spec for a single layer |
| auto textureSpecCopy = textureSpec; |
| textureSpecCopy.origin.z = 0_tc; |
| textureSpecCopy.copySize.depthOrArrayLayers = blockInfo.ToTexelDepth(1_bc); |
| |
| ValidateCopySplit(textureSpecCopy, bufferSpec, copySubresource, dimension, |
| relaxed); |
| } |
| |
| } else { |
| // Emulate Record2DBufferTextureCopyWithSplit |
| TextureCopySplits copySplits = Compute2DTextureCopySplits( |
| origin, copySize, blockInfo, bufferSpec.offset, blocksPerRow, rowsPerImage); |
| const uint64_t bytesPerLayer = blockInfo.ToBytes(blocksPerRow * rowsPerImage); |
| for (BlockCount copyLayer : Range(copySize.depthOrArrayLayers)) { |
| const uint32_t splitIndex = |
| static_cast<uint32_t>(copyLayer) % copySplits.copySubresources.size(); |
| const TextureCopySubresource& copySubresourcePerLayer = |
| copySplits.copySubresources[splitIndex]; |
| |
| // Since Compute2DTextureCopySplits splits up the single copy into one or |
| // two alternating copies per layer, we need to modify the buffer and |
| // texture specs to validate for a single layer. |
| |
| auto bufferSpecCopy = bufferSpec; |
| // Unlike Record2DBufferTextureCopyWithSplit, we don't need to compute a |
| // running buffer offset per layer. However, we do need to add an offset for |
| // the 2nd (4th, 6th, etc.) layers because the copy subresource values are |
| // computed assuming an offset of bytesPerLayer from the previous (1st) |
| // copy, and ValidateFootprints will check for that. |
| const uint64_t bufferOffsetForNextLayer = |
| bytesPerLayer * static_cast<uint32_t>(splitIndex); |
| bufferSpecCopy.offset += bufferOffsetForNextLayer; |
| |
| // Modify texture spec for a single layer |
| auto textureSpecCopy = textureSpec; |
| textureSpecCopy.origin.z = 0_tc; |
| textureSpecCopy.copySize.depthOrArrayLayers = blockInfo.ToTexelDepth(1_bc); |
| |
| ValidateCopySplit(textureSpecCopy, bufferSpecCopy, copySubresourcePerLayer, |
| dimension, relaxed); |
| } |
| } |
| break; |
| } |
| case wgpu::TextureDimension::e3D: { |
| TextureCopySubresource copySubresource = |
| Compute3DTextureCopySubresource(origin, copySize, blockInfo, bufferSpec.offset, |
| blocksPerRow, rowsPerImage, relaxed); |
| ValidateCopySplit(textureSpec, bufferSpec, copySubresource, dimension, relaxed); |
| break; |
| } |
| default: |
| DAWN_UNREACHABLE(); |
| break; |
| } |
| } |
| |
| // Call from parameterized tests |
| void DoTest(const TextureSpec& textureSpec, const BufferSpec& bufferSpec) { |
| wgpu::TextureDimension dimension = GetParam().dimension; |
| bool relaxed = GetParam().relaxed; |
| DoTest(textureSpec, bufferSpec, dimension, relaxed); |
| } |
| |
| void ValidateCopySplit(const TextureSpec& textureSpec, |
| const BufferSpec& bufferSpec, |
| const TextureCopySubresource& copySubresource, |
| wgpu::TextureDimension dimension, |
| bool relaxed) { |
| ValidateFootprints(textureSpec, bufferSpec, copySubresource, dimension); |
| ValidateOffset(copySubresource, relaxed); |
| ValidateDisjoint(textureSpec, copySubresource); |
| ValidateTextureBounds(textureSpec, copySubresource); |
| ValidatePixelCount(textureSpec, copySubresource); |
| ValidateBufferOffset(textureSpec, bufferSpec, copySubresource, dimension, relaxed); |
| |
| if (HasFatalFailure()) { |
| std::ostringstream message; |
| message << "Failed generating splits: " << textureSpec << ", " << bufferSpec << "\n" |
| << dimension << " " << copySubresource << "\n"; |
| FAIL() << message.str(); |
| } |
| } |
| }; |
| |
| TEST_P(CopySplitTest, General) { |
| for (const TextureSpec& textureSpec : kBaseTextureSpecs) { |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, TextureWidth) { |
| for (TextureSpec textureSpec : kBaseTextureSpecs) { |
| for (uint32_t val : kCheckValues) { |
| if (TexelCount{val} % textureSpec.blockInfo.width != 0_tc) { |
| continue; |
| } |
| textureSpec.copySize.width = TexelCount{val}; |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, TextureHeight) { |
| for (TextureSpec textureSpec : kBaseTextureSpecs) { |
| for (uint32_t val : kCheckValues) { |
| if (TexelCount{val} % textureSpec.blockInfo.height != 0_tc) { |
| continue; |
| } |
| textureSpec.copySize.height = TexelCount{val}; |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, TextureX) { |
| for (TextureSpec textureSpec : kBaseTextureSpecs) { |
| for (uint32_t val : kCheckValues) { |
| if (TexelCount{val} % textureSpec.blockInfo.width != 0_tc) { |
| continue; |
| } |
| textureSpec.origin.x = TexelCount{val}; |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, TextureY) { |
| for (TextureSpec textureSpec : kBaseTextureSpecs) { |
| for (uint32_t val : kCheckValues) { |
| if (TexelCount{val} % textureSpec.blockInfo.height != 0_tc) { |
| continue; |
| } |
| textureSpec.origin.y = TexelCount{val}; |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, TexelSize) { |
| for (TextureSpec textureSpec : kBaseTextureSpecs) { |
| for (uint32_t texelSize : {4, 8, 16, 32, 64}) { |
| textureSpec.blockInfo.byteSize = texelSize; |
| for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) { |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, BufferOffset) { |
| for (const TextureSpec& textureSpec : kBaseTextureSpecs) { |
| for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) { |
| for (uint32_t val : kCheckValues) { |
| bufferSpec.offset = textureSpec.blockInfo.byteSize * val; |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, RowPitch) { |
| for (const TextureSpec& textureSpec : kBaseTextureSpecs) { |
| for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) { |
| uint32_t baseRowPitch = bufferSpec.bytesPerRow; |
| for (uint32_t i = 0; i < 5; ++i) { |
| bufferSpec.bytesPerRow = baseRowPitch + i * 256; |
| |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CopySplitTest, ImageHeight) { |
| for (const TextureSpec& textureSpec : kBaseTextureSpecs) { |
| for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) { |
| BlockCount baseImageHeight = bufferSpec.rowsPerImage; |
| for (uint32_t i = 0; i < 5; ++i) { |
| bufferSpec.rowsPerImage = baseImageHeight + BlockCount{i * 256}; |
| |
| DoTest(textureSpec, bufferSpec); |
| } |
| } |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| , |
| CopySplitTest, |
| testing::Values(CopySplitTestParam{.dimension = wgpu::TextureDimension::e1D, .relaxed = false}, |
| CopySplitTestParam{.dimension = wgpu::TextureDimension::e1D, .relaxed = true}, |
| CopySplitTestParam{.dimension = wgpu::TextureDimension::e2D, .relaxed = false}, |
| CopySplitTestParam{.dimension = wgpu::TextureDimension::e2D, .relaxed = true}, |
| CopySplitTestParam{.dimension = wgpu::TextureDimension::e3D, .relaxed = false}, |
| CopySplitTestParam{.dimension = wgpu::TextureDimension::e3D, .relaxed = true})); |
| |
| // Test for specific case that failed CTS for BCSliced3D formats (4x4 block) when the copy height |
| // is 1 block row, and we have a buffer offset that results in the copy region straddling |
| // bytesPerRow. |
| TEST_F(CopySplitTest, Block4x4_3D_CopyOneRow_StraddleBytesPerRowOffset) { |
| constexpr TexelCount blockDim = 4_tc; |
| constexpr uint32_t bytesPerBlock = 8; |
| TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {128_tc, 1_tc * blockDim, 8_tc}, |
| .blockInfo = {bytesPerBlock, blockDim, blockDim}}; |
| BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false); |
| } |
| // Test similar failure to above for 2x2 blocks |
| TEST_F(CopySplitTest, Block2x2_3D_CopyOneRow_StraddleBytesPerRowOffset) { |
| constexpr TexelCount blockDim = 2_tc; |
| constexpr uint32_t bytesPerBlock = 4; |
| TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {128_tc, 1_tc * blockDim, 8_tc}, |
| .blockInfo = {bytesPerBlock, blockDim, blockDim}}; |
| BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false); |
| } |
| // Also test 1x1, although this always passed as this one engages the "copySize.height is odd" path. |
| TEST_F(CopySplitTest, Block1x1_3D_CopyOneRow_StraddleBytesPerRowOffset) { |
| constexpr TexelCount blockDim = 1_tc; |
| constexpr uint32_t bytesPerBlock = 4; |
| TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {128_tc, 1_tc * blockDim, 8_tc}, |
| .blockInfo = {bytesPerBlock, blockDim, blockDim}}; |
| BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false); |
| } |
| |
| TEST_F(CopySplitTest, Blah) { |
| TextureSpec textureSpec = {.origin = {64_tc, 16_tc, 8_tc}, |
| .copySize = {1_tc, 1_tc, 1_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}; |
| BufferSpec bufferSpec = {.offset = 0, .bytesPerRow = 256, .rowsPerImage = 1_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e2D, false); |
| } |
| TEST_F(CopySplitTest, Blah2) { |
| TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc}, |
| .copySize = {64_tc, 1_tc, 2_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}; |
| BufferSpec bufferSpec = {.offset = 0, .bytesPerRow = 256, .rowsPerImage = 1_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e2D, false); |
| } |
| TEST_F(CopySplitTest, Blah3) { |
| TextureSpec textureSpec = {.origin = {64_tc, 48_tc, 16_tc}, |
| .copySize = {1024_tc, 1024_tc, 1024_tc}, |
| .blockInfo = {4, 1_tc, 1_tc}}; |
| BufferSpec bufferSpec = {.offset = 0, .bytesPerRow = 4096, .rowsPerImage = 1024_bc}; |
| DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e2D, false); |
| } |
| |
| } // anonymous namespace |
| } // namespace dawn::native::d3d12 |
