Merge

test/verify/test_conv_pooling.cpp

@@ -3,6 +3,7 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/op/common.hpp>
 
 struct test_conv_pooling : verify_program<test_conv_pooling>
 {
@@ -15,7 +16,8 @@ struct test_conv_pooling : verify_program<test_conv_pooling>
         auto weights =
             mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
         auto conv    = mm->add_instruction(migraphx::make_op("convolution"), input, weights);
-        auto pooling = mm->add_instruction(migraphx::make_op("pooling", {{"mode", "max"}}), conv);
+        auto pooling = mm->add_instruction(
+            migraphx::make_op("pooling", {{"mode", migraphx::op::pooling_mode::max}}), conv);
         mm->add_instruction(migraphx::make_op("relu"), pooling);
         return p;
     }

test/verify/test_gathernd_batch_dims_1.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_gathernd_batch_dims_1 : verify_program<test_gathernd_batch_dims_1>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape ds{migraphx::shape::float_type, {2, 3, 2, 3}};
+        migraphx::shape is{migraphx::shape::int64_type, {2, 3, 2}};
+        std::vector<int64_t> indices{1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+        auto a0        = mm->add_parameter("data", ds);
+        auto a1        = mm->add_literal(migraphx::literal{is, indices});
+        int batch_dims = 1;
+        mm->add_instruction(migraphx::make_op("gathernd", {{"batch_dims", batch_dims}}), a0, a1);
+        return p;
+    }
+};

test/verify/test_gathernd_batch_dims_2.cpp

+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_gathernd_batch_dims_2 : verify_program<test_gathernd_batch_dims_2>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape ds{migraphx::shape::float_type, {2, 3, 1, 3}};
+        migraphx::shape is{migraphx::shape::int64_type, {2, 3, 2}};
+        std::vector<int64_t> indices{0, 0, 0, 1, 0, 2, 0, 2, 0, 1, 0, 0};
+        auto a0        = mm->add_parameter("data", ds);
+        auto a1        = mm->add_literal(migraphx::literal{is, indices});
+        int batch_dims = 2;
+        mm->add_instruction(migraphx::make_op("gathernd", {{"batch_dims", batch_dims}}), a0, a1);
+        return p;
+    }
+};

test/verify/test_gathernd_default.cpp

+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_gathernd_default : verify_program<test_gathernd_default>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape ds{migraphx::shape::float_type, {2, 2}};
+        migraphx::shape is{migraphx::shape::int64_type, {2, 2}};
+        std::vector<int64_t> indices{0, 0, 1, 1};
+        auto a0 = mm->add_parameter("data", ds);
+        auto a1 = mm->add_literal(migraphx::literal{is, indices});
+        mm->add_instruction(migraphx::make_op("gathernd"), a0, a1);
+        return p;
+    }
+};

test/verify/test_gathernd_negative_indices.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_gathernd_negative_indices : verify_program<test_gathernd_negative_indices>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape ds{migraphx::shape::float_type, {2, 2}};
+        migraphx::shape is{migraphx::shape::int64_type, {2, 1, 1}};
+        std::vector<int64_t> indices{-1, 0};
+        auto a0        = mm->add_parameter("data", ds);
+        auto a1        = mm->add_literal(migraphx::literal{is, indices});
+        int batch_dims = 1;
+        mm->add_instruction(migraphx::make_op("gathernd", {{"batch_dims", batch_dims}}), a0, a1);
+        return p;
+    }
+};

test/verify/test_global_avg_pooling.cpp

@@ -13,7 +13,7 @@ struct test_global_avg_pooling : verify_program<test_global_avg_pooling>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
-        auto op    = migraphx::op::pooling{"average"};
+        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
         auto lens  = input->get_shape().lens();
         op.lengths = {lens[2], lens[3]};
         mm->add_instruction(op, input);

test/verify/test_global_max_pooling.cpp

@@ -13,7 +13,7 @@ struct test_global_max_pooling : verify_program<test_global_max_pooling>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
-        auto op    = migraphx::op::pooling{"max"};
+        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
         auto lens  = input->get_shape().lens();
         op.lengths = {lens[2], lens[3]};
         mm->add_instruction(op, input);

test/verify/test_isnan_broadcast.cpp

+#include <limits>
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_isnan_broadcast : verify_program<test_isnan_broadcast>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2}});
+        auto s0  = migraphx::shape{migraphx::shape::float_type, {2, 2}};
+        x        = mm->add_instruction(
+            migraphx::make_op("broadcast", {{"axis", 0}, {"out_lens", s0.lens()}}), x);
+        std::vector<float> data0{2, std::numeric_limits<float>::quiet_NaN()};
+        migraphx::shape s1{migraphx::shape::float_type, {1, 2}};
+        auto l0 = mm->add_literal(migraphx::literal{s1, data0});
+        x       = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, l0);
+        mm->add_instruction(migraphx::make_op("isnan"), x);
+        return p;
+    }
+};

test/verify/test_isnan_float.cpp

+#include <limits>
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_isnan_float : verify_program<test_isnan_float>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2}});
+        auto l0  = mm->add_literal(std::numeric_limits<float>::quiet_NaN());
+        x        = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, l0);
+        mm->add_instruction(migraphx::make_op("isnan"), x);
+        return p;
+    }
+};

test/verify/test_isnan_half.cpp

+#include <limits>
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/half.hpp>
+
+struct test_isnan_half : verify_program<test_isnan_half>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {2}});
+        auto l0  = mm->add_literal(std::numeric_limits<migraphx::half>::quiet_NaN());
+        x        = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, l0);
+        mm->add_instruction(migraphx::make_op("isnan"), x);
+        return p;
+    }
+};

test/verify/test_max_pooling_ceil_3d.cpp

@@ -12,7 +12,8 @@ struct test_max_pooling_ceil_3d : verify_program<test_max_pooling_ceil_3d>
         auto* mm = p.get_main_module();
         auto input =
             mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 5, 5, 5}});
-        auto op = migraphx::op::pooling{"max", {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
+        auto op = migraphx::op::pooling{
+            migraphx::op::pooling_mode::max, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_pooling_autopad.cpp

@@ -12,7 +12,7 @@ struct test_pooling_autopad : verify_program<test_pooling_autopad>
         auto* mm = p.get_main_module();
         migraphx::shape s0{migraphx::shape::float_type, {1, 3, 63, 63}};
         auto l0 = mm->add_parameter("x", s0);
-        migraphx::op::pooling op{"max"};
+        migraphx::op::pooling op{migraphx::op::pooling_mode::max};
         op.lengths = {2, 2};
         op.stride  = {2, 2};
         mm->add_instruction(op, l0);

test/verify/test_prefix_scan_sum_2d.cpp

@@ -9,10 +9,12 @@ struct test_prefix_scan_sum_2d_small : verify_program<test_prefix_scan_sum_2d_sm
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
+        migraphx::shape s{migraphx::shape::float_type, {1}};
         auto x = mm->add_parameter("x", s);
+        auto xb =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 3}}}), x);
         mm->add_instruction(
-            migraphx::make_op("prefix_scan_sum", {{"axis", 1}, {"exclusive", false}}), x);
+            migraphx::make_op("prefix_scan_sum", {{"axis", 1}, {"exclusive", false}}), xb);
         return p;
     }
 };

test/verify/test_prefix_scan_sum_exclusive.cpp

+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_prefix_scan_sum_exclusive : verify_program<test_prefix_scan_sum_exclusive>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {3, 3, 3}};
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(
+            migraphx::make_op("prefix_scan_sum",
+                              {{"axis", 2}, {"exclusive", true}, {"reverse", false}}),
+            x);
+        return p;
+    }
+};

test/verify/test_prefix_scan_sum_exclusive_reverse.cpp

+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_prefix_scan_sum_exclusive_reverse
+    : verify_program<test_prefix_scan_sum_exclusive_reverse>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {3, 3, 3}};
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(
+            migraphx::make_op("prefix_scan_sum",
+                              {{"axis", 0}, {"exclusive", true}, {"reverse", true}}),
+            x);
+        return p;
+    }
+};

test/verify/test_prefix_scan_sum_reverse.cpp

+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_prefix_scan_sum_reverse : verify_program<test_prefix_scan_sum_reverse>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {3, 3, 3}};
+        auto x = mm->add_parameter("x", s);
+        mm->add_instruction(
+            migraphx::make_op("prefix_scan_sum",
+                              {{"axis", 1}, {"exclusive", false}, {"reverse", true}}),
+            x);
+        return p;
+    }
+};

test/verify/test_reduce_op_large.cpp

@@ -17,7 +17,7 @@ struct test_reduce_op_large : verify_program<test_reduce_op_large<Op, Axis, T>>
         auto* mm = p.get_main_module();
         migraphx::shape s{T, {3, 1026, 4, 3}};
         auto x = mm->add_parameter("x", s);
-        mm->add_instruction(Op{{1}}, x);
+        mm->add_instruction(Op{{Axis}}, x);
         return p;
     };
 };

test/verify/test_reduce_op_small.cpp

@@ -15,13 +15,14 @@ struct test_reduce_op_small : verify_program<test_reduce_op_small<Op, Axis, T>>
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{T, {3, 4, 8, 8}};
+        migraphx::shape s{T, {3, 4, 2, 2}};
         auto x = mm->add_parameter("x", s);
-        mm->add_instruction(Op{{1}}, x);
+        mm->add_instruction(Op{{Axis}}, x);
         return p;
     };
 };
 
+template struct test_reduce_op_small<migraphx::op::reduce_sum, 1, migraphx::shape::float_type>;
 template struct test_reduce_op_small<migraphx::op::reduce_sum, 2, migraphx::shape::int32_type>;
 template struct test_reduce_op_small<migraphx::op::reduce_mean, 2, migraphx::shape::int32_type>;
 template struct test_reduce_op_small<migraphx::op::reduce_max, 2, migraphx::shape::int32_type>;

test/verify/test_roialign_nondefault.cpp

@@ -3,6 +3,7 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/op/common.hpp>
 
 struct test_roialign_nondefault : verify_program<test_roialign_nondefault>
 {
@@ -23,7 +24,7 @@ struct test_roialign_nondefault : verify_program<test_roialign_nondefault>
         auto r   = mm->add_instruction(
             migraphx::make_op("roialign",
                               {{"coordinate_transformation_mode", "output_half_pixel"},
-                               {"mode", "max"},
+                               {"mode", migraphx::op::pooling_mode::max},
                                {"spatial_scale", 1.0},
                                {"output_height", 5},
                                {"output_width", 5},

test/verify/test_roialign_nonstandard.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_roialign_nonstandard : verify_program<test_roialign_nonstandard>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x_s = migraphx::shape::from_permutation(
+            migraphx::shape::float_type, {5, 4, 10, 10}, {0, 2, 3, 1});
+
+        migraphx::shape roi_s{migraphx::shape::float_type, {5, 4}};
+
+        migraphx::shape ind_s{migraphx::shape::int64_type, {5}};
+        std::vector<int64_t> ind_vec = {0, 2, 3, 4, 1};
+
+        auto x   = mm->add_parameter("x", x_s);
+        auto roi = mm->add_parameter("roi", roi_s);
+        auto ind = mm->add_literal(migraphx::literal(ind_s, ind_vec));
+        auto r   = mm->add_instruction(migraphx::make_op("roialign",
+                                                       {{"spatial_scale", 1.0},
+                                                        {"output_height", 5},
+                                                        {"output_width", 5},
+                                                        {"sampling_ratio", 2}}),
+                                     x,
+                                     roi,
+                                     ind);
+        mm->add_return({r});
+
+        return p;
+    }
+};