merge changes from develop branch and resolve merge conflicts

test/onnx/randomuniform_generated_seed_test.onnx

+!randomuniform_generated_seed_test:

+2
+inputoutput"
RandomUniform*
+sample_size
+
!randomuniform_generated_seed_testZ
+input
+

+

+
+b
+output
+
+

+
+B
\ No newline at end of file

test/onnx/roialign_default_test.onnx

+roialign_default_test:

+!
+
x
+rois
+	batch_ind
y"RoiAlignroialign_default_testZ
+
x
+

+
+
+
+
+Z
+rois
+

+
+Z
+	batch_ind
+
+
+b
+
y
+

+
+
+

+
B
\ No newline at end of file

test/onnx/softplus_nd_test.onnx

+softplus_nd_test:V
+
+
x
y"Softplussoftplus_nd_testZ
+
x
+
+
+
+
+b
+
y
+
+
+
+
+B
\ No newline at end of file

test/onnx/softplus_test.onnx

+
softplus_test:C
+
+
x
y"Softplus
softplus_testZ
+
x
+
+

+b
+
y
+
+

+B
\ No newline at end of file

test/onnx/softsign_nd_test.onnx

+softsign_nd_test:V
+
+
x
y"Softsignsoftsign_nd_testZ
+
x
+
+
+
+
+b
+
y
+
+
+
+
+B
\ No newline at end of file

test/onnx/softsign_test.onnx

+
softsign_test:C
+
+
x
y"Softsign
softsign_testZ
+
x
+
+

+b
+
y
+
+

+B
\ No newline at end of file

test/onnx/spacetodepth_invalid_blocksize_test.onnx

+#spacetodepth_invalid_blocksize_test:

+)
+
x
y"SpaceToDepth*
+	blocksize>

#spacetodepth_invalid_blocksize_testZ
+
x
+

+

+
+
+b
+
y
+

+

+
+
+B
\ No newline at end of file

test/onnx/spacetodepth_nondivisibility_test.onnx

+!spacetodepth_nondivisibility_test:

+&
+
x
y"SpaceToDepth*
+	blocksize
!spacetodepth_nondivisibility_testZ
+
x
+

+

+
+
+b
+
y
+

+

+
+
+B
\ No newline at end of file

test/onnx/spacetodepth_simple_test.onnx

+spacetodepth_simple_test:|
+&
+
x
y"SpaceToDepth*
+	blocksize
spacetodepth_simple_testZ
+
x
+

+

+
+
+b
+
y
+

+

+
+
+B
\ No newline at end of file

test/onnx/spacetodepth_test.onnx

+spacetodepth_test:u
+&
+
x
y"SpaceToDepth*
+	blocksize
spacetodepth_testZ
+
x
+

+
+
+
+
+
+b
+
y
+

+
+
+
+B
\ No newline at end of file

test/onnx/verify_onnx.cpp

@@ -63,6 +63,46 @@ TEST_CASE(depthtospace_simple_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(spacetodepth_simple_test)
+{
+    auto p = migraphx::parse_onnx("spacetodepth_simple_test.onnx");
+    p.compile(migraphx::ref::target{});
+    std::vector<float> data_in(48);
+    std::iota(std::begin(data_in), std::end(data_in), 0);
+    migraphx::shape s_x{migraphx::shape::float_type, {1, 2, 4, 6}};
+    migraphx::parameter_map pp;
+    pp["x"]     = migraphx::argument(s_x, data_in.data());
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0,  2,  4,  12, 14, 16, 24, 26, 28, 36, 38, 40, 1,  3,  5,  13,
+                               15, 17, 25, 27, 29, 37, 39, 41, 6,  8,  10, 18, 20, 22, 30, 32,
+                               34, 42, 44, 46, 7,  9,  11, 19, 21, 23, 31, 33, 35, 43, 45, 47};
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
+TEST_CASE(spacetodepth_depthtospace_test)
+{
+    // space to depth
+    auto p1 = migraphx::parse_onnx("spacetodepth_simple_test.onnx");
+    p1.compile(migraphx::ref::target{});
+    std::vector<float> data_in(48);
+    std::iota(std::begin(data_in), std::end(data_in), 0);
+    migraphx::shape s_x_1{migraphx::shape::float_type, {1, 2, 4, 6}};
+    migraphx::parameter_map pp1;
+    pp1["x"]     = migraphx::argument(s_x_1, data_in.data());
+    auto result1 = p1.eval(pp1).back();
+    // depth to space
+    auto p2 = migraphx::parse_onnx("depthtospace_simple_test.onnx");
+    p2.compile(migraphx::ref::target{});
+    migraphx::parameter_map pp2;
+    pp2["x"]     = result1;
+    auto result2 = p2.eval(pp2).back();
+    std::vector<float> result_vector2;
+    result2.visit([&](auto output) { result_vector2.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify_range(result_vector2, data_in));
+}
+
 TEST_CASE(gather_elements)
 {
     migraphx::program p = migraphx::parse_onnx("gather_elements_axis0_test.onnx");
@@ -86,6 +126,51 @@ TEST_CASE(gather_elements)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(greaterorequal_test)
+{
+    migraphx::program p = migraphx::parse_onnx("greaterorequal_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::float_type, {3}};
+    std::vector<float> data1 = {0.25, 0.75, 0.9375};
+    std::vector<float> data2 = {0.25, 0.74, 0.9411};
+
+    migraphx::parameter_map pp;
+    pp["x1"] = migraphx::argument(s, data1.data());
+    pp["x2"] = migraphx::argument(s, data2.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold = {1.0, 1.0, 0.0};
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
+TEST_CASE(hardsigmoid_verify_test)
+{
+    migraphx::program p = migraphx::parse_onnx("hardsigmoid_verify_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::float_type, {2, 5}};
+    std::vector<float> data = {-10.0, -2.5, -1.0, -0.5, 0, 1.0, 2.0, 2.5, 2.6, 100.0};
+
+    float alpha = 0.2;
+    float beta  = 0.5;
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold(10);
+    std::transform(data.begin(), data.end(), gold.begin(), [&](auto x) {
+        return std::max(0.0f, std::min(x * alpha + beta, 1.0f));
+    });
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
 TEST_CASE(if_else_test)
 {
     migraphx::program p = migraphx::parse_onnx("if_else_test.onnx");
@@ -308,6 +393,64 @@ TEST_CASE(lessorequal_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(mean_broadcast_test)
+{
+    migraphx::program p = migraphx::parse_onnx("mean_broadcast_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s0{migraphx::shape::float_type, {1, 3, 4}};
+    std::vector<float> data0(12, 1);
+    migraphx::shape s1{migraphx::shape::float_type, {1, 2, 3, 4}};
+    std::vector<float> data1(24, 2);
+    migraphx::shape s2{migraphx::shape::float_type, {4}};
+    std::vector<float> data2(4, 3);
+    migraphx::shape s3{migraphx::shape::float_type, {1}};
+    std::vector<float> data3(1, 4);
+    migraphx::shape s4{migraphx::shape::float_type, {2, 3, 1}};
+    std::vector<float> data4(6, 5);
+
+    migraphx::parameter_map pp;
+    pp["0"] = migraphx::argument(s0, data0.data());
+    pp["1"] = migraphx::argument(s1, data1.data());
+    pp["2"] = migraphx::argument(s2, data2.data());
+    pp["3"] = migraphx::argument(s3, data3.data());
+    pp["4"] = migraphx::argument(s4, data4.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold(24, 3);
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
+TEST_CASE(mean_test)
+{
+    migraphx::program p = migraphx::parse_onnx("mean_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::double_type, {2, 2, 2}};
+    const int num_elms = 8;
+    const int num_data = 10;
+    const std::vector<double> scalars{1.0, 2.0, -2.5, 3.3, 10.7, -1.0, 100.0, 7.9, 0.01, -56.8};
+    std::vector<std::vector<double>> data;
+    std::transform(scalars.begin(), scalars.end(), std::back_inserter(data), [&](const auto& i) {
+        return std::vector<double>(num_elms, i);
+    });
+
+    migraphx::parameter_map pp;
+    for(std::size_t i = 0; i < num_data; ++i)
+        pp[std::to_string(i)] = migraphx::argument(s, data[i].data());
+
+    auto result = p.eval(pp).back();
+    std::vector<double> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    const auto mean = std::accumulate(scalars.begin(), scalars.end(), 0.0) / num_data;
+    std::vector<double> gold(num_elms, mean);
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
 TEST_CASE(nonzero_test)
 {
     migraphx::program p = migraphx::parse_onnx("nonzero_dynamic_test.onnx");
@@ -524,6 +667,48 @@ TEST_CASE(slice_step_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(softplus_test)
+{
+    migraphx::program p = migraphx::parse_onnx("softplus_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::float_type, {5}};
+    std::vector<float> data = {0, 1, 2, 3, 4};
+
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold(5);
+    std::transform(
+        data.begin(), data.end(), gold.begin(), [](auto x) { return std::log1p(std::exp(x)); });
+
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
+TEST_CASE(softsign_test)
+{
+    migraphx::program p = migraphx::parse_onnx("softsign_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::float_type, {5}};
+    std::vector<float> data = {0, 1, 2, 3, 4};
+
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold(5);
+    std::transform(
+        data.begin(), data.end(), gold.begin(), [](auto x) { return x / (1.0 + std::abs(x)); });
+
+    EXPECT(migraphx::verify_range(result_vector, gold));
+}
+
 TEST_CASE(upsample_test)
 {
     migraphx::program p = migraphx::parse_onnx("upsample_test.onnx");

test/op_shape_test.cpp

@@ -1544,4 +1544,26 @@ TEST_CASE(where_broadcast_input)
     expect_shape(s2, migraphx::make_op("where"), s3, s1, s2);
 }
 
+TEST_CASE(roialign_test)
+{
+    migraphx::shape sx{migraphx::shape::float_type, {3, 4, 5, 6}};
+    migraphx::shape srois{migraphx::shape::float_type, {2, 4}};
+    migraphx::shape sbi{migraphx::shape::int64_type, {2}};
+    migraphx::shape sout{migraphx::shape::float_type, {2, 4, 1, 1}};
+
+    expect_shape(sout, migraphx::make_op("roialign"), sx, srois, sbi);
+
+    migraphx::shape sbi1{migraphx::shape::int64_type, {2, 3}};
+    throws_shape(migraphx::make_op("roialign"), sx, srois, sbi1);
+
+    migraphx::shape sbi2{migraphx::shape::int64_type, {3}};
+    throws_shape(migraphx::make_op("roialign"), sx, srois, sbi2);
+
+    migraphx::shape srois1{migraphx::shape::float_type, {2, 4, 3}};
+    throws_shape(migraphx::make_op("roialign"), sx, srois1, sbi);
+
+    migraphx::shape srois2{migraphx::shape::float_type, {2, 3}};
+    throws_shape(migraphx::make_op("roialign"), sx, srois2, sbi);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/perf_report.cpp

@@ -19,6 +19,7 @@ TEST_CASE(perf_report)
 
     std::string output = ss.str();
     EXPECT(migraphx::contains(output, "Summary:"));
+    EXPECT(migraphx::contains(output, "Batch size:"));
     EXPECT(migraphx::contains(output, "Rate:"));
     EXPECT(migraphx::contains(output, "Total time:"));
     EXPECT(migraphx::contains(output, "Total instructions time:"));

test/py/onnx_backend_test.py

@@ -119,6 +119,7 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.include(r'.*test_globalmaxpool.*')
         backend_test.include(r'.*test_greater.*')
         backend_test.include(r'.*test_hardsigmoid.*')
+        backend_test.include(r'.*test_hardswish.*')
         backend_test.include(r'.*test_identity.*')
         backend_test.include(r'.*test_if.*')
         backend_test.include(r'.*test_LeakyReLU*')
@@ -174,6 +175,8 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.include(r'.*test_reduce.*')
         backend_test.include(r'.*test_ReLU*')
         backend_test.include(r'.*test_relu.*')
+        backend_test.include(r'.*test_RoiAlign*')
+        backend_test.include(r'.*test_roialign.*')
         backend_test.include(r'.*test_scatter.*')
         backend_test.include(r'.*test_Scatter.*')
         backend_test.include(r'.*test_selu.*')
@@ -264,18 +267,8 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.exclude(r'test_gathernd_example_float32_cpu')
         backend_test.exclude(r'test_gathernd_example_int32_batch_dim1_cpu')
         backend_test.exclude(r'test_gathernd_example_int32_cpu')
-        backend_test.exclude(r'test_greater_equal_bcast_cpu')
-        backend_test.exclude(r'test_greater_equal_bcast_expanded_cpu')
-        backend_test.exclude(r'test_greater_equal_cpu')
-        backend_test.exclude(r'test_greater_equal_expanded_cpu')
-        backend_test.exclude(r'test_hardsigmoid_cpu')
-        backend_test.exclude(r'test_hardsigmoid_default_cpu')
-        backend_test.exclude(r'test_hardsigmoid_example_cpu')
         backend_test.exclude(r'test_identity_sequence_cpu')
         backend_test.exclude(r'test_maxpool_2d_uint8_cpu')
-        backend_test.exclude(r'test_mean_example_cpu')
-        backend_test.exclude(r'test_mean_one_input_cpu')
-        backend_test.exclude(r'test_mean_two_inputs_cpu')
         backend_test.exclude(r'test_negative_log_likelihood_loss_*')
         backend_test.exclude(r'test_scatternd_*')
 
@@ -283,12 +276,7 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.exclude(r'test_size_cpu')
         backend_test.exclude(r'test_size_example_cpu')
         backend_test.exclude(r'test_softmax_cross_entropy_*')
-        backend_test.exclude(r'test_softplus_cpu')
-        backend_test.exclude(r'test_softplus_example_cpu')
-        backend_test.exclude(r'test_softsign_cpu')
-        backend_test.exclude(r'test_softsign_example_cpu')
         backend_test.exclude(r'test_Embedding_cpu')
-        backend_test.exclude(r'test_Softplus_cpu')
 
         # real model tests
         backend_test.exclude(r'test_inception_v1_cpu')

test/ref_ops_nonstd_shape_test.cpp

+#include <iostream>
+#include <vector>
+#include <migraphx/literal.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/ref/target.hpp>
+#include <migraphx/verify.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/auto_contiguous.hpp>
+#include <migraphx/pass_manager.hpp>
+#include "test.hpp"
+
+TEST_CASE(argmax_test_nonstd_shape)
+{
+    migraphx::program p;
+    auto* mm                = p.get_main_module();
+    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
+                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
+                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    auto dl_trans =
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 2, 0}}}), dl);
+    mm->add_instruction(migraphx::make_op("argmax", {{"axis", -3}}), dl_trans);
+    auto p_uncompiled = p;
+    p.compile(migraphx::ref::target{});
+    auto result   = p.eval({}).back();
+    auto res_gold = p_uncompiled.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    std::vector<int64_t> res_gold_vec;
+    res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify_range(result_vec, res_gold_vec));
+}
+
+TEST_CASE(argmin_test_nonstd_shape)
+{
+    migraphx::program p;
+    auto* mm                = p.get_main_module();
+    std::vector<float> data = {1.2255,  1.6834,  -2.0305, -0.3221, 0.4701,  0.2583, 0.7545, 2.5758,
+                               -1.6849, 0.0928,  0.9022,  -0.8765, -0.4090, 0.9301, 2.0724, -1.5706,
+                               0.4867,  -0.1493, 0.6957,  -0.2179, 0.7142,  0.7177, 0.0183, 1.3497};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3, 4}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    auto dl_trans =
+        mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 2, 0}}}), dl);
+    mm->add_instruction(migraphx::make_op("argmin", {{"axis", -1}}), dl_trans);
+    auto p_uncompiled = p;
+    p.compile(migraphx::ref::target{});
+    auto result   = p.eval({}).back();
+    auto res_gold = p_uncompiled.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    std::vector<int64_t> res_gold_vec;
+    res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify_range(result_vec, res_gold_vec));
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/ref_ops_test.cpp

@@ -1473,6 +1473,32 @@ TEST_CASE(fp32_fp16_test)
     test_case({"add"});
 }
 
+TEST_CASE(gather_non_std_test)
+{
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+
+        std::vector<float> data = {0.5f, 3.5f, 6.5f, 1.5f, 4.5f, 7.5f, 2.5f, 2.5f, 8.5f};
+        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
+        auto d = mm->add_literal(migraphx::literal{s, data});
+        migraphx::shape s_indices{migraphx::shape::int32_type, {2, 2}};
+        std::vector<int> indices{-3, -3, -1, -1};
+        auto ind = mm->add_literal(migraphx::literal{s_indices, indices});
+        auto td = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), d);
+        auto tind =
+            mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), ind);
+
+        mm->add_instruction(migraphx::make_op("gather", {{"axis", 0}}), td, tind);
+        auto result               = p.eval({}).back();
+        std::vector<float> golden = {
+            0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f, 0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
+        std::vector<float> res_data;
+        result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
+        EXPECT(migraphx::verify_range(res_data, golden));
+    }
+}
+
 TEST_CASE(gather_test)
 {
     {
@@ -1838,8 +1864,6 @@ TEST_CASE(if_param_test)
         auto res = p.eval(m).back();
         std::vector<float> ret;
         res.visit([&](auto v) { ret.assign(v.begin(), v.end()); });
-        std::cout << std::endl;
-
         return ret;
     };
 
@@ -2756,6 +2780,73 @@ TEST_CASE(neg_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(nms_not_center_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape boxes_s{migraphx::shape::float_type, {1, 6, 4}};
+    std::vector<float> boxes_vec = {1.0, 1.0,  0.0, 0.0,  0.0, 0.1,   1.0, 1.1,
+                                    0.0, 0.9,  1.0, -0.1, 0.0, 10.0,  1.0, 11.0,
+                                    1.0, 10.1, 0.0, 11.1, 1.0, 101.0, 0.0, 100.0};
+
+    migraphx::shape scores_s{migraphx::shape::float_type, {1, 1, 6}};
+    std::vector<float> scores_vec = {0.9, 0.75, 0.6, 0.95, 0.5, 0.3};
+
+    auto boxes_l         = mm->add_literal(migraphx::literal(boxes_s, boxes_vec));
+    auto scores_l        = mm->add_literal(migraphx::literal(scores_s, scores_vec));
+    auto max_out_l       = mm->add_literal(int64_t{4});
+    auto iou_threshold   = mm->add_literal(0.5f);
+    auto score_threshold = mm->add_literal(0.0f);
+
+    auto r = mm->add_instruction(migraphx::make_op("nonmaxsuppression"),
+                                 boxes_l,
+                                 scores_l,
+                                 max_out_l,
+                                 iou_threshold,
+                                 score_threshold);
+    mm->add_return({r});
+
+    p.compile(migraphx::ref::target{});
+    auto output = p.eval({}).back();
+    std::vector<int64_t> result;
+    output.visit([&](auto out) { result.assign(out.begin(), out.end()); });
+    std::vector<int64_t> gold = {0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    EXPECT(migraphx::verify_range(result, gold));
+}
+
+TEST_CASE(nms_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape boxes_s{migraphx::shape::float_type, {1, 6, 4}};
+    std::vector<float> boxes_vec = {0.5, 0.5,  1.0, 1.0, 0.5, 0.6,  1.0, 1.0, 0.5, 0.4,   1.0, 1.0,
+                                    0.5, 10.5, 1.0, 1.0, 0.5, 10.6, 1.0, 1.0, 0.5, 100.5, 1.0, 1.0};
+
+    migraphx::shape scores_s{migraphx::shape::float_type, {1, 1, 6}};
+    std::vector<float> scores_vec = {0.9, 0.75, 0.6, 0.95, 0.5, 0.3};
+
+    auto boxes_l         = mm->add_literal(migraphx::literal(boxes_s, boxes_vec));
+    auto scores_l        = mm->add_literal(migraphx::literal(scores_s, scores_vec));
+    auto max_out_l       = mm->add_literal(int64_t{4});
+    auto iou_threshold   = mm->add_literal(0.5f);
+    auto score_threshold = mm->add_literal(0.0f);
+
+    auto r = mm->add_instruction(migraphx::make_op("nonmaxsuppression", {{"center_point_box", 1}}),
+                                 boxes_l,
+                                 scores_l,
+                                 max_out_l,
+                                 iou_threshold,
+                                 score_threshold);
+    mm->add_return({r});
+
+    p.compile(migraphx::ref::target{});
+    auto output = p.eval({}).back();
+    std::vector<int64_t> result;
+    output.visit([&](auto out) { result.assign(out.begin(), out.end()); });
+    std::vector<int64_t> gold = {0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    EXPECT(migraphx::verify_range(result, gold));
+}
+
 TEST_CASE(nonzero_test)
 {
     migraphx::program p;
@@ -2768,7 +2859,6 @@ TEST_CASE(nonzero_test)
     mm->add_return({ret});
     p.compile(migraphx::ref::target{});
     auto result = p.eval({}).back();
-    std::cout << "result = " << result << std::endl;
     std::vector<int64_t> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
@@ -2865,6 +2955,26 @@ TEST_CASE(pad_test_lowest_half)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
+TEST_CASE(pointwise_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::float_type, {3}};
+    auto l1  = mm->add_literal(migraphx::literal{s, {-1, 0, 1}});
+    auto l2  = mm->add_literal(migraphx::literal{s, {1, 2, 3}});
+    auto* pm = p.create_module("pointwise");
+    auto x1  = pm->add_parameter("x1", {migraphx::shape::float_type});
+    auto x2  = pm->add_parameter("x2", {migraphx::shape::float_type});
+    pm->add_instruction(migraphx::make_op("add"), x1, x2);
+    mm->add_instruction(migraphx::make_op("pointwise"), {l1, l2}, {pm});
+    p.compile(migraphx::ref::target{});
+    auto result = p.eval({}).back();
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 2, 4};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(pow_test)
 {
     migraphx::program p;
@@ -3832,6 +3942,170 @@ TEST_CASE(reverse_test_axis10)
     EXPECT(migraphx::verify_range(results_vector, target_data));
 }
 
+TEST_CASE(roialign_out_of_bound_test)
+{
+    auto create_program = [](const std::string& trans_mode = "half_pixel") {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape x_s{migraphx::shape::float_type, {1, 1, 10, 10}};
+        std::vector<float> x_vec = {
+            0.2764, 0.7150, 0.1958, 0.3416, 0.4638, 0.0259, 0.2963, 0.6518, 0.4856, 0.7250,
+            0.9637, 0.0895, 0.2919, 0.6753, 0.0234, 0.6132, 0.8085, 0.5324, 0.8992, 0.4467,
+            0.3265, 0.8479, 0.9698, 0.2471, 0.9336, 0.1878, 0.4766, 0.4308, 0.3400, 0.2162,
+            0.0206, 0.1720, 0.2155, 0.4394, 0.0653, 0.3406, 0.7724, 0.3921, 0.2541, 0.5799,
+            0.4062, 0.2194, 0.4473, 0.4687, 0.7109, 0.9327, 0.9815, 0.6320, 0.1728, 0.6119,
+            0.3097, 0.1283, 0.4984, 0.5068, 0.4279, 0.0173, 0.4388, 0.0430, 0.4671, 0.7119,
+            0.1011, 0.8477, 0.4726, 0.1777, 0.9923, 0.4042, 0.1869, 0.7795, 0.9946, 0.9689,
+            0.1366, 0.3671, 0.7011, 0.6234, 0.9867, 0.5585, 0.6985, 0.5609, 0.8788, 0.9928,
+            0.5697, 0.8511, 0.6711, 0.9406, 0.8751, 0.7496, 0.1650, 0.1049, 0.1559, 0.2514,
+            0.7012, 0.4056, 0.7879, 0.3461, 0.0415, 0.2998, 0.5094, 0.3727, 0.5482, 0.0502};
+
+        migraphx::shape roi_s{migraphx::shape::float_type, {3, 4}};
+        std::vector<float> roi_vec = {0, 0, 9.99, 9.99, 0, 5, 4, 9, 5, 5, 9.9, 9.9};
+
+        migraphx::shape ind_s{migraphx::shape::int64_type, {3}};
+        std::vector<int64_t> ind_vec = {0, 0, 0};
+
+        auto x   = mm->add_literal(migraphx::literal(x_s, x_vec));
+        auto roi = mm->add_literal(migraphx::literal(roi_s, roi_vec));
+        auto ind = mm->add_literal(migraphx::literal(ind_s, ind_vec));
+        auto r =
+            mm->add_instruction(migraphx::make_op("roialign",
+                                                  {{"coordinate_transformation_mode", trans_mode},
+                                                   {"spatial_scale", 5.0},
+                                                   {"output_height", 1},
+                                                   {"output_width", 1},
+                                                   {"sampling_ratio", 1}}),
+                                x,
+                                roi,
+                                ind);
+        mm->add_return({r});
+        return p;
+    };
+
+    {
+        auto p = create_program("output_half_pixel");
+        p.compile(migraphx::ref::target{});
+        auto result = p.eval({}).back();
+        std::vector<float> results_vector;
+        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+        std::vector<float> gold = {0.0f, 0.0f, 0.0f};
+
+        EXPECT(migraphx::verify_range(results_vector, gold));
+    }
+}
+
+TEST_CASE(roialign_test)
+{
+    auto create_program = [](const std::string& trans_mode   = "half_pixel",
+                             const std::string& pooling_mode = "avg",
+                             int64_t sampling_ratio          = 2) {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape x_s{migraphx::shape::float_type, {1, 1, 10, 10}};
+        std::vector<float> x_vec = {
+            0.2764, 0.7150, 0.1958, 0.3416, 0.4638, 0.0259, 0.2963, 0.6518, 0.4856, 0.7250,
+            0.9637, 0.0895, 0.2919, 0.6753, 0.0234, 0.6132, 0.8085, 0.5324, 0.8992, 0.4467,
+            0.3265, 0.8479, 0.9698, 0.2471, 0.9336, 0.1878, 0.4766, 0.4308, 0.3400, 0.2162,
+            0.0206, 0.1720, 0.2155, 0.4394, 0.0653, 0.3406, 0.7724, 0.3921, 0.2541, 0.5799,
+            0.4062, 0.2194, 0.4473, 0.4687, 0.7109, 0.9327, 0.9815, 0.6320, 0.1728, 0.6119,
+            0.3097, 0.1283, 0.4984, 0.5068, 0.4279, 0.0173, 0.4388, 0.0430, 0.4671, 0.7119,
+            0.1011, 0.8477, 0.4726, 0.1777, 0.9923, 0.4042, 0.1869, 0.7795, 0.9946, 0.9689,
+            0.1366, 0.3671, 0.7011, 0.6234, 0.9867, 0.5585, 0.6985, 0.5609, 0.8788, 0.9928,
+            0.5697, 0.8511, 0.6711, 0.9406, 0.8751, 0.7496, 0.1650, 0.1049, 0.1559, 0.2514,
+            0.7012, 0.4056, 0.7879, 0.3461, 0.0415, 0.2998, 0.5094, 0.3727, 0.5482, 0.0502};
+
+        migraphx::shape roi_s{migraphx::shape::float_type, {3, 4}};
+        std::vector<float> roi_vec = {0, 0, 9, 9, 0, 5, 4, 9, 5, 5, 9, 9};
+
+        migraphx::shape ind_s{migraphx::shape::int64_type, {3}};
+        std::vector<int64_t> ind_vec = {0, 0, 0};
+
+        auto x   = mm->add_literal(migraphx::literal(x_s, x_vec));
+        auto roi = mm->add_literal(migraphx::literal(roi_s, roi_vec));
+        auto ind = mm->add_literal(migraphx::literal(ind_s, ind_vec));
+        auto r =
+            mm->add_instruction(migraphx::make_op("roialign",
+                                                  {{"coordinate_transformation_mode", trans_mode},
+                                                   {"spatial_scale", 1.0},
+                                                   {"output_height", 5},
+                                                   {"output_width", 5},
+                                                   {"sampling_ratio", sampling_ratio},
+                                                   {"mode", pooling_mode}}),
+                                x,
+                                roi,
+                                ind);
+        mm->add_return({r});
+        return p;
+    };
+
+    {
+        auto p = create_program();
+        p.compile(migraphx::ref::target{});
+        auto result = p.eval({}).back();
+        std::vector<float> results_vector;
+        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+        std::vector<float> gold = {
+            0.466421425, 0.446552634, 0.340521216, 0.568848491, 0.606780827, 0.371379346,
+            0.429571986, 0.383519977, 0.556241512, 0.351050019, 0.27680251,  0.488286227,
+            0.522200167, 0.552770197, 0.417057365, 0.471240699, 0.4844096,   0.690457463,
+            0.492039412, 0.877398551, 0.623889625, 0.712461948, 0.628926516, 0.335504025,
+            0.349469036, 0.302179992, 0.43046391,  0.469585985, 0.39774403,  0.542259991,
+            0.365552008, 0.704923987, 0.516481996, 0.317131996, 0.701444089, 0.291239977,
+            0.505897999, 0.647610962, 0.623489916, 0.829879999, 0.591567993, 0.738860011,
+            0.704825997, 0.837148011, 0.889315963, 0.622680008, 0.615276039, 0.709713995,
+            0.615356028, 0.458524048, 0.238451958, 0.337952018, 0.371693879, 0.609999895,
+            0.760059953, 0.376724035, 0.378532052, 0.71468991,  0.924308002, 0.972783983,
+            0.574903965, 0.582623959, 0.570936024, 0.761904061, 0.876998067, 0.535508037,
+            0.256580025, 0.214098021, 0.279604018, 0.360000014, 0.436488032, 0.350427985,
+            0.288755983, 0.366139978, 0.234920025};
+
+        EXPECT(migraphx::verify_range(results_vector, gold));
+    }
+
+    {
+        auto p = create_program("output_half_pixel");
+        p.compile(migraphx::ref::target{});
+        auto result = p.eval({}).back();
+        std::vector<float> results_vector;
+        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+        std::vector<float> gold = {
+            0.517783, 0.343411, 0.322905, 0.447362, 0.634375, 0.40308,  0.536647, 0.442791,
+            0.486144, 0.402313, 0.251194, 0.400154, 0.515524, 0.695369, 0.346537, 0.33504,
+            0.460099, 0.588069, 0.343863, 0.684932, 0.49319,  0.714058, 0.821744, 0.471935,
+            0.403946, 0.306955, 0.218678, 0.33369,  0.488001, 0.486962, 0.18709,  0.49142,
+            0.55611,  0.419167, 0.368608, 0.143278, 0.460835, 0.597125, 0.53096,  0.498207,
+            0.278818, 0.438569, 0.6022,   0.700038, 0.752436, 0.577385, 0.702383, 0.725097,
+            0.733754, 0.816304, 0.23933,  0.407514, 0.337893, 0.252521, 0.474335, 0.367075,
+            0.270168, 0.41051,  0.64189,  0.830777, 0.55564,  0.454295, 0.55645,  0.75015,
+            0.929997, 0.66257,  0.561664, 0.481275, 0.495449, 0.666306, 0.663573, 0.372107,
+            0.205603, 0.192776, 0.247849};
+
+        EXPECT(migraphx::verify_range(results_vector, gold));
+    }
+
+    {
+        auto p = create_program("output_half_pixel", "max", 0);
+        p.compile(migraphx::ref::target{});
+        auto result = p.eval({}).back();
+        std::vector<float> results_vector;
+        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+        std::vector<float> gold = {
+            0.819145, 0.373103, 0.258302,  0.515419, 0.726104, 0.540536, 0.545512,  0.38511,
+            0.376545, 0.274635, 0.22341,   0.184511, 0.230843, 0.404869, 0.29546,   0.540409,
+            0.265838, 0.409324, 0.213915,  0.708654, 0.687264, 0.580821, 0.461283,  0.462879,
+            0.709632, 0.27873,  0.083619,  0.22428,  0.313992, 0.410508, 0.0929099, 0.415373,
+            0.296695, 0.231574, 0.136836,  0.0683,   0.296695, 0.211925, 0.245385,  0.28053,
+            0.17091,  0.179879, 0.245385,  0.343539, 0.392742, 0.51273,  0.536193,  0.382995,
+            0.422793, 0.761886, 0.0839429, 0.276444, 0.19746,  0.126117, 0.378351,  0.254646,
+            0.092148, 0.272825, 0.381955,  0.626599, 0.251325, 0.244475, 0.194875,  0.272825,
+            0.44757,  0.351855, 0.342265,  0.244475, 0.274841, 0.553644, 0.607176,  0.202392,
+            0.07425,  0.066087, 0.126279};
+
+        EXPECT(migraphx::verify_range(results_vector, gold));
+    }
+}
+
 TEST_CASE(round_test)
 {
     migraphx::program p;

test/run_loop_test.cpp

@@ -75,7 +75,7 @@ struct test_loop_op
             ins_out_shapes.push_back({out_s.type(), lens});
         }
 
-        return migraphx::shape(ins_out_shapes);
+        return {ins_out_shapes};
     }
 
     struct test_loop : public migraphx::op::loop::ref_loop

test/simplify_reshapes_test.cpp

@@ -945,4 +945,177 @@ TEST_CASE(reshape_cont_nonpw)
     EXPECT(m1 == create_module());
 }
 
+TEST_CASE(transpose_contiguous_reshape_unary)
+{
+    migraphx::module m1;
+    {
+        auto x = m1.add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
+        auto reshape_ins1 =
+            m1.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 2, 2, 5, 5}}}), x);
+        auto transpose_ins = m1.add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), reshape_ins1);
+        auto cont_ins = m1.add_instruction(migraphx::make_op("contiguous"), transpose_ins);
+        auto reshape_ins2 =
+            m1.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 10, 10}}}), cont_ins);
+        auto relu = m1.add_instruction(migraphx::make_op("relu"), reshape_ins2);
+        m1.add_instruction(pass_op{}, relu);
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto x = m2.add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
+        auto reshape_ins1 =
+            m2.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 2, 2, 5, 5}}}), x);
+        auto transpose_ins = m2.add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), reshape_ins1);
+        auto relu     = m2.add_instruction(migraphx::make_op("relu"), transpose_ins);
+        auto cont_ins = m2.add_instruction(migraphx::make_op("contiguous"), relu);
+        auto reshape_ins2 =
+            m2.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 10, 10}}}), cont_ins);
+        m2.add_instruction(pass_op{}, reshape_ins2);
+    }
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(transpose_contiguous_squeeze_unary)
+{
+    migraphx::module m1;
+    {
+        auto x = m1.add_parameter("x", {migraphx::shape::float_type, {2, 8, 1, 5}});
+        auto transpose_ins =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), x);
+        auto cont_ins = m1.add_instruction(migraphx::make_op("contiguous"), transpose_ins);
+        auto sq_ins   = m1.add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), cont_ins);
+        auto rsqrt    = m1.add_instruction(migraphx::make_op("rsqrt"), sq_ins);
+        m1.add_instruction(pass_op{}, rsqrt);
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto x = m2.add_parameter("x", {migraphx::shape::float_type, {2, 8, 1, 5}});
+        auto transpose_ins =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), x);
+        auto rsqrt    = m2.add_instruction(migraphx::make_op("rsqrt"), transpose_ins);
+        auto cont_ins = m2.add_instruction(migraphx::make_op("contiguous"), rsqrt);
+        auto sq_ins   = m2.add_instruction(migraphx::make_op("squeeze", {{"axes", {1}}}), cont_ins);
+        m2.add_instruction(pass_op{}, sq_ins);
+    }
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(transpose_contiguous_unsqueeze_unary)
+{
+    migraphx::module m1;
+    {
+        auto x = m1.add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
+        auto transpose_ins =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), x);
+        auto cont_ins = m1.add_instruction(migraphx::make_op("contiguous"), transpose_ins);
+        auto unsq_ins =
+            m1.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {2}}}), cont_ins);
+        auto round = m1.add_instruction(migraphx::make_op("round"), unsq_ins);
+        m1.add_instruction(pass_op{}, round);
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto x = m2.add_parameter("x", {migraphx::shape::float_type, {2, 8, 5, 5}});
+        auto transpose_ins =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), x);
+        auto round    = m2.add_instruction(migraphx::make_op("round"), transpose_ins);
+        auto cont_ins = m2.add_instruction(migraphx::make_op("contiguous"), round);
+        auto unsq_ins =
+            m2.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {2}}}), cont_ins);
+        m2.add_instruction(pass_op{}, unsq_ins);
+    }
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(transpose_contiguous_reshape_binary_packed)
+{
+    migraphx::module m1;
+    {
+        auto x  = m1.add_parameter("x", {migraphx::shape::float_type, {2, 128, 28, 28}});
+        auto w1 = m1.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {256, 128, 1, 1}}));
+        auto conv1 = m1.add_instruction(
+            migraphx::make_op("convolution",
+                              {{"padding", {0, 0}}, {"stride", {1, 1}}, {"dilation", {1, 1}}}),
+            x,
+            w1); // (2, 256, 28, 28)
+        auto w2 = m1.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {512, 256, 1, 1}}));
+        auto conv2 = m1.add_instruction(
+            migraphx::make_op("convolution",
+                              {{"padding", {0, 0}}, {"stride", {2, 2}}, {"dilation", {1, 1}}}),
+            conv1,
+            w2); // (2, 512, 14, 14)
+
+        auto conv2_rsp1 = m1.add_instruction(
+            migraphx::make_op("reshape", {{"dims", {2, 2, 2, 128, 14, 14}}}), conv2);
+        auto conv2_trans = m1.add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), conv2_rsp1);
+        auto conv2_cont = m1.add_instruction(migraphx::make_op("contiguous"), conv2_trans);
+        auto conv2_rsp2 = m1.add_instruction(
+            migraphx::make_op("reshape", {{"dims", {2, 128, 28, 28}}}), conv2_cont);
+        auto add_ins = m1.add_instruction(migraphx::make_op("add"), conv2_rsp2, x);
+        m1.add_instruction(pass_op{}, add_ins);
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto x  = m2.add_parameter("x", {migraphx::shape::float_type, {2, 128, 28, 28}});
+        auto w1 = m2.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {256, 128, 1, 1}}));
+        auto conv1 = m2.add_instruction(
+            migraphx::make_op("convolution",
+                              {{"padding", {0, 0}}, {"stride", {1, 1}}, {"dilation", {1, 1}}}),
+            x,
+            w1); // (2, 256, 28, 28)
+        auto w2 = m2.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {512, 256, 1, 1}}));
+        auto conv2 = m2.add_instruction(
+            migraphx::make_op("convolution",
+                              {{"padding", {0, 0}}, {"stride", {2, 2}}, {"dilation", {1, 1}}}),
+            conv1,
+            w2); // (2, 512, 14, 14)
+
+        auto conv2_rsp = m2.add_instruction(
+            migraphx::make_op("reshape", {{"dims", {2, 2, 2, 128, 14, 14}}}), conv2);
+        auto conv2_trans = m2.add_instruction(
+            migraphx::make_op("transpose", {{"permutation", {0, 3, 4, 1, 5, 2}}}), conv2_rsp);
+        auto x_rsp =
+            m2.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 128, 14, 2, 14, 2}}}), x);
+        auto add_ins = m2.add_instruction(migraphx::make_op("add"), conv2_trans, x_rsp);
+        auto add_rsp =
+            m2.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 128, 28, 28}}}), add_ins);
+        m2.add_instruction(pass_op{}, add_rsp);
+    }
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(transpose_contiguous_reshape_binary_broadcast)
+{
+    migraphx::module m1;
+    {
+        migraphx::shape sx{migraphx::shape::float_type, {4}};
+        migraphx::shape sy{migraphx::shape::float_type, {2, 6, 2, 2}};
+
+        auto x       = m1.add_parameter("x", sx);
+        auto y       = m1.add_parameter("y", sy);
+        auto x_brcst = m1.add_instruction(
+            migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", {2, 4, 6}}}), x);
+        auto y_trans =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), y);
+        auto y_cont = m1.add_instruction(migraphx::make_op("contiguous"), y_trans);
+        auto y_rsp =
+            m1.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 4, 6}}}), y_cont);
+        auto r = m1.add_instruction(migraphx::make_op("add"), y_rsp, x_brcst);
+        m1.add_return({r});
+    }
+    migraphx::module m2 = m1;
+    run_pass(m1);
+    EXPECT(m1 == m2);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }