merge changes from develop branch

test/verify/test_avg_pooling_3d_opt.cpp

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

test/verify/test_avg_pooling_ceil_3d.cpp

@@ -10,9 +10,11 @@ struct test_avg_pooling_ceil_3d : verify_program<test_avg_pooling_ceil_3d>
     {
         migraphx::program p;
         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{"average", {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
+        auto op = migraphx::op::pooling{
+            migraphx::op::pooling_mode::average, {1, 1, 1}, {3, 3, 3}, {3, 3, 3}, true};
         mm->add_instruction(op, input);
         return p;
     }

test/verify/test_concat_pooling.cpp

@@ -3,6 +3,7 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/op/pooling.hpp>
 
 struct test_concat_pooling : verify_program<test_concat_pooling>
 {
@@ -18,12 +19,13 @@ struct test_concat_pooling : verify_program<test_concat_pooling>
         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"},
-                                                              {"padding", {0, 0}},
-                                                              {"stride", {1, 1}},
-                                                              {"lengths", {8, 8}}}),
-                                           concat_t);
+        auto pooling =
+            mm->add_instruction(migraphx::make_op("pooling",
+                                                  {{"mode", migraphx::op::pooling_mode::average},
+                                                   {"padding", {0, 0}},
+                                                   {"stride", {1, 1}},
+                                                   {"lengths", {8, 8}}}),
+                                concat_t);
         mm->add_instruction(migraphx::make_op("relu"), pooling);
         return p;
     }

test/verify/test_conv_bn_relu_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_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
 {
@@ -29,7 +30,7 @@ struct test_conv_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
             migraphx::make_op("batch_norm_inference"), conv, scale, bias, mean, variance);
         auto relu = mm->add_instruction(migraphx::make_op("relu"), bn);
         mm->add_instruction(migraphx::make_op("pooling",
-                                              {{"mode", "average"},
+                                              {{"mode", migraphx::op::pooling_mode::average},
                                                {"padding", {1, 1}},
                                                {"stride", {2, 2}},
                                                {"lengths", {3, 3}}}),

test/verify/test_conv_bn_relu_pooling2.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_bn_relu_pooling2 : verify_program<test_conv_bn_relu_pooling2>
 {
@@ -47,7 +48,7 @@ struct test_conv_bn_relu_pooling2 : verify_program<test_conv_bn_relu_pooling2>
         auto add  = mm->add_instruction(migraphx::make_op("add"), bn1, bn2);
         auto relu = mm->add_instruction(migraphx::make_op("relu"), add);
         mm->add_instruction(migraphx::make_op("pooling",
-                                              {{"mode", "average"},
+                                              {{"mode", migraphx::op::pooling_mode::average},
                                                {"padding", {1, 1}},
                                                {"stride", {2, 2}},
                                                {"lengths", {3, 3}}}),

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_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_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_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},

tools/api/api.cpp

@@ -4,6 +4,7 @@
 #include <migraphx/program.hpp>
 #include <migraphx/onnx.hpp>
 #include <migraphx/tf.hpp>
+#include <migraphx/instruction_ref.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/quantization.hpp>
@@ -72,6 +73,23 @@ migraphx_shape_datatype_t to_shape_type(shape::type_t t)
     MIGRAPHX_THROW(migraphx_status_bad_param, "Unknown type");
 }
 
+template <class T>
+auto to_obj_vector(const T* x, std::size_t n)
+{
+    std::vector<decltype((*x)->object)> result;
+    std::transform(x, x + n, std::back_inserter(result), [&](auto&& y) { return y->object; });
+    return result;
+}
+
+template <class T, class U>
+auto to_objptr_vector(const U* x, std::size_t n)
+{
+    std::vector<T> result;
+    std::transform(
+        x, x + n, std::back_inserter(result), [&](auto&& y) { return std::addressof(y->object); });
+    return result;
+}
+
 target get_target(const std::string& name) { return make_target(name); }
 
 void set_offload_copy(compile_options& options, bool value) { options.offload_copy = value; }
@@ -194,6 +212,8 @@ void print_program(const program& p) { std::cout << p << std::endl; }
 
 void print_module(const module& m) { std::cout << m << std::endl; }
 
+migraphx::context get_context(const program& p) { return p.get_context(); }
+
 } // namespace migraphx
 
 <% generate_c_api_body() %>