[mlir] [transform] Error for duplicated processor mapping

[guraypp]

Summary

In a nested loop nest, it is not feasible to map different loops to the same processing unit; for an example, check the code below. This modification includes a check in this circumstance.

scf.foreach_thread (%i, %j) in (%c32, %c32) {...}
{ mapping = [#gpu.thread<x>, #gpu.thread<x>] }

Note: It also deletes a test because it is not possible to reproduce this error.

Depends on D138020

[guraypp]

rebase
add newline

[ftynse]

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

46–48

The entire flow reads strange here. Assigning a captured variable inside a lambda inside the callback of any_of that kind of implies the function to be a non-side-effecting predicate, and then potentially overwriting it. Could we turn this into a normal loop with early returns instead?

48

Would llvm::is_contained work?

49–52

Nit: add braces around the conditional's body. We only omit braces when the statement is trivial, typically fits into one line.

[guraypp]

address @ftynse comments

[guraypp]

remove unnecessary include

[ftynse]

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

39

Nit: ArrayRef is already an implicitly constant reference to an array, no need to pass it by const reference additionally.

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

 class SimpleRewriter : public PatternRewriter {
 public:
   SimpleRewriter(MLIRContext *context) : PatternRewriter(context) {}
 };
 } // namespace
 
 /// Check if given mapping attributes are one of the desired attributes
 static DiagnosedSilenceableFailure checkAttributeType(
     const ArrayRef<DeviceMappingAttrInterface> &threadMappingAttributes,
     const Optional<ArrayAttr> &foreachMapping,
     llvm::Optional<TransformOpInterface> transformOp) {
+  DiagnosedSilenceableFailure diag = DiagnosedSilenceableFailure::success();
   if (!foreachMapping.has_value())
     return transformOp->emitSilenceableError() << "mapping must be present";
-
+  DenseSet<DeviceMappingAttrInterface> seen;
   if (llvm::any_of(foreachMapping->getValue(),
                    [&](DeviceMappingAttrInterface map) {
+                     if (seen.find(map) != seen.end())
+                       diag = transformOp->emitDefiniteFailure()
+                              << map
+                              << " is duplicated, cannot map different "
+                                 "loops to the same processor";
+
+                     seen.insert(map);
                      return llvm::find(threadMappingAttributes, map) ==
                             threadMappingAttributes.end();
                    }))
-    return transformOp->emitDefiniteFailure()
+    diag = transformOp->emitDefiniteFailure()
            << "mapping must be one of " << threadMappingAttributes;
-  return DiagnosedSilenceableFailure::success();
+  return diag;
 }
 
 /// Determines if the size of the kernel configuration is supported by the GPU
 /// architecture being used. It presently makes use of CUDA limitations, however
 /// that aspect may be enhanced for other GPUs.
 static DiagnosedSilenceableFailure
 checkGpuLimits(TransformOpInterface transformOp, Optional<int64_t> gridDimX,
                Optional<int64_t> gridDimY, Optional<int64_t> gridDimZ,

mlir/test/Dialect/GPU/transform-gpu-failing.mlir

 ^bb1(%arg0: !pdl.operation):
   %funcop = transform.structured.match ops{["gpu.launch"]} in %arg0
   // expected-error @below {{unsupported dynamic blockdim size}}
   transform.gpu.map_nested_foreach_to_threads %funcop { blockDim = [128, 4, 1] }
 }
 
 // -----
 
-func.func @map_nested_foreach_to_threads_4d_loop(%x: memref<2x32x32x32xf32>, %y: memref<2x32x32x32xf32>, %stream : !gpu.async.token) -> memref<2x32x32x32xf32> {
-  %one = arith.constant 1 : index
-  %c2 = arith.constant 1 : index
-  %c32 = arith.constant 32 : index
-  %name = gpu.launch async[%stream] blocks(%arg3, %arg4, %arg5) in (%arg9 = %one, %arg10 = %one, %arg11 = %one)
-            threads(%arg6, %arg7, %arg8) in (%arg12 = %one, %arg13 = %one, %arg14 = %one)
-  {
-    scf.foreach_thread (%i, %j, %k, %l) in (%c2, %c32,%c32,%c32) {
-        %4 = memref.load %x[%i, %j, %k, %l] : memref<2x32x32x32xf32>        
-        memref.store %4, %y[%i, %j, %k, %l] : memref<2x32x32x32xf32>
-     }  { mapping = [#gpu.thread<y>, #gpu.thread<x>, #gpu.thread<z>, #gpu.thread<z>] }
-    gpu.terminator
-  }
-  return %y : memref<2x32x32x32xf32>
-}
-
-transform.sequence failures(propagate) {
-^bb1(%arg0: !pdl.operation):
-  %funcop = transform.structured.match ops{["gpu.launch"]} in %arg0
-  // expected-error @below {{scf.foreach_thread with rank > 3 does not lower to gpu.thread_id}}
-  transform.gpu.map_nested_foreach_to_threads %funcop { blockDim = [128, 4, 1] }
-}
-
-// -----
-
 func.func @map_nested_foreach_to_threads_not_buffer(%x: tensor<32x32xf32>, %y: tensor<32x32xf32>, %z: tensor<32x32xf32>, %stream : !gpu.async.token) {
   %one = arith.constant 1 : index
   %name = gpu.launch async[%stream] blocks(%arg3, %arg4, %arg5) in (%arg9 = %one, %arg10 = %one, %arg11 = %one)
             threads(%arg6, %arg7, %arg8) in (%arg12 = %one, %arg13 = %one, %arg14 = %one)
   {
     %t = linalg.matmul ins(%x, %y: tensor<32x32xf32>, tensor<32x32xf32>) outs(%z : tensor<32x32xf32>) -> tensor<32x32xf32>
     gpu.terminator
   }  

 transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):  
   %funcop = transform.structured.match ops{["func.func"]} in %arg0   
   // expected-error @below {{Trying to launch a GPU kernel with gridDim = (65535, 65535, 1) blockDim = (1, 1, 1). It is larger than the limits.}}
   %1 = transform.gpu.map_foreach_to_blocks %funcop { generate_gpu_launch }
 }
 
 // -----
+
+
+!type = memref<32x32xf32>
+func.func @saxpy2d_singleloop(%x: !type, %y: !type, %stream : !gpu.async.token) -> !type {
+  %c32 = arith.constant 32 : index
+  %one = arith.constant 1 : index
+  %name = gpu.launch async[%stream] blocks(%arg3, %arg4, %arg5) in (%arg9 = %one, %arg10 = %one, %arg11 = %one)
+            threads(%arg6, %arg7, %arg8) in (%arg12 = %one, %arg13 = %one, %arg14 = %one)
+  {
+    scf.foreach_thread (%i, %j) in (%c32, %c32) {
+        %4 = memref.load %x[%i, %j] : !type
+        %5 = memref.load %y[%i, %j] : !type
+        %6 = arith.mulf %4, %5 : f32
+        memref.store %6, %y[%i, %j] : !type
+     }  { mapping = [#gpu.thread<x>, #gpu.thread<x>] }
+    gpu.terminator
+  }
+  return %y : !type
+}
+
+transform.sequence failures(propagate) {
+^bb1(%arg0: !pdl.operation):
+  %funcop = transform.structured.match ops{["gpu.launch"]} in %arg0
+  // expected-error @below {{#gpu.thread<x> is duplicated, cannot map different loops to the same processor}}
+  transform.gpu.map_nested_foreach_to_threads %funcop { blockDim = [32, 32]}
+}