Merge

test/verify/gemm_2args_mm_4.cpp

@@ -13,8 +13,8 @@ struct gemm_2args_mm_4 : verify_program<gemm_2args_mm_4>
         migraphx::shape m1_shape{migraphx::shape::float_type, {2, 3}};
         migraphx::shape m2_shape{migraphx::shape::float_type, {3, 3, 4}};
         auto l1 = mm->add_parameter("1", m1_shape);
-        auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {3, 2, 3}}}), l1);
+        auto bl1 =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 2, 3}}}), l1);
         auto l2 = mm->add_parameter("2", m2_shape);
 
         mm->add_instruction(migraphx::make_op("dot"), bl1, l2);

test/verify/gemm_2args_mm_5.cpp

@@ -14,7 +14,7 @@ struct gemm_2args_mm_5 : verify_program<gemm_2args_mm_5>
         migraphx::shape m2_shape{migraphx::shape::float_type, {2, 3, 3, 4}};
         auto l1  = mm->add_parameter("1", m1_shape);
         auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 2, 3}}}), l1);
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 2, 3}}}), l1);
         auto l2 = mm->add_parameter("2", m2_shape);
 
         mm->add_instruction(migraphx::make_op("dot"), bl1, l2);

test/verify/gemm_2args_mm_6.cpp

@@ -14,10 +14,10 @@ struct gemm_2args_mm_6 : verify_program<gemm_2args_mm_6>
         migraphx::shape m2_shape{migraphx::shape::float_type, {1, 3, 3, 4}};
         auto l1  = mm->add_parameter("1", m1_shape);
         auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 2, 3}}}), l1);
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 2, 3}}}), l1);
         auto l2  = mm->add_parameter("2", m2_shape);
         auto bl2 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 3, 4}}}), l2);
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 3, 4}}}), l2);
 
         mm->add_instruction(migraphx::make_op("dot"), bl1, bl2);
 

test/verify/gemm_2args_mm_7.cpp

@@ -14,7 +14,7 @@ struct gemm_2args_mm_7 : verify_program<gemm_2args_mm_7>
         migraphx::shape m2_shape{migraphx::shape::float_type, {2, 3, 3, 4}};
         auto l1  = mm->add_parameter("1", m1_shape);
         auto bl1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 3, 2, 3}}}), l1);
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 2, 3}}}), l1);
         auto l2 = mm->add_parameter("2", m2_shape);
 
         mm->add_instruction(migraphx::make_op("dot"), bl1, l2);

test/verify/gemm_2args_vbm.cpp

@@ -15,7 +15,7 @@ struct gemm_2args_vbm : verify_program<gemm_2args_vbm>
         auto l1   = mm->add_parameter("1", m1_shape);
         auto ul1  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), l1);
         auto bul1 = mm->add_instruction(
-            migraphx::make_op("multibroadcast", {{"output_lens", {2, 2, 1, 5}}}), ul1);
+            migraphx::make_op("multibroadcast", {{"out_lens", {2, 2, 1, 5}}}), ul1);
 
         auto l2 = mm->add_parameter("2", m2_shape);
 

test/verify/gemm_2args_vv.cpp

 
+#include <migraphx/apply_alpha_beta.hpp>
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
@@ -17,8 +18,7 @@ struct gemm_2args_vv : verify_program<gemm_2args_vv>
         auto l2     = mm->add_parameter("2", m2_shape);
         auto ul2    = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1}}}), l2);
         float alpha = 0.23f;
-
-        auto res  = mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}}), ul1, ul2);
+        auto res = migraphx::add_apply_alpha_beta(*mm, {ul1, ul2}, migraphx::make_op("dot"), alpha);
         auto sres = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), res);
         mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {0}}}), sres);
 

test/verify/gemm_add.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
+struct gemm_add : verify_program<gemm_add>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape m1_shape{migraphx::shape::float_type, {1, 2, 3}};
+        migraphx::shape m2_shape{migraphx::shape::float_type, {1, 3, 4}};
+        migraphx::shape m3_shape{migraphx::shape::float_type, {1, 2, 4}};
+        auto l1 = mm->add_parameter("1", m1_shape);
+        auto l2 = mm->add_parameter("2", m2_shape);
+        auto l3 = mm->add_parameter("3", m3_shape);
+
+        auto dot = mm->add_instruction(migraphx::make_op("dot"), l1, l2);
+        mm->add_instruction(migraphx::make_op("add"), dot, l3);
+        return p;
+    }
+};

test/verify/gemm_multi_3args.cpp

 
+#include <migraphx/apply_alpha_beta.hpp>
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
@@ -19,9 +20,7 @@ struct gemm_multi_3args : verify_program<gemm_multi_3args>
         auto l3     = mm->add_parameter("3", m3_shape);
         float alpha = 0.35;
         float beta  = 0.41;
-        mm->add_instruction(
-            migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2, l3);
-
+        migraphx::add_apply_alpha_beta(*mm, {l1, l2, l3}, migraphx::make_op("dot"), alpha, beta);
         return p;
     }
 };

test/verify/gemm_multi_3args_alpha0.cpp

@@ -3,7 +3,7 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
-
+#include <migraphx/apply_alpha_beta.hpp>
 struct gemm_multi_3args_alpha0 : verify_program<gemm_multi_3args_alpha0>
 {
     migraphx::program create_program() const
@@ -19,9 +19,7 @@ struct gemm_multi_3args_alpha0 : verify_program<gemm_multi_3args_alpha0>
 
         float alpha = 0.0f;
         float beta  = 1.0f;
-        mm->add_instruction(
-            migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2, l3);
-
+        migraphx::add_apply_alpha_beta(*mm, {l1, l2, l3}, migraphx::make_op("dot"), alpha, beta);
         return p;
     }
 };

test/verify/gemm_multi_3args_beta0.cpp

 
+#include <migraphx/apply_alpha_beta.hpp>
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
@@ -19,9 +20,7 @@ struct gemm_multi_3args_beta0 : verify_program<gemm_multi_3args_beta0>
 
         float alpha = 1.0f;
         float beta  = 0.0f;
-        mm->add_instruction(
-            migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2, l3);
-
+        migraphx::add_apply_alpha_beta(*mm, {l1, l2, l3}, migraphx::make_op("dot"), alpha, beta);
         return p;
     }
 };

test/verify/gemm_multi_3args_c25.cpp

 
+#include <migraphx/apply_alpha_beta.hpp>
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
@@ -19,9 +20,7 @@ struct gemm_multi_3args_c25 : verify_program<gemm_multi_3args_c25>
         auto l3     = mm->add_parameter("3", m3_shape);
         float alpha = 0.35;
         float beta  = 0.41;
-        mm->add_instruction(
-            migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, l2, l3);
-
+        migraphx::add_apply_alpha_beta(*mm, {l1, l2, l3}, migraphx::make_op("dot"), alpha, beta);
         return p;
     }
 };

test/verify/gemm_multi_transpose.cpp

 
+#include <migraphx/apply_alpha_beta.hpp>
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
@@ -14,12 +15,12 @@ struct gemm_multi_transpose : verify_program<gemm_multi_transpose>
         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 tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0, 2}}}), l2);
 
         float alpha = 1.0f;
         float beta  = 1.0f;
-        mm->add_instruction(migraphx::make_op("dot", {{"alpha", alpha}, {"beta", beta}}), l1, tl2);
-
+        migraphx::add_apply_alpha_beta(*mm, {l1, tl2}, migraphx::make_op("dot"), alpha, beta);
         return p;
     }
 };

test/verify/main.cpp

@@ -45,14 +45,6 @@ int main(int argc, const char* argv[])
     run_verify rv;
     rv.add_validation_for("gpu", &validate_gpu);
     rv.disable_test_for("cpu", {"test_if_lp", "test_if_param", "test_if_literal"});
-    rv.disable_test_for("gpu",
-                        {"batch_quant_dot_2",
-                         "batch_quant_dot_3",
-                         "batch_quant_dot_5",
-                         "quant_dot_3args_1",
-                         "quant_dot_3args_2",
-                         "quant_dot_3args_3",
-                         "quant_dot_3args_4",
-                         "quant_dot_3args_5"});
+    rv.disable_test_for("gpu", {"test_conv_bn_add"});
     rv.run(argc, argv);
 }

test/verify/quant_conv_int8x4_default.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/op/quant_convolution.hpp>
+
+struct quant_conv_int8x4_default : verify_program<quant_conv_int8x4_default>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape a_shape{migraphx::shape::int8_type, {16, 16, 4, 4}};
+        auto pa = mm->add_parameter("a", a_shape);
+        migraphx::shape c_shape{migraphx::shape::int8_type, {16, 16, 3, 3}};
+        auto pc = mm->add_parameter("c", c_shape);
+        mm->add_instruction(
+            migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}, migraphx::op::same},
+            pa,
+            pc);
+        return p;
+    }
+};

test/verify/quant_dot_3args_1.cpp

 
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
@@ -17,7 +18,7 @@ struct quant_dot_3args_1 : verify_program<quant_dot_3args_1>
         auto l1 = mm->add_parameter("a", m1_shape);
         auto l2 = mm->add_parameter("b", m2_shape);
         auto l3 = mm->add_parameter("c", m3_shape);
-        mm->add_instruction(migraphx::make_op("quant_dot"), l1, l2, l3);
+        migraphx::add_apply_alpha_beta(*mm, {l1, l2, l3}, migraphx::make_op("quant_dot"), 1, 1);
         return p;
     }
 };

test/verify/quant_dot_3args_2.cpp

 
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
@@ -15,11 +16,11 @@ struct quant_dot_3args_2 : verify_program<quant_dot_3args_2>
         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 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);
+        migraphx::add_apply_alpha_beta(*mm, {tl1, l2, l3}, migraphx::make_op("quant_dot"), 1, 3);
         return p;
     }
 };

test/verify/quant_dot_3args_3.cpp

 
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
@@ -16,10 +17,10 @@ struct quant_dot_3args_3 : verify_program<quant_dot_3args_3>
 
         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 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);
+        migraphx::add_apply_alpha_beta(*mm, {l1, tl2, l3}, migraphx::make_op("quant_dot"), 2, 3);
         return p;
     }
 };

test/verify/quant_dot_3args_4.cpp

 
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
@@ -15,12 +16,13 @@ struct quant_dot_3args_4 : verify_program<quant_dot_3args_4>
         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 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", {{"dims", {1, 0}}}), l2);
+        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);
+        migraphx::add_apply_alpha_beta(*mm, {tl1, tl2, l3}, migraphx::make_op("quant_dot"), 3, 2);
         return p;
     }
 };

test/verify/quant_dot_3args_5.cpp

 
 #include "verify_program.hpp"
 #include <migraphx/program.hpp>
+#include <migraphx/apply_alpha_beta.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
@@ -14,10 +15,12 @@ struct quant_dot_3args_5 : verify_program<quant_dot_3args_5>
         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 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", {{"dims", {1, 0}}}), l2);
-        mm->add_instruction(migraphx::make_op("quant_dot", {{"alpha", 3}, {"beta", 2}}), tl1, tl2);
+        auto tl2 =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), l2);
+        migraphx::add_apply_alpha_beta(*mm, {tl1, tl2}, migraphx::make_op("quant_dot"), 3);
         return p;
     }
 };

test/verify/run_verify.cpp

@@ -6,6 +6,7 @@
 #include <migraphx/ref/target.hpp>
 #include <migraphx/ranges.hpp>
 #include <migraphx/generate.hpp>
+#include <migraphx/load_save.hpp>
 #include <migraphx/verify_args.hpp>
 #include <set>
 
@@ -15,6 +16,7 @@
 
 MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_TRACE_TEST_COMPILE)
 MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_TRACE_TEST)
+MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_DUMP_TEST)
 
 // An improved async, that doesn't block
 template <class Function>
@@ -99,8 +101,10 @@ 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);
 
@@ -123,7 +127,8 @@ void run_verify::verify(const std::string& name, const migraphx::program& p) con
     using result_future =
         std::future<std::pair<migraphx::program, std::vector<migraphx::argument>>>;
     auto_print::set_terminate_handler(name);
-    std::vector<std::pair<std::string, result_future>> results;
+    if(migraphx::enabled(MIGRAPHX_DUMP_TEST{}))
+        migraphx::save(p, name + ".mxr");
     std::vector<std::string> target_names;
     for(const auto& tname : migraphx::get_targets())
     {
@@ -139,6 +144,7 @@ void run_verify::verify(const std::string& name, const migraphx::program& p) con
     }
     if(not target_names.empty())
     {
+        std::vector<std::pair<std::string, result_future>> results;
         migraphx::parameter_map m;
         for(auto&& x : p.get_parameter_shapes())
         {