[mlir][tosa] Added div op, variadic concat. Removed placeholder. Spec v0.22 alignment.

[sjarus]

Summary

Nearly complete alignment to spec v0.22

• Adds Div op
• Concat inputs now variadic
• Removes Placeholder op

Note: TF side PR https://github.com/tensorflow/tensorflow/pull/48921 deletes Concat legalizations to avoid breaking TensorFlow CI. This must be merged only after the TF PR has merged.

[rsuderman]

The implementation looks good however the description needs work. Be more specific than a TOSA version and preface with [mlir][tosa]. It helps contributors to note if this is a CL they should be interested with. Description should be along the lines of "Added tosa.div op and remove tosa.placeholder". For the LLVM repo the summary should focus on what is specifically changing.

[sjarus]

In D101958#2741101, @rsuderman wrote:

The implementation looks good however the description needs work. Be more specific than a TOSA version and preface with [mlir][tosa]. It helps contributors to note if this is a CL they should be interested with. Description should be along the lines of "Added tosa.div op and remove tosa.placeholder". For the LLVM repo the summary should focus on what is specifically changing.

Seems I can use 'edit revision' to do this - and it shows as updated. I assume that takes care of this request ?

[rsuderman]

In D101958#2742222, @sjarus wrote:

In D101958#2741101, @rsuderman wrote:

The implementation looks good however the description needs work. Be more specific than a TOSA version and preface with [mlir][tosa]. It helps contributors to note if this is a CL they should be interested with. Description should be along the lines of "Added tosa.div op and remove tosa.placeholder". For the LLVM repo the summary should focus on what is specifically changing.

Seems I can use 'edit revision' to do this - and it shows as updated. I assume that takes care of this request ?

Yup, that should be fine. When I patch and sync it should use the updated commit messages.

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.td

def Tosa_BitwiseXorOp : Tosa_Op<"bitwise_xor", [ResultsBroadcastableShape,
   );
 
   let results = (outs
     Tosa_TensorUpto4D:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
+// Operator: div
+//===----------------------------------------------------------------------===//
+def Tosa_DivOp : Tosa_Op<"div", [ResultsBroadcastableShape,
+                                 NoSideEffect]> {
+  let summary = "Integer divide operator";
+
+  let description = [{
+    Elementwise integer divide operator of input1 by input2. Axis of size 1
+    will be broadcast, as necessary. Rank of input tensors must match.
+  }];
+
+  let arguments = (ins
+    Tosa_Int32TensorUpto4D:$input1,
+    Tosa_Int32TensorUpto4D:$input2
+  );
+
+  let results = (outs
+    Tosa_Int32TensorUpto4D:$output
+  );
+}
+
+//===----------------------------------------------------------------------===//
 // Operator: logical_and
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalAndOp : Tosa_Op<"logical_and", [ResultsBroadcastableShape,
                                                 Commutative, NoSideEffect]> {
   let summary = "Returns the truth value of x AND y element-wise.";
 
   let description = [{
     Elementwise logical AND of input1 and input2. Axis of size 1 will be

 
 //===----------------------------------------------------------------------===//
 // Operator: concat
 //===----------------------------------------------------------------------===//
 def Tosa_ConcatOp : Tosa_Op<"concat", [NoSideEffect]> {
   let summary = "Concatenates tensors along one dimension.";
 
   let description = [{
-    Concatenate two tensors along a given axis. No data conversion happens
-    during a concat operation.
+    Concatenate a variadic amount of tensors along a given axis. No data 
+    conversion happens during a concat operation.
   }];
 
   let arguments = (ins
-    Tosa_Tensor1Dto4D:$input1,
-    Tosa_Tensor1Dto4D:$input2,
+    Variadic<Tosa_Tensor1Dto4D>:$input1,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 }
 
let arguments = (ins
     Variadic<Tosa_TensorUpto6D>:$input1
   );
 
   let results = (outs
      Variadic<Tosa_TensorUpto6D>:$output
   );
 }
 
-
-//===----------------------------------------------------------------------===//
-// Operator: placeholder
-//===----------------------------------------------------------------------===//
-def Tosa_PlaceholderOp : Tosa_Op<"placeholder", [NoSideEffect]> {
-  let summary = "Placeholder op";
-
-  let description = [{
-    A node where data will be inserted into the network at runtime. Generally
-    used for inputs to the network.
-  }];
-
-  let arguments = (ins
-  );
-
-  let results = (outs
-    Tosa_Tensor1Dto4D:$output
-  );
-}
-
 //===----------------------------------------------------------------------===//
 // TOSA Spec Section 2.14
 // Operator Class: Custom Operators.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: custom
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/Tosa/IR/TosaTypesBase.td

 def Tosa_Tensor1Dto2D : TensorRankOf<[Tosa_AnyNumber], [1,2]>;
 def Tosa_Tensor1Dto4D : TensorRankOf<[Tosa_AnyNumber], [1,2,3,4]>;
 def Tosa_Tensor1Dto5D : TensorRankOf<[Tosa_AnyNumber], [1,2,3,4,5]>;
 def Tosa_Tensor1Dto6D : TensorRankOf<[Tosa_AnyNumber], [1,2,3,4,5,6]>;
 
 def Tosa_TensorUpto4D : TensorRankOf<[Tosa_AnyNumber], [0,1,2,3,4]>;
 def Tosa_TensorUpto6D : TensorRankOf<[Tosa_AnyNumber], [0,1,2,3,4,5,6]>;
 
+def Tosa_Int32TensorUpto4D : TensorRankOf<[Tosa_Int32], [0,1,2,3,4]>;
+
 //===----------------------------------------------------------------------===//
 // Generic scalar, vector, or tensor of a particular type.
 //===----------------------------------------------------------------------===//
 
 class Tosa_TypeLike<list<Type> types, string description = ""> : TypeConstraint<Or<[
      AnyTypeOf<types>.predicate,
      VectorOf<types>.predicate,
      TensorOf<types>.predicate]>,

mlir/test/Dialect/Tosa/ops.mlir

 
 // -----
 // CHECK-LABEL: arithmetic_right_shift
 func @test_arithmetic_right_shift(%arg0: tensor<13x21x1xf32>, %arg1: tensor<13x21x3xf32>) -> tensor<13x21x3xf32> {
   %0 = "tosa.arithmetic_right_shift"(%arg0, %arg1) { round = false } : (tensor<13x21x1xf32>, tensor<13x21x3xf32>) -> tensor<13x21x3xf32>
   return %0 : tensor<13x21x3xf32>
 }
 
-
 // -----
 // CHECK-LABEL: bitwise_and
 func @test_bitwise_and(%arg0: tensor<13x21x3xi32>, %arg1: tensor<13x21x1xi32>) -> tensor<13x21x3xi32> {
   %0 = "tosa.bitwise_and"(%arg0, %arg1) : (tensor<13x21x3xi32>, tensor<13x21x1xi32>) -> tensor<13x21x3xi32>
   return %0 : tensor<13x21x3xi32>
 }
 
 // -----
 // CHECK-LABEL: bitwise_or
 func @test_bitwise_or(%arg0: tensor<13x21x3xi32>, %arg1: tensor<13x1x3xi32>) -> tensor<13x21x3xi32> {
   %0 = "tosa.bitwise_or"(%arg0, %arg1) : (tensor<13x21x3xi32>, tensor<13x1x3xi32>) -> tensor<13x21x3xi32>
   return %0 : tensor<13x21x3xi32>
 }
 
 // -----
 // CHECK-LABEL: bitwise_xor
 func @test_bitwise_xor(%arg0: tensor<13x21x1xi32>, %arg1: tensor<13x21x3xi32>) -> tensor<13x21x3xi32> {
   %0 = "tosa.bitwise_xor"(%arg0, %arg1) : (tensor<13x21x1xi32>, tensor<13x21x3xi32>) -> tensor<13x21x3xi32>
   return %0 : tensor<13x21x3xi32>
 }
 
 // -----
+// CHECK-LABEL: div
+func @test_div(%arg0: tensor<13x21x1xi32>, %arg1: tensor<13x21x3xi32>) -> tensor<13x21x3xi32> {
+  %0 = "tosa.div"(%arg0, %arg1) : (tensor<13x21x1xi32>, tensor<13x21x3xi32>) -> tensor<13x21x3xi32>
+  return %0 : tensor<13x21x3xi32>
+}
+
+// -----
 // CHECK-LABEL: logical_and
 func @test_logical_and(%arg0: tensor<13x21x3xi1>, %arg1: tensor<13x21x1xi1>) -> tensor<13x21x3xi1> {
   %0 = "tosa.logical_and"(%arg0, %arg1) : (tensor<13x21x3xi1>, tensor<13x21x1xi1>) -> tensor<13x21x3xi1>
   return %0 : tensor<13x21x3xi1>
 }
 
 // -----
 // CHECK-LABEL: logical_left_shift

 // -----
 // CHECK-LABEL: identityn
 func @test_identityn(%arg0: tensor<1xi32>, %arg1: tensor<1xi32>) -> tensor<1xi32> {
   %0:2 = "tosa.identityn"(%arg0, %arg1) : (tensor<1xi32>, tensor<1xi32>) -> (tensor<1xi32>, tensor<1xi32>)
   return %0#0 : tensor<1xi32>
 }
 
 // -----
-// CHECK-LABEL: placeholder
-func @test_placeholder() -> tensor<1xi32> {
-  %0 = "tosa.placeholder"() : () -> tensor<1xi32>
-  return %0 : tensor<1xi32>
-}
-
-// -----
 // CHECK-LABEL: cond_if
 func @test_cond_if(%arg0: tensor<f32>, %arg1: tensor<f32>, %arg2: tensor<i1>) -> tensor<f32> {
   %0 = "tosa.cond_if"(%arg2, %arg0, %arg1) ( {
   ^bb0(%arg3: tensor<f32>, %arg4: tensor<f32>):  // no predecessors
     %1 = "tosa.add"(%arg3, %arg4) : (tensor<f32>, tensor<f32>) -> tensor<f32>
     "tosa.yield"(%1) : (tensor<f32>) -> ()
   },  {
   ^bb0(%arg3: tensor<f32>, %arg4: tensor<f32>):  // no predecessors