Merge branch 'develop' of https://github.com/ROCmSoftwarePlatform/AMDMIGraphX into mi100_opts

test/verify/gemm_multi_transpose.cpp

@@ -12,9 +12,10 @@ struct gemm_multi_transpose : verify_program<gemm_multi_transpose>
         auto* mm = p.get_main_module();
         migraphx::shape m1_shape{migraphx::shape::float_type, {2, 2, 3}};
         migraphx::shape m2_shape{migraphx::shape::float_type, {3, 2, 4}};
-        auto l1  = mm->add_parameter("1", m1_shape);
-        auto l2  = mm->add_parameter("2", m2_shape);
-        auto tl2 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0, 2}}}), l2);
+        auto l1 = mm->add_parameter("1", m1_shape);
+        auto l2 = mm->add_parameter("2", m2_shape);
+        auto tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0, 2}}}), l2);
 
         float alpha = 1.0f;
         float beta  = 1.0f;

test/verify/quant_dot_3args_2.cpp

@@ -14,10 +14,11 @@ struct quant_dot_3args_2 : verify_program<quant_dot_3args_2>
         migraphx::shape m2_shape{migraphx::shape::int8_type, {8, 7}};
         migraphx::shape m3_shape{migraphx::shape::int32_type, {2, 7}};
 
-        auto l1  = mm->add_parameter("a", m1_shape);
-        auto tl1 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l1);
-        auto l2  = mm->add_parameter("b", m2_shape);
-        auto l3  = mm->add_parameter("c", m3_shape);
+        auto l1 = mm->add_parameter("a", m1_shape);
+        auto tl1 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l1);
+        auto l2 = mm->add_parameter("b", m2_shape);
+        auto l3 = mm->add_parameter("c", m3_shape);
         mm->add_instruction(
             migraphx::make_op("quant_dot", {{"alpha", 1}, {"beta", 3}}), tl1, l2, l3);
         return p;

test/verify/quant_dot_3args_3.cpp

@@ -14,10 +14,11 @@ struct quant_dot_3args_3 : verify_program<quant_dot_3args_3>
         migraphx::shape m2_shape{migraphx::shape::int8_type, {7, 8}};
         migraphx::shape m3_shape{migraphx::shape::int32_type, {2, 7}};
 
-        auto l1  = mm->add_parameter("a", m1_shape);
-        auto l2  = mm->add_parameter("b", m2_shape);
-        auto tl2 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l2);
-        auto l3  = mm->add_parameter("c", m3_shape);
+        auto l1 = mm->add_parameter("a", m1_shape);
+        auto l2 = mm->add_parameter("b", m2_shape);
+        auto tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l2);
+        auto l3 = mm->add_parameter("c", m3_shape);
         mm->add_instruction(
             migraphx::make_op("quant_dot", {{"alpha", 2}, {"beta", 3}}), l1, tl2, l3);
         return p;

test/verify/quant_dot_3args_4.cpp

@@ -14,11 +14,13 @@ struct quant_dot_3args_4 : verify_program<quant_dot_3args_4>
         migraphx::shape m2_shape{migraphx::shape::int8_type, {7, 8}};
         migraphx::shape m3_shape{migraphx::shape::int32_type, {2, 7}};
 
-        auto l1  = mm->add_parameter("a", m1_shape);
-        auto tl1 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l1);
-        auto l2  = mm->add_parameter("b", m2_shape);
-        auto tl2 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l2);
-        auto l3  = mm->add_parameter("c", m3_shape);
+        auto l1 = mm->add_parameter("a", m1_shape);
+        auto tl1 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l1);
+        auto l2 = mm->add_parameter("b", m2_shape);
+        auto tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l2);
+        auto l3 = mm->add_parameter("c", m3_shape);
         mm->add_instruction(
             migraphx::make_op("quant_dot", {{"alpha", 3}, {"beta", 2}}), tl1, tl2, l3);
         return p;

test/verify/quant_dot_3args_5.cpp

@@ -13,10 +13,12 @@ struct quant_dot_3args_5 : verify_program<quant_dot_3args_5>
         migraphx::shape m1_shape{migraphx::shape::int8_type, {6, 2}};
         migraphx::shape m2_shape{migraphx::shape::int8_type, {7, 6}};
 
-        auto l1  = mm->add_parameter("a", m1_shape);
-        auto tl1 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l1);
-        auto l2  = mm->add_parameter("b", m2_shape);
-        auto tl2 = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), l2);
+        auto l1 = mm->add_parameter("a", m1_shape);
+        auto tl1 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l1);
+        auto l2 = mm->add_parameter("b", m2_shape);
+        auto tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l2);
         mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 3}, {"beta", 2}}), tl1, tl2);
         return p;
     }

test/verify/run_verify.cpp

@@ -99,7 +99,9 @@ std::pair<migraphx::program, std::vector<migraphx::argument>> run_verify::run_ta
     for(auto&& x : p.get_parameter_shapes())
     {
         if(m.count(x.first) == 0)
+        {
             m[x.first] = t.allocate(x.second);
+        }
     }
     validate(t, p, m);
     p.eval(m);

test/verify/test_acosh.cpp

@@ -14,10 +14,10 @@ struct test_acosh : verify_program<test_acosh>
         auto x       = mm->add_parameter("x", s);
         auto min_val = mm->add_literal(1.1f);
         auto max_val = mm->add_literal(100.0f);
-        min_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {16}}}),
-                                      min_val);
-        max_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {16}}}),
-                                      max_val);
+        min_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), min_val);
+        max_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), max_val);
         auto cx = mm->add_instruction(migraphx::make_op("clip"), x, min_val, max_val);
         mm->add_instruction(migraphx::make_op("acosh"), cx);
         return p;

test/verify/test_add_broadcast.cpp

@@ -16,7 +16,7 @@ struct test_add_broadcast : verify_program<test_add_broadcast>
         auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 2, 3}});
         auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {2, 2}});
         auto by = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 0}, {"dims", x->get_shape().lens()}}), y);
+            migraphx::make_op("broadcast", {{"axis", 0}, {"out_lens", x->get_shape().lens()}}), y);
         mm->add_instruction(migraphx::make_op("add"), x, by);
         return p;
     }

test/verify/test_add_broadcast2.cpp

@@ -16,7 +16,7 @@ struct test_add_broadcast2 : verify_program<test_add_broadcast2>
         auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 3, 4}});
         auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {3}});
         auto by = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", x->get_shape().lens()}}), y);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", x->get_shape().lens()}}), y);
         mm->add_instruction(migraphx::make_op("add"), x, by);
         return p;
     }

test/verify/test_add_broadcast3.cpp

@@ -16,7 +16,7 @@ struct test_add_broadcast3 : verify_program<test_add_broadcast3>
         auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 4, 5}});
         auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {4}});
         auto by = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", x->get_shape().lens()}}), y);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", x->get_shape().lens()}}), y);
         mm->add_instruction(migraphx::make_op("add"), x, by);
         return p;
     }

test/verify/test_add_broadcast4.cpp

@@ -16,7 +16,7 @@ struct test_add_broadcast4 : verify_program<test_add_broadcast4>
         auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 3, 5}});
         auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {3}});
         auto by = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", x->get_shape().lens()}}), y);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", x->get_shape().lens()}}), y);
         mm->add_instruction(migraphx::make_op("add"), x, by);
         return p;
     }

test/verify/test_add_broadcast5.cpp

@@ -16,7 +16,7 @@ struct test_add_broadcast5 : verify_program<test_add_broadcast5>
         auto x  = mm->add_parameter("x", {migraphx::shape::float_type, {2, 4, 8}});
         auto y  = mm->add_parameter("y", {migraphx::shape::float_type, {4}});
         auto by = mm->add_instruction(
-            migraphx::make_op("broadcast", {{"axis", 1}, {"dims", x->get_shape().lens()}}), y);
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", x->get_shape().lens()}}), y);
         mm->add_instruction(migraphx::make_op("add"), x, by);
         return p;
     }

test/verify/test_add_broadcast6.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+#include <migraphx/instruction.hpp>
+
+struct test_add_broadcast6 : verify_program<test_add_broadcast6>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", {migraphx::shape::float_type, {1, 64, 568, 1328}});
+        auto y   = mm->add_parameter("y", {migraphx::shape::float_type, {64}});
+        auto by  = mm->add_instruction(
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", {1, 64, 568, 1328}}}), y);
+        mm->add_instruction(migraphx::make_op("add"), x, by);
+        return p;
+    }
+};

test/verify/test_add_gelu.cpp

@@ -18,14 +18,14 @@ struct test_add_gelu : verify_program<test_add_gelu>
         auto sqrt2       = mm->add_literal(static_cast<float>(M_SQRT2));
         auto add         = mm->add_instruction(migraphx::make_op("add"), x, y);
         auto half_mbcast = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", input_lens}}), half);
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), half);
         auto mul_half     = mm->add_instruction(migraphx::make_op("mul"), add, half_mbcast);
         auto sqrt2_mbcast = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", input_lens}}), sqrt2);
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), sqrt2);
         auto div        = mm->add_instruction(migraphx::make_op("div"), add, sqrt2_mbcast);
         auto erf        = mm->add_instruction(migraphx::make_op("erf"), div);
         auto one_mbcast = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", input_lens}}), one);
+            migraphx::make_op("multibroadcast", {{"out_lens", input_lens}}), one);
         auto add_one = mm->add_instruction(migraphx::make_op("add"), erf, one_mbcast);
         mm->add_instruction(migraphx::make_op("mul"), mul_half, add_one);
         return p;

test/verify/test_atanh.cpp

@@ -14,10 +14,10 @@ struct test_atanh : verify_program<test_atanh>
         auto x       = mm->add_parameter("x", s);
         auto min_val = mm->add_literal(-0.95f);
         auto max_val = mm->add_literal(0.95f);
-        min_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {16}}}),
-                                      min_val);
-        max_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {16}}}),
-                                      max_val);
+        min_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), min_val);
+        max_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {16}}}), max_val);
         auto cx = mm->add_instruction(migraphx::make_op("clip"), x, min_val, max_val);
         mm->add_instruction(migraphx::make_op("atanh"), cx);
         return p;

test/verify/test_clip.cpp

@@ -13,10 +13,10 @@ struct test_clip : verify_program<test_clip>
         auto x       = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3}});
         auto min_val = mm->add_literal(0.0f);
         auto max_val = mm->add_literal(6.0f);
-        min_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}),
-                                      min_val);
-        max_val = mm->add_instruction(migraphx::make_op("multibroadcast", {{"output_lens", {3}}}),
-                                      max_val);
+        min_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), min_val);
+        max_val =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3}}}), max_val);
         mm->add_instruction(migraphx::make_op("clip"), x, min_val, max_val);
         return p;
     }

test/verify/test_concat_pooling.cpp

@@ -12,11 +12,11 @@ struct test_concat_pooling : verify_program<test_concat_pooling>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 256, 8, 8}});
-        auto transpose =
-            mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 2, 3, 1}}}), input);
-        auto concat = mm->add_instruction(migraphx::make_op("concat", {{"axis", 3}}), transpose);
-        auto concat_t =
-            mm->add_instruction(migraphx::make_op("transpose", {{"dims", {0, 3, 1, 2}}}), concat);
+        auto transpose = mm->add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), input);
+        auto concat   = mm->add_instruction(migraphx::make_op("concat", {{"axis", 3}}), transpose);
+        auto concat_t = mm->add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 3, 1, 2}}}), concat);
 
         auto pooling = mm->add_instruction(migraphx::make_op("pooling",
                                                              {{"mode", "average"},

test/verify/test_concat_transpose.cpp

@@ -16,8 +16,9 @@ struct test_concat_transpose : verify_program<test_concat_transpose>
         migraphx::shape s2{migraphx::shape::int32_type, {2, 4}};
         auto l0  = mm->add_parameter("x", s0);
         auto lp1 = mm->add_parameter("y", s1);
-        auto l1  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), lp1);
-        auto l2  = mm->add_parameter("z", s2);
+        auto l1 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), lp1);
+        auto l2 = mm->add_parameter("z", s2);
         mm->add_instruction(migraphx::make_op("concat", {{"axis", axis}}), l0, l1, l2);
         return p;
     }

test/verify/test_concat_transpose2.cpp

@@ -17,7 +17,8 @@ struct test_concat_transpose2 : verify_program<test_concat_transpose2>
         auto l0  = mm->add_parameter("x", s0);
         auto l1  = mm->add_parameter("y", s1);
         auto lp2 = mm->add_parameter("z", s2);
-        auto l2  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), lp2);
+        auto l2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), lp2);
         mm->add_instruction(migraphx::make_op("concat", {{"axis", axis}}), l0, l1, l2);
         return p;
     }

test/verify/test_concat_transpose3.cpp

@@ -16,9 +16,11 @@ struct test_concat_transpose3 : verify_program<test_concat_transpose3>
         migraphx::shape s2{migraphx::shape::int32_type, {5, 2}};
         auto l0  = mm->add_parameter("x", s0);
         auto lp1 = mm->add_parameter("y", s1);
-        auto l1  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), lp1);
+        auto l1 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), lp1);
         auto lp2 = mm->add_parameter("z", s2);
-        auto l2  = mm->add_instruction(migraphx::make_op("transpose", {{"dims", {1, 0}}}), lp2);
+        auto l2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), lp2);
         mm->add_instruction(migraphx::make_op("concat", {{"axis", axis}}), l0, l1, l2);
         return p;
     }