Change attributes names to be more consistent and reflect better meaning (#916)

* rename broadcast and multibroadcast output_lens attribute to out_lens attribute, and change tests and source code to reflect the same

* change the reshape attribute from dims to out_lens

* change transpose attribute's name from dims to perm to reflect better meaning

* use permutation instead of perm for transpose

clang formaating

* use dims instead of out_lens for reshape

clang formatting

test/verify/test_gemm_transposea.cpp

@@ -12,7 +12,7 @@ struct test_gemm_transposea : verify_program<test_gemm_transposea>
         auto* mm = p.get_main_module();
         auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
         auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}});
-        auto at  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), a);
+        auto at = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), a);
         mm->add_instruction(migraphx::make_op("dot"), at, b);
         return p;
     }

test/verify/test_gemm_transposea_ex.cpp

@@ -12,7 +12,8 @@ struct test_gemm_transposea_ex : verify_program<test_gemm_transposea_ex>
         auto* mm = p.get_main_module();
         auto a = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 4}});
         auto b = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 3}});
-        auto at = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), a);
+        auto at =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), a);
         mm->add_instruction(migraphx::make_op("dot"), at, b);
         return p;
     }

test/verify/test_gemm_transposeab.cpp

@@ -12,8 +12,8 @@ struct test_gemm_transposeab : verify_program<test_gemm_transposeab>
         auto* mm = p.get_main_module();
         auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
         auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
-        auto at  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), a);
-        auto bt  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), b);
+        auto at = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), a);
+        auto bt = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), at, bt);
         return p;
     }

test/verify/test_gemm_transposeb.cpp

@@ -12,7 +12,7 @@ struct test_gemm_transposeb : verify_program<test_gemm_transposeb>
         auto* mm = p.get_main_module();
         auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}});
         auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
-        auto bt  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), b);
+        auto bt = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), a, bt);
         return p;
     }

test/verify/test_gemm_transposeb_ex.cpp

@@ -12,7 +12,8 @@ struct test_gemm_transposeb_ex : verify_program<test_gemm_transposeb_ex>
         auto* mm = p.get_main_module();
         auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 4, 5}});
         auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 3, 5}});
-        auto bt  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 1}}}), b);
+        auto bt =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 1}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), a, bt);
         return p;
     }

test/verify/test_greater_brcst.cpp

@@ -13,9 +13,9 @@ struct test_greater_brcst : verify_program<test_greater_brcst>
         migraphx::shape s0{migraphx::shape::float_type, {3, 3}};
         auto l0 = mm->add_parameter("x", s0);
         migraphx::shape s1{migraphx::shape::float_type, {3, 1}};
-        auto l1  = mm->add_parameter("y", s1);
-        auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", s0.lens()}}), l1);
+        auto l1 = mm->add_parameter("y", s1);
+        auto bl1 =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", s0.lens()}}), l1);
         auto r = mm->add_instruction(migraphx::make_op("greater"), l0, bl1);
         mm->add_return({r});
 

test/verify/test_layernorm.cpp

@@ -18,24 +18,24 @@ add_layernorm(migraphx::module& m, migraphx::instruction_ref x, std::vector<size
 
     auto mean = m.add_instruction(migraphx::op::reduce_mean({2}), x);
     auto mean_mbcast =
-        m.add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), mean);
+        m.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), mean);
     auto sub = m.add_instruction(migraphx::make_op("sub"), x, mean_mbcast);
     auto exponent_mbcast =
-        m.add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), exponent);
+        m.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), exponent);
     auto pow            = m.add_instruction(migraphx::make_op("pow"), sub, exponent_mbcast);
     auto var            = m.add_instruction(migraphx::op::reduce_mean({2}), pow);
     auto epsilon_mbcast = m.add_instruction(
-        migraphx::make_op("multibroadcast", {{"output_lens", {1, dims.at(1), 1}}}), epsilon);
+        migraphx::make_op("multibroadcast", {{"out_lens", {1, dims.at(1), 1}}}), epsilon);
     auto add_epsilon = m.add_instruction(migraphx::make_op("add"), var, epsilon_mbcast);
     auto sqrt        = m.add_instruction(migraphx::make_op("sqrt"), add_epsilon);
     auto sqrt_mbcast =
-        m.add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), sqrt);
+        m.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), sqrt);
     auto div = m.add_instruction(migraphx::make_op("div"), sub, sqrt_mbcast);
     auto scale_mbcast =
-        m.add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), scale);
+        m.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), scale);
     auto mul = m.add_instruction(migraphx::make_op("mul"), scale_mbcast, div);
     auto bias_mbcast =
-        m.add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", dims}}), bias);
+        m.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", dims}}), bias);
     return m.add_instruction(migraphx::make_op("add"), mul, bias_mbcast);
 }
 

test/verify/test_less_brcst.cpp

@@ -13,9 +13,9 @@ struct test_less_brcst : verify_program<test_less_brcst>
         migraphx::shape s0{migraphx::shape::float_type, {3, 3}};
         auto l0 = mm->add_parameter("x", s0);
         migraphx::shape s1{migraphx::shape::float_type, {3, 1}};
-        auto l1  = mm->add_parameter("y", s1);
-        auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", s0.lens()}}), l1);
+        auto l1 = mm->add_parameter("y", s1);
+        auto bl1 =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", s0.lens()}}), l1);
         auto r = mm->add_instruction(migraphx::make_op("less"), l0, bl1);
         mm->add_return({r});
 

test/verify/test_logsoftmax1.cpp

@@ -11,8 +11,9 @@ struct test_logsoftmax1 : verify_program<test_logsoftmax1>
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {5, 3, 3, 4}});
-        auto tx = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {2, 3, 0, 1}}}), x);
-        auto r  = mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", 0}}), tx);
+        auto tx =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {2, 3, 0, 1}}}), x);
+        auto r = mm->add_instruction(migraphx::make_op("logsoftmax", {{"axis", 0}}), tx);
         mm->add_return({r});
         return p;
     }

test/verify/test_mul_add.cpp

@@ -16,9 +16,9 @@ struct test_mul_add : verify_program<test_mul_add>
         auto a  = mm->add_parameter("a", bs);
         auto b  = mm->add_parameter("b", bs);
         auto ab = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", s.lens()}}), a);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", s.lens()}}), a);
         auto bb = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", s.lens()}}), b);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", s.lens()}}), b);
         auto mul = mm->add_instruction(migraphx::make_op("mul"), x, ab);
         mm->add_instruction(migraphx::make_op("add"), mul, bb);
         return p;

test/verify/test_pad_transposed.cpp

@@ -12,7 +12,8 @@ struct test_pad_transposed : verify_program<test_pad_transposed>
         auto* mm = p.get_main_module();
         migraphx::shape s{migraphx::shape::int32_type, {1, 224, 224, 3}};
         auto x = mm->add_parameter("x", s);
-        auto t = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 3, 1, 2}}}), x);
+        auto t =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 3, 1, 2}}}), x);
         mm->add_instruction(migraphx::make_op("pad", {{"pads", {0, 0, 2, 2, 0, 0, 3, 3}}}), t);
         return p;
     }

test/verify/test_rsqrt.cpp

@@ -16,9 +16,9 @@ struct test_rsqrt : verify_program<test_rsqrt>
         auto min_val = mm->add_literal(1.0f);
         auto max_val = mm->add_literal(std::numeric_limits<float>::max());
         min_val      = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", input_lens}}), min_val);
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), min_val);
         max_val = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", input_lens}}), max_val);
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), max_val);
         auto l0 = mm->add_instruction(migraphx::make_op("clip"), x, min_val, max_val);
         mm->add_instruction(migraphx::make_op("rsqrt"), l0);
         return p;

test/verify/test_step_broadcast_transpose.cpp

@@ -13,9 +13,10 @@ struct test_step_broadcast_transpose : verify_program<test_step_broadcast_transp
         migraphx::shape s1{migraphx::shape::float_type, {1, 1, 1, 6}};
         auto l0 = mm->add_parameter("x", s1);
         auto ml = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 1, 4, 6}}}), l0);
-        auto tl = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 3, 1}}}), ml);
-        auto r  = mm->add_instruction(
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 1, 4, 6}}}), l0);
+        auto tl = mm->add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), ml);
+        auto r = mm->add_instruction(
             migraphx::make_op("step", {{"axes", {0, 1, 2}}, {"steps", {2, 2, 3}}}), tl);
         mm->add_return({r});
 

test/verify/test_step_transpose.cpp

@@ -12,8 +12,9 @@ struct test_step_transpose : verify_program<test_step_transpose>
         auto* mm = p.get_main_module();
         migraphx::shape s1{migraphx::shape::float_type, {2, 1, 4, 6}};
         auto l0 = mm->add_parameter("x", s1);
-        auto tl = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 3, 1}}}), l0);
-        auto r  = mm->add_instruction(
+        auto tl = mm->add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), l0);
+        auto r = mm->add_instruction(
             migraphx::make_op("step", {{"axes", {0, 1, 2}}, {"steps", {2, 2, 3}}}), tl);
         mm->add_return({r});
 

test/verify/test_sub2.cpp

@@ -16,7 +16,7 @@ struct test_sub2 : verify_program<test_sub2>
         auto y  = mm->add_parameter("y", s);
         auto z  = mm->add_parameter("z", b);
         auto zb = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", s.lens()}}), z);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", s.lens()}}), z);
         auto diff = mm->add_instruction(migraphx::make_op("sub"), x, y);
         mm->add_instruction(migraphx::make_op("sub"), diff, zb);
         return p;

test/verify/test_trans_abs.cpp

@@ -11,7 +11,8 @@ struct test_trans_abs : verify_program<test_trans_abs>
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto tx = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), x);
+        auto tx =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), x);
         auto absx = mm->add_instruction(migraphx::make_op("abs"), tx);
         auto r    = mm->add_instruction(migraphx::make_op("add"), absx, absx);
         mm->add_instruction(migraphx::make_op("contiguous"), r);

test/verify/test_trans_ret.cpp

@@ -11,7 +11,8 @@ struct test_trans_ret : verify_program<test_trans_ret>
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto tx = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), x);
+        auto tx =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), x);
         mm->add_return({tx});
 
         return p;

test/verify/test_trans_tanh.cpp

@@ -11,7 +11,8 @@ struct test_trans_tanh : verify_program<test_trans_tanh>
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto tx = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), x);
+        auto tx =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), x);
         auto tanhx = mm->add_instruction(migraphx::make_op("tanh"), tx);
         auto r     = mm->add_instruction(migraphx::make_op("add"), tanhx, tanhx);
         mm->add_instruction(migraphx::make_op("contiguous"), r);

test/verify/test_trans_tanh1.cpp

@@ -11,7 +11,8 @@ struct test_trans_tanh1 : verify_program<test_trans_tanh1>
         migraphx::program p;
         auto* mm = p.get_main_module();
         auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
-        auto tx = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 1, 3, 2}}}), x);
+        auto tx =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), x);
         auto tanhx = mm->add_instruction(migraphx::make_op("tanh"), tx);
         auto r     = mm->add_instruction(migraphx::make_op("add"), tanhx, tanhx);
         mm->add_return({tx, r});

test/verify/test_transpose.cpp

@@ -13,7 +13,7 @@ struct test_transpose : verify_program<test_transpose>
         migraphx::shape s{migraphx::shape::float_type, {4, 3, 4, 4}};
         auto x                    = mm->add_parameter("x", s);
         std::vector<int64_t> perm = {0, 2, 3, 1};
-        auto l = mm->add_instruction(migraphx::make_op("transpose", {{"dims", perm}}), x);
+        auto l = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), x);
         mm->add_instruction(migraphx::make_op("contiguous"), l);
         return p;
     }