add check access fully mapped

Author: bob80905

lib/API/DX/Device.cpp

@@ -549,73 +549,83 @@ class DXDevice : public offloadtest::Device {
                           "Failed to create reserved resource (buffer)."))
         return Err;
 
-      // Committed Upload Buffer
+      // Committed Upload Buffer (CPU visible)
       ComPtr<ID3D12Resource> UploadBuffer;
       const D3D12_HEAP_PROPERTIES UploadHeapProps =
           CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
 
       if (auto Err = HR::toError(
               Device->CreateCommittedResource(
                   &UploadHeapProps, D3D12_HEAP_FLAG_NONE, &UploadResDesc,
-                  D3D12_RESOURCE_STATE_GENERIC_READ, // upload state for CPU
-                                                     // writes
-                  nullptr, IID_PPV_ARGS(&UploadBuffer)),
+                  D3D12_RESOURCE_STATE_GENERIC_READ, nullptr,
+                  IID_PPV_ARGS(&UploadBuffer)),
               "Failed to create committed resource (upload buffer)."))
         return Err;
 
-      // Tile mapping setup
-      UINT numTiles = R.TilesMapped;
-      std::vector<D3D12_TILED_RESOURCE_COORDINATE> startCoords(numTiles);
-      std::vector<D3D12_TILE_REGION_SIZE> regionSizes(numTiles);
-      std::vector<D3D12_TILE_RANGE_FLAGS> rangeFlags(
-          numTiles, D3D12_TILE_RANGE_FLAG_NONE);
-      std::vector<UINT> heapRangeStartOffsets(numTiles);
-      std::vector<UINT> rangeTileCounts(numTiles, 1);
-
-      // Create a heap large enough for all mapped tiles
-      D3D12_HEAP_DESC heapDesc = {};
-      heapDesc.Properties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
-      heapDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
-      heapDesc.SizeInBytes =
-          numTiles * D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
-      heapDesc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS;
-
-      ComPtr<ID3D12Heap> heap;
-      if (auto Err =
-              HR::toError(Device->CreateHeap(&heapDesc, IID_PPV_ARGS(&heap)),
-                          "Failed to create heap for tiled SRV resource."))
-        return Err;
+      // Tile mapping setup (optional if numTiles > 0)
+      UINT numTiles = static_cast<UINT>(R.TilesMapped);
+      ComPtr<ID3D12Heap> heap; // optional, only created if numTiles > 0
 
-      // Fill tile coordinates and region sizes
-      for (UINT i = 0; i < numTiles; ++i) {
-        startCoords[i] = {i, 0, 0, 0};
-        regionSizes[i].NumTiles = 1;
-        regionSizes[i].UseBox = FALSE;
-        heapRangeStartOffsets[i] = i;
-      }
+      if (numTiles > 0) {
+        std::vector<D3D12_TILED_RESOURCE_COORDINATE> startCoords(numTiles);
+        std::vector<D3D12_TILE_REGION_SIZE> regionSizes(numTiles);
+        std::vector<D3D12_TILE_RANGE_FLAGS> rangeFlags(
+            numTiles, D3D12_TILE_RANGE_FLAG_NONE);
+        std::vector<UINT> heapRangeStartOffsets(numTiles);
+        std::vector<UINT> rangeTileCounts(numTiles, 1);
+
+        // Create a heap large enough for the mapped tiles
+        D3D12_HEAP_DESC heapDesc = {};
+        heapDesc.Properties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
+        heapDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+        heapDesc.SizeInBytes = static_cast<UINT64>(numTiles) *
+                               D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+        heapDesc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS;
+
+        if (auto Err =
+                HR::toError(Device->CreateHeap(&heapDesc, IID_PPV_ARGS(&heap)),
+                            "Failed to create heap for tiled SRV resource."))
+          return Err;
 
-      // Retrieve a command queue from InvocationState
-      ID3D12CommandQueue *CommandQueue = IS.Queue.Get();
+        // Fill tile coordinates and region sizes
+        for (UINT i = 0; i < numTiles; ++i) {
+          startCoords[i] = {i, 0, 0, 0};
+          regionSizes[i].NumTiles = 1;
+          regionSizes[i].UseBox = FALSE;
+          heapRangeStartOffsets[i] = i;
+        }
+
+        // Retrieve a command queue from InvocationState
+        ID3D12CommandQueue *CommandQueue = IS.Queue.Get();
 
-      // Map the first numTiles tiles in the Buffer
-      CommandQueue->UpdateTileMappings(
-          Buffer.Get(), numTiles, startCoords.data(), regionSizes.data(),
-          heap.Get(), numTiles, rangeFlags.data(), heapRangeStartOffsets.data(),
-          rangeTileCounts.data(), D3D12_TILE_MAPPING_FLAG_NONE);
+        // Map the first numTiles tiles in the Buffer
+        CommandQueue->UpdateTileMappings(
+            Buffer.Get(), numTiles, startCoords.data(), regionSizes.data(),
+            heap.Get(), numTiles, rangeFlags.data(),
+            heapRangeStartOffsets.data(), rangeTileCounts.data(),
+            D3D12_TILE_MAPPING_FLAG_NONE);
+      }
 
       // Upload data initialization
       void *ResDataPtr = nullptr;
       D3D12_RANGE range = {0, 0}; // no reads expected
       if (SUCCEEDED(UploadBuffer->Map(0, &range, &ResDataPtr))) {
         memcpy(ResDataPtr, ResData.get(), R.size());
+        // Zero remaining bytes if the buffer is padded
+        if (R.size() < BufferSize) {
+          memset(static_cast<char *>(ResDataPtr) + R.size(), 0,
+                 BufferSize - R.size());
+        }
         UploadBuffer->Unmap(0, nullptr);
       } else {
         return llvm::createStringError(std::errc::io_error,
                                        "Failed to map SRV upload buffer.");
       }
 
+      // Add GPU upload commands
       addResourceUploadCommands(R, IS, Buffer, UploadBuffer);
 
+      // Store resource bundle (heap optional)
       Bundle.emplace_back(UploadBuffer, Buffer, nullptr, heap);
       RegOffset++;
     }

test/Feature/HLSLLib/Mapped.test

@@ -8,6 +8,7 @@ StructuredBuffer<S> X : register(t0);
 StructuredBuffer<S> Y : register(t1);
 
 RWStructuredBuffer<int> Out : register(u2);
+RWStructuredBuffer<int> CAFM : register(u3);
 
 
 [numthreads(1,1,1)]
@@ -21,21 +22,25 @@ void main() {
   S Out0 = X.Load(0, status);
   Out[idx] = Out0.data[0];
   Out[idx + 4] = status;
+  CAFM[idx] = CheckAccessFullyMapped(status) ? 1 : 0;
   idx += 1;
 
   S Out1 = X.Load(50, status);
   Out[idx] = Out1.data[0];
   Out[idx + 4] = status;
+  CAFM[idx] = CheckAccessFullyMapped(status) ? 1 : 0;
   idx += 1;
 
   S Out2 = Y.Load(0, status);
   Out[idx] = Out2.data[0];
   Out[idx + 4] = status;
+  CAFM[idx] = CheckAccessFullyMapped(status) ? 1 : 0;
   idx += 1;
 
   S Out3 = Y.Load(50, status);
   Out[idx] = Out3.data[0];
-  Out[idx + 4] = status;  
+  Out[idx + 4] = status;
+  CAFM[idx] = CheckAccessFullyMapped(status) ? 1 : 0;
 }
 //--- pipeline.yaml
 
@@ -64,13 +69,27 @@ Buffers:
     Stride: 4
     # first 4 values are the actual data retrieved. For non-resident loads, 0 is expected.
     # last 4 values are the status. 1 is expected for resident memory, 0 for non-resident
-    Data: [1, 1, 2, 0, 1, 1, 1, 0]
+    Data: [1, 0, 0, 0, 1, 0, 0, 0]
+  - Name: CAFM
+    Format: Int32
+    Stride: 4
+    FillSize: 16
+    FillValue: 0
+  - Name: ExpectedCAFM
+    Format: Int32
+    Stride: 4
+    # Only the first data access should be accessing fully mapped memory
+    Data: [1, 0, 0, 0]
 
 Results:
   - Result: Test
-    Rule: BufferExact    
+    Rule: BufferExact
     Actual: Out
     Expected: ExpectedOut
+  - Result: TestCAFM
+    Rule: BufferExact
+    Actual: CAFM
+    Expected: ExpectedCAFM
 DescriptorSets:
   - Resources:
     - Name: X
@@ -80,21 +99,29 @@ DescriptorSets:
         Space: 0
       VulkanBinding:
         Binding: 0
+      TilesMapped: 1
     - Name: Y
       Kind: StructuredBuffer
       DirectXBinding:
         Register: 1
         Space: 0
       VulkanBinding:
         Binding: 1
-      TilesMapped: 1
+      TilesMapped: 0
     - Name: Out
       Kind: RWStructuredBuffer
       DirectXBinding:
         Register: 2
         Space: 0
       VulkanBinding:
         Binding: 2
+    - Name: CAFM
+      Kind: RWStructuredBuffer
+      DirectXBinding:
+        Register: 3
+        Space: 0
+      VulkanBinding:
+        Binding: 3
 #--- end
 
 # XFAIL: Clang