Merge branch 'develop' into tests

test/gpu/quantization.cpp

+#include <iostream>
+#include <vector>
+#include <migraphx/operators.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/quantization.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/cpu/target.hpp>
+#include <migraphx/gpu/target.hpp>
+#include <migraphx/verify.hpp>
+#include <migraphx/quantization.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/propagate_constant.hpp>
+#include <migraphx/pass_manager.hpp>
+#include <migraphx/onnx.hpp>
+#include "test.hpp"
+#include <migraphx/half.hpp>
+
+TEST_CASE(target_copy)
+{
+    auto run_prog = [](migraphx::program p,
+                       const migraphx::target& t,
+                       migraphx::program::parameter_map& m_in,
+                       std::vector<float>& res) {
+        p.compile(t);
+        migraphx::program::parameter_map m;
+        for(auto&& x : p.get_parameter_shapes())
+        {
+            if(m_in.count(x.first) > 0)
+            {
+                m[x.first] = t.copy_to(m_in[x.first]);
+            }
+            else
+            {
+                m[x.first] = t.allocate(x.second);
+            }
+        }
+
+        auto result = t.copy_from(p.eval(m));
+        result.visit([&](auto v) { res.assign(v.begin(), v.end()); });
+    };
+
+    auto create_program = [] {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
+        auto p1 = p.add_parameter("x", s);
+        auto p2 = p.add_parameter("y", s);
+        p.add_instruction(migraphx::op::add{}, p1, p2);
+
+        return p;
+    };
+
+    {
+        auto p = create_program();
+        migraphx::program::parameter_map m;
+        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
+        m["x"] = migraphx::generate_argument(s);
+        std::vector<float> cpu_result;
+        migraphx::target cpu_t = migraphx::cpu::target{};
+        run_prog(p, cpu_t, m, cpu_result);
+
+        std::vector<float> gpu_result;
+        migraphx::target gpu_t = migraphx::gpu::target{};
+        run_prog(p, gpu_t, m, gpu_result);
+
+        EXPECT(migraphx::verify_range(cpu_result, gpu_result));
+    }
+}
+
+TEST_CASE(int8_quantization)
+{
+    auto run_prog = [](migraphx::program p,
+                       const migraphx::target& t,
+                       migraphx::program::parameter_map& m_in,
+                       std::vector<float>& res) {
+        std::vector<migraphx::program::parameter_map> cali_data;
+        cali_data.push_back(m_in);
+        migraphx::quantize_int8(p, t, cali_data);
+        p.compile(t);
+        migraphx::program::parameter_map m;
+        for(auto&& x : p.get_parameter_shapes())
+        {
+            if(m_in.count(x.first) > 0)
+            {
+                m[x.first] = t.copy_to(m_in[x.first]);
+            }
+            else
+            {
+                m[x.first] = t.allocate(x.second);
+            }
+        }
+
+        auto result = t.copy_from(p.eval(m));
+        result.visit([&](auto v) { res.assign(v.begin(), v.end()); });
+    };
+
+    auto create_program = [] {
+        migraphx::program p;
+        migraphx::shape sa{migraphx::shape::float_type, {2, 16}};
+        migraphx::shape sb{migraphx::shape::float_type, {16, 8}};
+        migraphx::shape sc{migraphx::shape::float_type, {2, 8}};
+        auto pa = p.add_parameter("a", sa);
+        auto pb = p.add_parameter("b", sb);
+        auto pc = p.add_parameter("c", sc);
+        p.add_instruction(migraphx::op::dot{}, pa, pb, pc);
+
+        return p;
+    };
+
+    {
+        auto p = create_program();
+        migraphx::program::parameter_map m;
+        migraphx::shape sa{migraphx::shape::float_type, {2, 16}};
+        migraphx::shape sc{migraphx::shape::float_type, {2, 8}};
+        m["a"] = migraphx::generate_argument(sa);
+        m["c"] = migraphx::generate_argument(sc);
+        std::vector<float> cpu_result;
+        migraphx::target cpu_t = migraphx::cpu::target{};
+        run_prog(p, cpu_t, m, cpu_result);
+
+        std::vector<float> gpu_result;
+        migraphx::target gpu_t = migraphx::gpu::target{};
+        run_prog(p, gpu_t, m, gpu_result);
+
+        EXPECT(migraphx::verify_range(cpu_result, gpu_result));
+    }
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/matcher.cpp

@@ -5,6 +5,8 @@
 
 namespace match = migraphx::match;
 
+MIGRAPHX_PRED_MATCHER(throws, migraphx::instruction_ref) { MIGRAPHX_THROW("Matcher throws"); }
+
 template <class M>
 migraphx::match::matcher_result find_match(migraphx::program& p, M&& m)
 {
@@ -148,6 +150,56 @@ TEST_CASE(match_arg7)
     EXPECT(bool{r.result == sum});
 }
 
+TEST_CASE(match_arg8)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::all_of(match::arg(0)(match::name("@literal")),
+                                              match::arg(1)(match::name("@literal"))),
+                                match::standard_shape());
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+}
+
+TEST_CASE(match_nargs1)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::nargs(2));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+}
+
+TEST_CASE(match_nargs2)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::nargs(2), match::standard_shape());
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+}
+
+TEST_CASE(match_nargs3)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::all_of(match::nargs(2)));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+}
+
 TEST_CASE(match_args1)
 {
     migraphx::program p;
@@ -281,6 +333,81 @@ TEST_CASE(match_either_args3)
     EXPECT(bool{r.result == p.end()});
 }
 
+TEST_CASE(match_either_args_any1)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto sum1 = p.add_instruction(sum_op{}, one, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, two);
+    p.add_instruction(pass_op{}, sum2);
+    auto m =
+        match::name("sum")(match::either_arg(0, 1)(match::any().bind("x"), match::any().bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum1});
+    EXPECT(bool{r.instructions.at("x") != r.instructions.at("y")});
+}
+
+TEST_CASE(match_either_args_any2)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto sum1 = p.add_instruction(sum_op{}, one, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, two);
+    p.add_instruction(pass_op{}, sum2);
+    auto m = match::name("sum")(
+        match::either_arg(0, 1)(match::any().bind("x"), match::name("@literal").bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum1});
+    EXPECT(bool{r.instructions.at("x") != r.instructions.at("y")});
+}
+
+TEST_CASE(match_either_args_any3)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto sum1 = p.add_instruction(sum_op{}, one, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, two);
+    p.add_instruction(pass_op{}, sum2);
+    auto m = match::name("sum")(
+        match::either_arg(0, 1)(match::name("@literal").bind("x"), match::any().bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum1});
+    EXPECT(bool{r.instructions.at("x") != r.instructions.at("y")});
+}
+
+TEST_CASE(match_either_args_any4)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto sum1 = p.add_instruction(sum_op{}, one, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, two);
+    p.add_instruction(pass_op{}, sum2);
+    auto m = match::name("sum")(
+        match::either_arg(0, 1)(match::name("sum").bind("x"), match::any().bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum2});
+    EXPECT(bool{r.instructions.at("x") != r.instructions.at("y")});
+}
+
+TEST_CASE(match_either_args_any5)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto sum1 = p.add_instruction(sum_op{}, one, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, two);
+    p.add_instruction(pass_op{}, sum2);
+    auto m = match::name("sum")(
+        match::either_arg(0, 1)(match::any().bind("x"), match::name("sum").bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum2});
+    EXPECT(bool{r.instructions.at("x") != r.instructions.at("y")});
+}
+
 TEST_CASE(match_all_of1)
 {
     migraphx::program p;
@@ -307,6 +434,49 @@ TEST_CASE(match_all_of2)
     EXPECT(bool{r.result == p.end()});
 }
 
+TEST_CASE(match_all_of3)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::all_of(match::all_of(
+        match::arg(0)(match::name("@literal")), match::arg(1)(match::name("@literal")))));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+}
+
+TEST_CASE(match_lazy_any_of)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    p.add_instruction(pass_op{}, one);
+    auto m = match::any_of(match::any(), throws());
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == one});
+}
+
+TEST_CASE(match_lazy_all_of)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    p.add_instruction(pass_op{}, one);
+    auto m = match::all_of(match::none(), throws());
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == p.end()});
+}
+
+TEST_CASE(match_lazy_none_of)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    p.add_instruction(pass_op{}, one);
+    auto m = match::none_of(match::any(), throws());
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == p.end()});
+}
+
 TEST_CASE(match_any_of1)
 {
     migraphx::program p;
@@ -333,6 +503,97 @@ TEST_CASE(match_any_of2)
     EXPECT(bool{r.result == p.end()});
 }
 
+TEST_CASE(match_any_of_lazy1)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(
+        match::any_of(match::args(match::any(), match::any()).bind("x"),
+                      match::args(match::name("sum"), match::name("sum")).bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+    EXPECT(migraphx::contains(r.instructions, "x"));
+    EXPECT(bool{r.instructions["x"] == sum});
+    EXPECT(not migraphx::contains(r.instructions, "y"));
+}
+
+TEST_CASE(match_any_of_lazy2)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(
+        match::any_of(match::args(match::name("@literal"), match::name("@literal")).bind("x"),
+                      match::args(match::any(), match::any()).bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+    EXPECT(migraphx::contains(r.instructions, "x"));
+    EXPECT(bool{r.instructions["x"] == sum});
+    EXPECT(not migraphx::contains(r.instructions, "y"));
+}
+
+TEST_CASE(match_any_of_lazy3)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(
+        match::any_of(match::args(match::any(), match::any()).bind("x"),
+                      match::args(match::name("@literal"), match::name("@literal")).bind("y")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+    EXPECT(migraphx::contains(r.instructions, "x"));
+    EXPECT(bool{r.instructions["x"] == sum});
+    EXPECT(not migraphx::contains(r.instructions, "y"));
+}
+
+TEST_CASE(match_any_of_lazy4)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::any_of(
+        match::args(match::name("@literal").bind("x1"), match::name("@literal").bind("y1")),
+        match::args(match::any().bind("x2"), match::any().bind("y2"))));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+    EXPECT(migraphx::contains(r.instructions, "x1"));
+    EXPECT(migraphx::contains(r.instructions, "y1"));
+    EXPECT(bool{r.instructions["x1"] == one});
+    EXPECT(bool{r.instructions["y1"] == two});
+    EXPECT(not migraphx::contains(r.instructions, "x2"));
+    EXPECT(not migraphx::contains(r.instructions, "y2"));
+}
+
+TEST_CASE(match_any_of_lazy5)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("sum")(match::any_of(
+        match::args(match::any().bind("x1"), match::any().bind("y1")),
+        match::args(match::name("@literal").bind("x2"), match::name("@literal").bind("y2"))));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == sum});
+    EXPECT(migraphx::contains(r.instructions, "x1"));
+    EXPECT(migraphx::contains(r.instructions, "y1"));
+    EXPECT(bool{r.instructions["x1"] == one});
+    EXPECT(bool{r.instructions["y1"] == two});
+    EXPECT(not migraphx::contains(r.instructions, "x2"));
+    EXPECT(not migraphx::contains(r.instructions, "y2"));
+}
+
 TEST_CASE(match_none_of1)
 {
     migraphx::program p;
@@ -359,6 +620,132 @@ TEST_CASE(match_none_of2)
     EXPECT(bool{r.result == p.end()});
 }
 
+TEST_CASE(match_output1)
+{
+    migraphx::program p;
+    auto one   = p.add_literal(1);
+    auto two   = p.add_literal(2);
+    auto minus = p.add_instruction(minus_op{}, two, one);
+    auto sum   = p.add_instruction(sum_op{}, minus, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("minus")(match::output(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus});
+}
+
+TEST_CASE(match_output2)
+{
+    migraphx::program p;
+    auto one   = p.add_literal(1);
+    auto two   = p.add_literal(2);
+    auto minus = p.add_instruction(minus_op{}, two, one);
+    auto sum   = p.add_instruction(sum_op{}, minus, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("@literal")(match::output(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == p.end()});
+}
+
+TEST_CASE(match_skip_output1)
+{
+    migraphx::program p;
+    auto one   = p.add_literal(1);
+    auto two   = p.add_literal(2);
+    auto minus = p.add_instruction(minus_op{}, two, one);
+    auto sum   = p.add_instruction(sum_op{}, minus, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("minus")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus});
+}
+
+TEST_CASE(match_skip_output2)
+{
+    migraphx::program p;
+    auto one        = p.add_literal(1);
+    auto two        = p.add_literal(2);
+    auto minus      = p.add_instruction(minus_op{}, two, one);
+    auto minus_pass = p.add_instruction(pass_op{}, minus);
+    auto sum        = p.add_instruction(sum_op{}, minus_pass, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("minus")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus});
+}
+
+TEST_CASE(match_skip_output3)
+{
+    migraphx::program p;
+    auto one         = p.add_literal(1);
+    auto two         = p.add_literal(2);
+    auto minus       = p.add_instruction(minus_op{}, two, one);
+    auto minus_pass1 = p.add_instruction(pass_op{}, minus);
+    auto minus_pass2 = p.add_instruction(pass_op{}, minus_pass1);
+    auto minus_pass3 = p.add_instruction(pass_op{}, minus_pass2);
+    auto sum         = p.add_instruction(sum_op{}, minus_pass3, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("minus")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus});
+}
+
+TEST_CASE(match_skip_output4)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto pass = p.add_instruction(pass_op{}, one);
+    auto sum  = p.add_instruction(sum_op{}, pass, two);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("@literal")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == two});
+}
+
+TEST_CASE(match_skip_output5)
+{
+    migraphx::program p;
+    auto one  = p.add_literal(1);
+    auto two  = p.add_literal(2);
+    auto pass = p.add_instruction(pass_op{}, one);
+    auto sum1 = p.add_instruction(sum_op{}, pass, two);
+    auto sum2 = p.add_instruction(sum_op{}, sum1, one);
+    auto sum3 = p.add_instruction(sum_op{}, sum2, two);
+    p.add_instruction(pass_op{}, sum3);
+    auto m = match::name("@literal")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == p.end()});
+}
+
+TEST_CASE(match_skip_output6)
+{
+    migraphx::program p;
+    auto one   = p.add_literal(1);
+    auto two   = p.add_literal(2);
+    auto minus = p.add_instruction(minus_op{}, two, one);
+    auto sum1  = p.add_instruction(sum_op{}, minus, two);
+    auto sum2  = p.add_instruction(sum_op{}, sum1, one);
+    auto sum3  = p.add_instruction(sum_op{}, sum2, two);
+    p.add_instruction(pass_op{}, sum3);
+    auto m = match::name("minus")(match::skip_output(match::name("pass"))(match::name("sum")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus});
+}
+
+TEST_CASE(match_skip_output7)
+{
+    migraphx::program p;
+    auto one    = p.add_literal(1);
+    auto two    = p.add_literal(2);
+    auto minus1 = p.add_instruction(minus_op{}, two, one);
+    auto minus2 = p.add_instruction(minus_op{}, two, minus1);
+    auto sum    = p.add_instruction(sum_op{}, one, minus2);
+    p.add_instruction(pass_op{}, sum);
+    auto m = match::name("minus")(match::skip_output(match::name("pass"))(match::name("minus")));
+    auto r = find_match(p, m);
+    EXPECT(bool{r.result == minus1});
+}
+
 TEST_CASE(match_bind1)
 {
     migraphx::program p;

test/onnx/cast_test.onnx

+cast-example:F
+
+
x
y"Cast*	
+to

	test_castZ
+
x
+
+
+
+
+b
+
y
+
+

+
+B

test/onnx/const_of_shape_int64_test.onnx

+constant-of-shape:

+6shape"Constant*#
+value**Bshape_tensor 

+7
+shape
y"ConstantOfShape*
+value*
:

+Bvalue 
constant_of_shapeb
+
y
+

+
+
+B

test/onnx/const_of_shape_no_value_attr_test.onnx

+constant-of-shape:

+6shape"Constant*#
+value**Bshape_tensor 

+
+shape
y"ConstantOfShapeconstant_of_shapeb
+
y
+

+
+
+B

test/onnx/constant_scalar.onnx → test/onnx/constant_scalar_test.onnx

-constant-scalar-example:R
+constant-scalar-example:R
 0
0"Constant*!
 value*
*

Bconst_tensor 

test-constantb
 
0
 
 

-
B
\ No newline at end of file
+
B

test/onnx/conv_bias_test.onnx

+conv-example:­

+8
+
0
+
1
+
2
3"Conv*
+	dilations@
@
 
*
+strides@
@
 
	test_convZ
+
0
+

+

+
+ 
+ Z
+
1
+

+

+
+
+Z
+
2
+
+

+
b
+
3
+

+

+
+
+B