Merge

src/targets/gpu/kernels/include/migraphx/kernels/pointwise.hpp

@@ -33,38 +33,6 @@
 
 namespace migraphx {
 
-template <class T>
-struct implicit_conversion_op
-{
-    T x;
-
-    template <index_int N, class U>
-    constexpr operator vec<U, N>() const
-    {
-        if constexpr(vec_size<T>() == 0)
-        {
-            return x;
-        }
-        else
-        {
-            static_assert(vec_size<T>() == N, "Vector mismatch size");
-            return __builtin_convertvector(x, vec<U, N>);
-        }
-    }
-
-    template <class U>
-    constexpr operator U() const
-    {
-        return x;
-    }
-};
-
-template <class T>
-constexpr implicit_conversion_op<T> implicit_conversion(T x)
-{
-    return {x};
-}
-
 template <class F, class T, class... Ts>
 __device__ void pointwise_tensor(index idx, F f, T out, Ts... xs)
 {

src/targets/gpu/kernels/include/migraphx/kernels/vec.hpp

@@ -185,5 +185,37 @@ constexpr auto vec_reduce(T x, Op op)
     }
 }
 
+template <class T>
+struct implicit_conversion_op
+{
+    T x;
+
+    template <index_int N, class U>
+    constexpr operator vec<U, N>() const
+    {
+        if constexpr(vec_size<T>() == 0)
+        {
+            return x;
+        }
+        else
+        {
+            static_assert(vec_size<T>() == N, "Vector mismatch size");
+            return __builtin_convertvector(x, vec<U, N>);
+        }
+    }
+
+    template <class U>
+    constexpr operator U() const
+    {
+        return x;
+    }
+};
+
+template <class T>
+constexpr implicit_conversion_op<T> implicit_conversion(T x)
+{
+    return {x};
+}
+
 } // namespace migraphx
 #endif // MIGRAPHX_GUARD_KERNELS_VEC_HPP

src/targets/gpu/prefuse_ops.cpp

@@ -51,17 +51,20 @@ struct layernorm_base
         }
         check_shapes{inputs, static_cast<const Derived&>(*this)}.has(nargs + N);
         auto s = inputs.at(0);
+        auto t = s.type();
+        if(not mods.empty())
+            t = mods.front()->get_output_shapes().front().type();
         if(s.scalar())
         {
             return s;
         }
         else if(s.broadcasted())
         {
-            return {s.type(), s.lens()};
+            return {t, s.lens()};
         }
         else
         {
-            return s.with_lens(s.lens());
+            return s.with_lens(t, s.lens());
         }
     }
 };

src/targets/gpu/target.cpp

@@ -148,8 +148,6 @@ std::vector<pass> target::get_passes(migraphx::context& gctx, const compile_opti
         dead_code_elimination{},
         pack_int8_args{},
         dead_code_elimination{},
-        adjust_allocation{gpu_allocation_model{}},
-        dead_code_elimination{},
         fuse_ops{&ctx, options.fast_math},
         dead_code_elimination{},
         replace_allocate{gpu_allocation_model{}, options.offload_copy},

test/literal_test.cpp

@@ -49,6 +49,25 @@ TEST_CASE(literal_test)
     EXPECT(l4.empty());
 }
 
+TEST_CASE(literal_nstd_shape_vector)
+{
+    migraphx::shape nstd_shape{migraphx::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
+    std::vector<float> data(12);
+    std::iota(data.begin(), data.end(), 0);
+    auto l0 = migraphx::literal{nstd_shape, data};
+
+    // check data buffer is read in correctly
+    std::vector<float> expected_buffer = {0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11};
+    const auto* start                  = reinterpret_cast<const float*>(l0.data());
+    std::vector<float> l0_data{start, start + 12};
+    EXPECT(l0_data == expected_buffer);
+
+    // check that using visit() (that uses a tensor view) gives data in correct order
+    std::vector<float> results_vector(12);
+    l0.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    EXPECT(results_vector == data);
+}
+
 TEST_CASE(literal_os1)
 {
     migraphx::literal l{1};

test/onnx/gen_onnx.py

@@ -238,6 +238,64 @@ def averagepool_3d_test():
     return ([node], [x], [out])
 
 
+@onnx_test
+def averagepool_dyn_test():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
+                                      [None, 3, 5, 5, 5])
+    out = helper.make_tensor_value_info('1', TensorProto.FLOAT,
+                                        [None, 3, 3, 3, 3])
+
+    node = onnx.helper.make_node('AveragePool',
+                                 inputs=['0'],
+                                 outputs=['1'],
+                                 kernel_shape=[3, 3, 3])
+
+    return ([node], [x], [out])
+
+
+@onnx_test
+def averagepool_dyn_autopad_error_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 5, 5])
+
+    node = onnx.helper.make_node('AveragePool',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 kernel_shape=[2, 2],
+                                 auto_pad='SAME_LOWER')
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def averagepool_dyn_asym_padding_error_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 3, 3])
+
+    node = onnx.helper.make_node('AveragePool',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 kernel_shape=[2, 2],
+                                 strides=[2, 2],
+                                 pads=[0, 0, 1, 1])
+
+    return ([node], [x], [y])
+
+
+@onnx_test
+def averagepool_dyn_cip_error_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 1, 1])
+
+    node = onnx.helper.make_node('AveragePool',
+                                 inputs=['x'],
+                                 outputs=['y'],
+                                 kernel_shape=[2, 2],
+                                 count_include_pad=1)
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def averagepool_notset_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
@@ -2107,6 +2165,21 @@ def globalavgpool_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def globalavgpool_dyn_test():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
+                                      [None, 3, 16, 16])
+    y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [None, 3, 1, 1])
+
+    node = onnx.helper.make_node(
+        'GlobalAveragePool',
+        inputs=['0'],
+        outputs=['1'],
+    )
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def globallppool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
@@ -2121,6 +2194,21 @@ def globallppool_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def globallppool_dyn_test():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
+                                      [1, 3, None, None])
+    y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
+
+    node = onnx.helper.make_node(
+        'GlobalLpPool',
+        inputs=['0'],
+        outputs=['1'],
+    )
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def globalmaxpool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
@@ -2135,6 +2223,21 @@ def globalmaxpool_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def globalmaxpool_dyn_test():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
+                                      [None, 3, 32, 32])
+    y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [None, 3, 1, 1])
+
+    node = onnx.helper.make_node(
+        'GlobalMaxPool',
+        inputs=['0'],
+        outputs=['1'],
+    )
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def greater_test():
     ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
@@ -6315,6 +6418,21 @@ def transpose_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def transpose_dyn_test():
+    x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 2, 2, 3])
+    y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [None, 3, 2, 2])
+
+    node = onnx.helper.make_node(
+        'Transpose',
+        perm=[0, 3, 1, 2],
+        inputs=['0'],
+        outputs=['1'],
+    )
+
+    return ([node], [x], [y])
+
+
 @onnx_test
 def transpose_gather_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 5, 4, 6])

test/onnx/onnx_test.cpp

@@ -273,6 +273,51 @@ TEST_CASE(averagepool_3d_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(averagepool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter(
+        "0",
+        {migraphx::shape::float_type, {{1, 4, 0}, {3, 3, 0}, {5, 5, 0}, {5, 5, 0}, {5, 5, 0}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::average},
+                                                      {"padding", {0, 0, 0, 0, 0, 0}},
+                                                      {"stride", {1, 1, 1}},
+                                                      {"lengths", {3, 3, 3}}}),
+                                   l0);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    auto prog                     = migraphx::parse_onnx("averagepool_dyn_test.onnx", options);
+    EXPECT(p == prog);
+}
+
+TEST_CASE(averagepool_dyn_autopad_error_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("averagepool_dyn_autopad_error_test.onnx", options); }));
+}
+
+TEST_CASE(averagepool_dyn_asym_padding_error_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("averagepool_dyn_asym_padding_error_test.onnx", options); }));
+}
+
+TEST_CASE(averagepool_dyn_cip_error_test)
+{
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    EXPECT(test::throws(
+        [&] { migraphx::parse_onnx("averagepool_dyn_cip_error_test.onnx", options); }));
+}
+
 TEST_CASE(averagepool_notset_test)
 {
     migraphx::program p;
@@ -2144,6 +2189,28 @@ TEST_CASE(globalavgpool_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(globalavgpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0",
+                          migraphx::shape{migraphx::shape::float_type,
+                                          {{1, 4, 0}, {3, 3, 0}, {16, 16, 0}, {16, 16, 0}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::average},
+                                                      {"lengths", {16, 16}},
+                                                      {"padding", {0, 0, 0, 0}}}),
+                                   input);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    auto prog                     = parse_onnx("globalavgpool_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(globallppool_test)
 {
     migraphx::program p;
@@ -2161,6 +2228,29 @@ TEST_CASE(globallppool_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(globallppool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0",
+                          migraphx::shape{migraphx::shape::float_type,
+                                          {{1, 1, 0}, {3, 3, 0}, {16, 32, 0}, {16, 32, 0}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::lpnorm},
+                                                      {"dyn_global", true},
+                                                      {"padding", {0, 0, 0, 0}},
+                                                      {"lengths", {}}}),
+                                   input);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {16, 32, 0};
+    auto prog                     = migraphx::parse_onnx("globallppool_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(globalmaxpool_test)
 {
     migraphx::program p;
@@ -2178,6 +2268,28 @@ TEST_CASE(globalmaxpool_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(globalmaxpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto input =
+        mm->add_parameter("0",
+                          migraphx::shape{migraphx::shape::float_type,
+                                          {{1, 4, 0}, {3, 3, 0}, {32, 32, 0}, {32, 32, 0}}});
+    auto ret = mm->add_instruction(migraphx::make_op("pooling",
+                                                     {{"mode", migraphx::op::pooling_mode::max},
+                                                      {"lengths", {32, 32}},
+                                                      {"padding", {0, 0, 0, 0}}}),
+                                   input);
+    mm->add_return({ret});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    auto prog                     = parse_onnx("globalmaxpool_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(greater_test)
 {
     migraphx::program p;
@@ -5973,6 +6085,24 @@ TEST_CASE(transpose_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(transpose_dyn_test)
+{
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto input = mm->add_parameter(
+        "0",
+        migraphx::shape{migraphx::shape::float_type, {{1, 4, 0}, {2, 2, 0}, {2, 2, 0}, {3, 3, 0}}});
+    std::vector<int64_t> perm{0, 3, 1, 2};
+    auto t0 = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), input);
+    mm->add_return({t0});
+
+    migraphx::onnx_options options;
+    options.default_dyn_dim_value = {1, 4, 0};
+    auto prog                     = migraphx::parse_onnx("transpose_dyn_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(topk_attrk_test)
 {
     migraphx::program p;

test/op_shape_test.cpp

@@ -1549,16 +1549,76 @@ TEST_CASE(nms_shape)
                  score_thres_s);
 }
 
-TEST_CASE(pooling_shape)
+TEST_CASE(pooling_shape0)
 {
+    migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};
+    throws_shape(migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {1}},
+                                    {"stride", {0}},
+                                    {"lengths", {1}}}),
+                 input);
+}
+
+TEST_CASE(pooling_shape1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};
     migraphx::shape output{migraphx::shape::float_type, {4, 3, 1, 1}};
+    expect_shape(output,
+                 migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {0, 0}},
+                                    {"stride", {3, 3}},
+                                    {"lengths", {1, 1}}}),
+                 input);
+}
+
+TEST_CASE(pooling_shape2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};
+    migraphx::shape output{migraphx::shape::float_type, {4, 3, 2, 2}};
+    expect_shape(output,
+                 migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {0, 0}},
+                                    {"stride", {3, 3}},
+                                    {"lengths", {1, 1}},
+                                    {"ceil_mode", true}}),
+                 input);
+}
+
+TEST_CASE(pooling_shape3)
+{
     migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};
+    migraphx::shape output{migraphx::shape::float_type, {4, 3, 3, 3}};
+    expect_shape(output,
+                 migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {2, 2}},
+                                    {"stride", {3, 3}},
+                                    {"lengths", {3, 3}},
+                                    {"ceil_mode", true}}),
+                 input);
+}
+
+TEST_CASE(pooling_dyn_shape0)
+{
+    migraphx::shape input{migraphx::shape::float_type,
+                          {{1, 4, 0}, {3, 3, 3}, {3, 3, 3}, {3, 3, 0}}};
     throws_shape(migraphx::make_op("pooling",
                                    {{"mode", migraphx::op::pooling_mode::max},
                                     {"padding", {1}},
                                     {"stride", {0}},
                                     {"lengths", {1}}}),
                  input);
+}
+
+TEST_CASE(pooling_dyn_shape1)
+{
+    migraphx::shape input{migraphx::shape::float_type,
+                          {{1, 4, 0}, {3, 3, 3}, {3, 3, 3}, {3, 3, 0}}};
+    migraphx::shape output{migraphx::shape::float_type,
+                           {{1, 4, 0}, {3, 3, 3}, {1, 1, 1}, {1, 1, 0}}};
     expect_shape(output,
                  migraphx::make_op("pooling",
                                    {{"mode", migraphx::op::pooling_mode::max},
@@ -1566,9 +1626,15 @@ TEST_CASE(pooling_shape)
                                     {"stride", {3, 3}},
                                     {"lengths", {1, 1}}}),
                  input);
+}
 
-    migraphx::shape output1{migraphx::shape::float_type, {4, 3, 2, 2}};
-    expect_shape(output1,
+TEST_CASE(pooling_dyn_shape2)
+{
+    migraphx::shape input{migraphx::shape::float_type,
+                          {{1, 4, 0}, {5, 5, 0}, {3, 3, 3}, {3, 3, 0}}};
+    migraphx::shape output{migraphx::shape::float_type,
+                           {{1, 4, 0}, {5, 5, 0}, {2, 2, 2}, {2, 2, 0}}};
+    expect_shape(output,
                  migraphx::make_op("pooling",
                                    {{"mode", migraphx::op::pooling_mode::max},
                                     {"padding", {0, 0}},
@@ -1578,6 +1644,37 @@ TEST_CASE(pooling_shape)
                  input);
 }
 
+TEST_CASE(pooling_dyn_shape3)
+{
+    migraphx::shape input{migraphx::shape::float_type,
+                          {{4, 4, 0}, {3, 3, 0}, {4, 12, 8}, {4, 12, 8}}};
+    migraphx::shape output{migraphx::shape::float_type,
+                           {{4, 4, 0}, {3, 3, 0}, {2, 4, 3}, {2, 4, 3}}};
+    expect_shape(output,
+                 migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {0, 0}},
+                                    {"stride", {3, 3}},
+                                    {"lengths", {1, 1}}}),
+                 input);
+}
+
+TEST_CASE(pooling_dyn_shape4)
+{
+    migraphx::shape input{migraphx::shape::float_type,
+                          {{4, 4, 0}, {3, 3, 0}, {4, 12, 8}, {4, 12, 8}}};
+    migraphx::shape output{migraphx::shape::float_type,
+                           {{4, 4, 0}, {3, 3, 0}, {3, 6, 4}, {3, 6, 4}}};
+    expect_shape(output,
+                 migraphx::make_op("pooling",
+                                   {{"mode", migraphx::op::pooling_mode::max},
+                                    {"padding", {2, 2}},
+                                    {"stride", {3, 3}},
+                                    {"lengths", {3, 3}},
+                                    {"ceil_mode", true}}),
+                 input);
+}
+
 TEST_CASE(prefix_scan_sum)
 {
     {
@@ -2226,6 +2323,28 @@ TEST_CASE(transpose_shape)
     throws_shape(migraphx::make_op("transpose", {{"permutation", {1, 2}}}), input);
 }
 
+TEST_CASE(transpose_dyn_shape0)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4, 0}, {2, 2, 0}}};
+    migraphx::shape output{migraphx::shape::float_type, {{2, 2, 0}, {1, 4, 0}}};
+    expect_shape(input, migraphx::make_op("transpose", {{"permutation", {0, 1}}}), input);
+    expect_shape(output, migraphx::make_op("transpose", {{"permutation", {1, 0}}}), input);
+}
+
+TEST_CASE(transpose_dyn_shape1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4, 0}, {4, 4, 0}, {4, 4, 0}}};
+    migraphx::shape output{migraphx::shape::float_type, {{4, 4, 0}, {4, 4, 0}, {1, 4, 0}}};
+    expect_shape(input, migraphx::make_op("transpose", {{"permutation", {0, 1, 2}}}), input);
+    expect_shape(output, migraphx::make_op("transpose", {{"permutation", {2, 1, 0}}}), input);
+}
+
+TEST_CASE(transpose_axes_error)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 2}};
+    throws_shape(migraphx::make_op("transpose", {{"permutation", {1}}}), input);
+}
+
 TEST_CASE(step_test)
 {
     migraphx::shape s1{migraphx::shape::float_type, {1, 2, 4}};

test/ref_ops_test.cpp

@@ -60,15 +60,16 @@ TEST_CASE(abs_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(abs_dynamic_test)
+TEST_CASE(abs_dyn_test)
 {
     migraphx::program p;
-    auto* mm             = p.get_main_module();
-    std::vector<float> a = {-1, 2, -3, 4};
+    auto* mm = p.get_main_module();
     migraphx::shape s{migraphx::shape::float_type, {{2, 8, 0}, {2, 2, 0}}};
     auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("abs"), input);
     p.compile(migraphx::ref::target{});
+
+    std::vector<float> a = {-1, 2, -3, 4};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 2}};
     params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
@@ -97,17 +98,17 @@ TEST_CASE(acos_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(acos_dynamic_test)
+TEST_CASE(acos_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-0.8f, 0.0f, 1.0f};
     mm->add_instruction(migraphx::make_op("acos"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-0.8f, 0.0f, 1.0f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -138,7 +139,7 @@ TEST_CASE(acosh_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(acosh_dynamic_test)
+TEST_CASE(acosh_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -419,17 +420,17 @@ TEST_CASE(asin_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(asin_dynamic_test)
+TEST_CASE(asin_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-0.5f, 0.0f, 0.9f};
     mm->add_instruction(migraphx::make_op("asin"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-0.5f, 0.0f, 0.9f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -460,17 +461,17 @@ TEST_CASE(asinh_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(asinh_dynamic_test)
+TEST_CASE(asinh_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-0.5f, 0.0f, 0.9f};
     mm->add_instruction(migraphx::make_op("asinh"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-0.5f, 0.0f, 0.9f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -501,17 +502,17 @@ TEST_CASE(atan_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(atan_dynamic_test)
+TEST_CASE(atan_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1.0f, 0.0f, 1.0f};
     mm->add_instruction(migraphx::make_op("atan"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1.0f, 0.0f, 1.0f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -542,17 +543,17 @@ TEST_CASE(atanh_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(atanh_dynamic_test)
+TEST_CASE(atanh_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{0.4435683f, 0.6223626f, 0.316958f};
     mm->add_instruction(migraphx::make_op("atanh"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{0.4435683f, 0.6223626f, 0.316958f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -565,111 +566,136 @@ TEST_CASE(atanh_dynamic_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(avgpool_test)
+TEST_CASE(avgpool_rank3_test)
 {
     // 1D case 1, input is 3D
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
-        op.lengths = {2};
-        op.padding = {0};
-        op.stride  = {1};
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths = {2};
+    op.padding = {0};
+    op.stride  = {1};
 
-        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.25, 0.3, 0.25, 0.65, 0.7, 0.5, 0.4, 0.4, 0.35};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.25, 0.3, 0.25, 0.65, 0.7, 0.5, 0.4, 0.4, 0.35};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(avgpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::float_type, {{1, 4, 0}, {3, 3, 0}, {4, 4, 0}}};
+    auto x   = mm->add_parameter("X", s);
+    mm->add_instruction(migraphx::make_op("pooling",
+                                          {{"mode", migraphx::op::pooling_mode::average},
+                                           {"lengths", {2}},
+                                           {"padding", {0}},
+                                           {"stride", {1}}}),
+                        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 4}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.25, 0.3, 0.25, 0.65, 0.7, 0.5, 0.4, 0.4, 0.35};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
 
+TEST_CASE(avgpool_rank3_stride2_test)
+{
     // 1D case 2, stride 2
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 4}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
-        op.lengths = {2};
-        op.padding = {1};
-        op.stride  = {2};
-
-        std::vector<float> data{1.6321,
-                                -2.4186,
-                                0.2239,
-                                -1.4232,
-                                0.8158,
-                                0.4103,
-                                -0.3149,
-                                -0.1361,
-                                -0.3442,
-                                2.007,
-                                0.4331,
-                                1.5295,
-                                0.9965,
-                                0.4766,
-                                1.0942,
-                                -0.2915};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        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{1.6321,
-                                -1.0974,
-                                -1.4232,
-                                0.8158,
-                                0.0477,
-                                -0.1361,
-                                -0.3442,
-                                1.22005,
-                                1.5295,
-                                0.9965,
-                                0.7854,
-                                -0.2915};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 4}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths = {2};
+    op.padding = {1};
+    op.stride  = {2};
+
+    std::vector<float> data{1.6321,
+                            -2.4186,
+                            0.2239,
+                            -1.4232,
+                            0.8158,
+                            0.4103,
+                            -0.3149,
+                            -0.1361,
+                            -0.3442,
+                            2.007,
+                            0.4331,
+                            1.5295,
+                            0.9965,
+                            0.4766,
+                            1.0942,
+                            -0.2915};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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{1.6321,
+                            -1.0974,
+                            -1.4232,
+                            0.8158,
+                            0.0477,
+                            -0.1361,
+                            -0.3442,
+                            1.22005,
+                            1.5295,
+                            0.9965,
+                            0.7854,
+                            -0.2915};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
 
+TEST_CASE(avgpool_rank5_test)
+{
     // 3D, input is 5D
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
-        op.lengths = {2, 2, 2};
-        op.padding = {0, 0, 0};
-        op.stride  = {1, 1, 1};
-
-        std::vector<float> data{
-            -0.179, -1.756, 0.651,  1.955,  1.87,   -0.604, 0.247,  0.449,  -0.137, 1.187,  1.593,
-            0.424,  2.698,  -0.104, -0.069, -1.293, 0.538,  1.291,  0.974,  1.096,  0.74,   -0.669,
-            -1.08,  -1.041, -1.407, 1.43,   -0.211, -0.017, 0.532,  1.276,  0.627,  0.236,  -0.396,
-            -0.204, 0.501,  -0.599, -1.414, -0.615, -0.274, 0.168,  -0.144, 0.5,    1.42,   1.082,
-            -0.952, -0.846, -1.244, 1.475,  1.246,  1.344,  -1.722, -1.24,  -0.851, 0.06,   0.507,
-            0.762,  -0.007, -1.484, 1.028,  0.317,  1.077,  -1.289, 0.875,  -0.417, -0.673, 1.715,
-            -0.307, 0.264,  -0.973, 1.412,  2.561,  -0.515, -0.201, 0.827,  -1.231, 1.958,  -0.552,
-            0.036,  -0.993, -0.859, -1.458, -0.575, 0.048,  -0.779, -1.025, -1.135, 1.166,  -0.131,
-            0.726,  0.52,   0.467,  -0.494, 0.675,  0.203,  -0.63,  -0.918, -0.5,   -1.395, 1.39,
-            1.705,  0.444,  -0.835, -0.506, 0.101,  0.602,  0.543,  0.357,  1.042};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        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.908,     0.250625,  0.795,     0.40425, 0.711875,  0.194875,  0.014125,  0.09425,
-            -0.078375, 0.139375,  0.46075,   0.0285,  -0.188125, -0.085,    0.378125,  -0.085375,
-            -0.04,     0.304125,  0.40775,   0.2835,  0.112375,  -0.073375, 0.4355,    -0.187,
-            -0.392625, -0.258375, -0.485875, -0.0345, 0.16125,   -0.131875, -0.228375, 0.068625};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::average};
+    op.lengths = {2, 2, 2};
+    op.padding = {0, 0, 0};
+    op.stride  = {1, 1, 1};
+
+    std::vector<float> data{
+        -0.179, -1.756, 0.651,  1.955,  1.87,   -0.604, 0.247,  0.449,  -0.137, 1.187,  1.593,
+        0.424,  2.698,  -0.104, -0.069, -1.293, 0.538,  1.291,  0.974,  1.096,  0.74,   -0.669,
+        -1.08,  -1.041, -1.407, 1.43,   -0.211, -0.017, 0.532,  1.276,  0.627,  0.236,  -0.396,
+        -0.204, 0.501,  -0.599, -1.414, -0.615, -0.274, 0.168,  -0.144, 0.5,    1.42,   1.082,
+        -0.952, -0.846, -1.244, 1.475,  1.246,  1.344,  -1.722, -1.24,  -0.851, 0.06,   0.507,
+        0.762,  -0.007, -1.484, 1.028,  0.317,  1.077,  -1.289, 0.875,  -0.417, -0.673, 1.715,
+        -0.307, 0.264,  -0.973, 1.412,  2.561,  -0.515, -0.201, 0.827,  -1.231, 1.958,  -0.552,
+        0.036,  -0.993, -0.859, -1.458, -0.575, 0.048,  -0.779, -1.025, -1.135, 1.166,  -0.131,
+        0.726,  0.52,   0.467,  -0.494, 0.675,  0.203,  -0.63,  -0.918, -0.5,   -1.395, 1.39,
+        1.705,  0.444,  -0.835, -0.506, 0.101,  0.602,  0.543,  0.357,  1.042};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.908,     0.250625,  0.795,     0.40425, 0.711875,  0.194875,  0.014125,  0.09425,
+        -0.078375, 0.139375,  0.46075,   0.0285,  -0.188125, -0.085,    0.378125,  -0.085375,
+        -0.04,     0.304125,  0.40775,   0.2835,  0.112375,  -0.073375, 0.4355,    -0.187,
+        -0.392625, -0.258375, -0.485875, -0.0345, 0.16125,   -0.131875, -0.228375, 0.068625};
+    EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
 TEST_CASE(broadcast_test)
@@ -758,17 +784,17 @@ TEST_CASE(ceil_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(ceil_dynamic_test)
+TEST_CASE(ceil_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{4, 12, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("ceil"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {9}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -918,11 +944,38 @@ TEST_CASE(contiguous_test)
     p.compile(migraphx::ref::target{});
     auto result = p.eval({}).back();
 
+    std::vector<size_t> new_strides = {12, 4, 2, 1};
+    EXPECT(result.get_shape().strides() == new_strides);
+
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<size_t> new_lens    = {1, 3, 2, 2};
-    std::vector<size_t> new_strides = {12, 1, 6, 3};
-    EXPECT(migraphx::verify_range(results_vector, data));
+
+    std::vector<float> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(contiguous_param_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape a_shape{migraphx::shape::float_type, {1, 3, 2, 2}, {12, 1, 6, 3}};
+    auto a = mm->add_parameter("X", a_shape);
+    mm->add_instruction(migraphx::make_op("contiguous"), a);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data(12);
+    std::iota(data.begin(), data.end(), 0);
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(a_shape, data.data());
+    auto result = p.eval(params).back();
+
+    std::vector<size_t> new_strides = {12, 4, 2, 1};
+    EXPECT(result.get_shape().strides() == new_strides);
+
+    std::vector<float> results_vector(12);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+    EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
 TEST_CASE(contiguous_dyn_test)
@@ -1069,7 +1122,7 @@ TEST_CASE(conv_dynamic_batch_test)
     EXPECT(migraphx::verify_range(results_vector, sol));
 }
 
-TEST_CASE(conv_dynamic_img_shape_test)
+TEST_CASE(conv_dyn_img_shape_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -1158,7 +1211,7 @@ TEST_CASE(conv_dynamic_img_shape_test)
     EXPECT(migraphx::verify_range(results_vector, sol));
 }
 
-TEST_CASE(conv_dynamic_weights_shape_test)
+TEST_CASE(conv_dyn_weights_shape_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -1235,7 +1288,7 @@ TEST_CASE(conv_dynamic_weights_shape_test)
     EXPECT(migraphx::verify_range(results_vector, sol));
 }
 
-TEST_CASE(conv_dynamic_img_same_upper_test)
+TEST_CASE(conv_dyn_img_same_upper_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -1306,7 +1359,7 @@ TEST_CASE(conv_dynamic_img_same_upper_test)
     EXPECT(migraphx::verify_range(results_vector, sol));
 }
 
-TEST_CASE(conv_dynamic_kernel_same_upper_test)
+TEST_CASE(conv_dyn_kernel_same_upper_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -1380,7 +1433,7 @@ TEST_CASE(conv_dynamic_kernel_same_upper_test)
     EXPECT(migraphx::verify_range(results_vector, sol));
 }
 
-TEST_CASE(conv_dynamic_kernel_same_lower_test)
+TEST_CASE(conv_dyn_kernel_same_lower_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -1725,17 +1778,17 @@ TEST_CASE(cos_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(cos_dynamic_test)
+TEST_CASE(cos_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1, 0, 1};
     mm->add_instruction(migraphx::make_op("cos"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1, 0, 1};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -1766,17 +1819,17 @@ TEST_CASE(cosh_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(cosh_dynamic_test)
+TEST_CASE(cosh_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {-1.0, 2.0, -3.0, 4.0};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("cosh"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {-1.0, 2.0, -3.0, 4.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {4}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -1999,18 +2052,18 @@ TEST_CASE(elu_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(elu_dynamic_test)
+TEST_CASE(elu_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1.0, 2.0, -3.0, 4.0};
+    auto input  = mm->add_parameter("X", s);
     float alpha = 0.5;
     mm->add_instruction(migraphx::make_op("elu", {{"alpha", alpha}}), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1.0, 2.0, -3.0, 4.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {4}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -2117,17 +2170,17 @@ TEST_CASE(erf_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(erf_dynamic_test)
+TEST_CASE(erf_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {0.73785057, 1.58165966, -0.43597795, -0.01677432};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("erf"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {0.73785057, 1.58165966, -0.43597795, -0.01677432};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {4}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -2158,17 +2211,17 @@ TEST_CASE(exp_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(exp_dynamic_test)
+TEST_CASE(exp_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1, 0, 1};
     mm->add_instruction(migraphx::make_op("exp"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1, 0, 1};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -2199,17 +2252,17 @@ TEST_CASE(floor_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(floor_dynamic_test)
+TEST_CASE(floor_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{5, 12, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {1.1, 1.5, 0.6, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("floor"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {1.1, 1.5, 0.6, -1.1, -1.5, -0.6, 0.0, 2.0, -2.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {9}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -2667,6 +2720,30 @@ TEST_CASE(globalavgpool_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
+TEST_CASE(globalavgpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s =
+        migraphx::shape{migraphx::shape::float_type, {{1, 1, 0}, {3, 3, 0}, {2, 6, 0}, {2, 6, 2}}};
+    auto x = mm->add_parameter("X", s);
+    mm->add_instruction(
+        migraphx::make_op("pooling",
+                          {{"mode", migraphx::op::pooling_mode::average}, {"dyn_global", true}}),
+        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 2, 2}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.25, 0.575, 0.375};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(globallppool_test)
 {
     migraphx::program p;
@@ -2689,6 +2766,30 @@ TEST_CASE(globallppool_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
+TEST_CASE(globallppool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s =
+        migraphx::shape{migraphx::shape::float_type, {{1, 1, 0}, {3, 3, 0}, {2, 6, 2}, {2, 6, 2}}};
+    auto x = mm->add_parameter("X", s);
+    mm->add_instruction(
+        migraphx::make_op("pooling",
+                          {{"mode", migraphx::op::pooling_mode::lpnorm}, {"dyn_global", true}}),
+        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 2, 2}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.5477225575051662, 1.307669683062202, 0.9327379053088815};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(globalmaxpool_test)
 {
     migraphx::program p;
@@ -2710,6 +2811,30 @@ TEST_CASE(globalmaxpool_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
+TEST_CASE(globalmaxpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s =
+        migraphx::shape{migraphx::shape::float_type, {{1, 1, 0}, {3, 3, 0}, {2, 6, 2}, {2, 6, 2}}};
+    auto x = mm->add_parameter("X", s);
+    mm->add_instruction(
+        migraphx::make_op("pooling",
+                          {{"mode", migraphx::op::pooling_mode::max}, {"dyn_global", true}}),
+        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 2, 2}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector(3);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.4, 0.9, 0.7};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(greater_brcst_test)
 {
     migraphx::program p;
@@ -2803,16 +2928,16 @@ TEST_CASE(identity_test)
     EXPECT(std::equal(data.begin(), data.end(), results_vector.begin()));
 }
 
-TEST_CASE(identity_dynamic_test)
+TEST_CASE(identity_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s{migraphx::shape::float_type, {{2, 4, 0}, {2, 4, 0}}};
     auto input = mm->add_parameter("X", s);
-    std::vector<int> input_data{1, 2, 3, 4};
     mm->add_instruction(migraphx::make_op("identity"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<int> input_data{1, 2, 3, 4};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::int32_type, {2, 2}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -3049,17 +3174,17 @@ TEST_CASE(isnan_test)
     }
 }
 
-TEST_CASE(isnan_dynamic_test)
+TEST_CASE(isnan_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s{migraphx::shape::float_type, {{2, 2, 0}, {3, 8, 0}}};
-    auto input                    = mm->add_parameter("X", s);
-    auto nan_val                  = std::numeric_limits<float>::quiet_NaN();
-    std::vector<float> input_data = {1.2, 5.2, nan_val, nan_val, 0., 100.};
+    auto input   = mm->add_parameter("X", s);
+    auto nan_val = std::numeric_limits<float>::quiet_NaN();
     mm->add_instruction(migraphx::make_op("isnan"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {1.2, 5.2, nan_val, nan_val, 0., 100.};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -3420,17 +3545,17 @@ TEST_CASE(log_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(log_dynamic_test)
+TEST_CASE(log_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {1, 2, 3};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("log"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {1, 2, 3};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -3732,61 +3857,93 @@ TEST_CASE(logsoftmax_test_axis_3)
     EXPECT(migraphx::verify_range(results_vector, s));
 }
 
-TEST_CASE(lppool_test)
+TEST_CASE(lppool_l1_norm_test)
 {
     // L1 norm test
-    {
-        migraphx::program p;
-        auto* mm    = p.get_main_module();
-        auto s      = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
-        auto op     = migraphx::op::pooling{migraphx::op::pooling_mode::lpnorm};
-        op.lengths  = {2};
-        op.padding  = {0};
-        op.stride   = {1};
-        op.lp_order = 1;
-
-        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    migraphx::program p;
+    auto* mm    = p.get_main_module();
+    auto s      = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op     = migraphx::op::pooling{migraphx::op::pooling_mode::lpnorm};
+    op.lengths  = {2};
+    op.padding  = {0};
+    op.stride   = {1};
+    op.lp_order = 1;
 
-        std::vector<float> results_vector;
-        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-        std::vector<float> gold{0.5, 0.6, 0.5, 1.3, 1.4, 1.0, 0.8, 0.8, 0.7};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.5, 0.6, 0.5, 1.3, 1.4, 1.0, 0.8, 0.8, 0.7};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(lppool_l2_norm_test)
+{
     // L2 norm test
-    {
-        migraphx::program p;
-        auto* mm    = p.get_main_module();
-        auto s      = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
-        auto op     = migraphx::op::pooling{migraphx::op::pooling_mode::lpnorm};
-        op.lengths  = {2};
-        op.padding  = {0};
-        op.stride   = {1};
-        op.lp_order = 2;
-
-        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    migraphx::program p;
+    auto* mm    = p.get_main_module();
+    auto s      = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op     = migraphx::op::pooling{migraphx::op::pooling_mode::lpnorm};
+    op.lengths  = {2};
+    op.padding  = {0};
+    op.stride   = {1};
+    op.lp_order = 2;
 
-        std::vector<float> results_vector;
-        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-        std::vector<float> gold{0.36055512754639896,
-                                0.447213595499958,
-                                0.4123105625617661,
-                                0.9433981132056605,
-                                1.0295630140987,
-                                0.9055385138137417,
-                                0.7071067811865475,
-                                0.7071067811865475,
-                                0.6082762530298219};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.36055512754639896,
+                            0.447213595499958,
+                            0.4123105625617661,
+                            0.9433981132056605,
+                            1.0295630140987,
+                            0.9055385138137417,
+                            0.7071067811865475,
+                            0.7071067811865475,
+                            0.6082762530298219};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(lppool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::float_type, {{1, 4, 0}, {3, 3, 0}, {4, 4, 0}}};
+    auto x   = mm->add_parameter("X", s);
+    mm->add_instruction(migraphx::make_op("pooling",
+                                          {{"mode", migraphx::op::pooling_mode::lpnorm},
+                                           {"lengths", {2}},
+                                           {"padding", {0}},
+                                           {"stride", {1}}}),
+                        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 4}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.36055512754639896,
+                            0.447213595499958,
+                            0.4123105625617661,
+                            0.9433981132056605,
+                            1.0295630140987,
+                            0.9055385138137417,
+                            0.7071067811865475,
+                            0.7071067811865475,
+                            0.6082762530298219};
+    EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
 TEST_CASE(lrn_test)
@@ -3908,122 +4065,147 @@ TEST_CASE(maxpool_test)
     EXPECT(migraphx::verify_range(results_vector, c));
 }
 
-TEST_CASE(maxpool_test_1D_3D)
+TEST_CASE(maxpool_rank3_test0)
 {
     // 1D case 1, input is 3D
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
-        op.lengths = {2};
-        op.padding = {0};
-        op.stride  = {1};
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {1, 3, 4}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths = {2};
+    op.padding = {0};
+    op.stride  = {1};
 
-        std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.3, 0.4, 0.4, 0.8, 0.9, 0.9, 0.7, 0.7, 0.6};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.3, 0.4, 0.4, 0.8, 0.9, 0.9, 0.7, 0.7, 0.6};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
 
+TEST_CASE(maxpool_rank3_test1)
+{
     // 1D case 2, input is 3D
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
-        op.lengths = {2};
-        op.padding = {0};
-        op.stride  = {2};
-
-        std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
-                                0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
-                                0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths = {2};
+    op.padding = {0};
+    op.stride  = {2};
 
-        std::vector<float> results_vector;
-        result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-        std::vector<float> gold{0.4975, -0.0405, -0.6186, 0.6022, 0.5493, -0.8039, 1.5001, -1.1603};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
+                            0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
+                            0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.4975, -0.0405, -0.6186, 0.6022, 0.5493, -0.8039, 1.5001, -1.1603};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(maxpool_rank3_ceil_test)
+{
     // 1D case 2, input is 3D, ceil mode
-    {
-        migraphx::program p;
-        auto* mm     = p.get_main_module();
-        auto s       = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
-        auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
-        op.lengths   = {2};
-        op.padding   = {0};
-        op.stride    = {2};
-        op.ceil_mode = true;
-
-        std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
-                                0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
-                                0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        p.compile(migraphx::ref::target{});
-        auto result = p.eval({}).back();
+    migraphx::program p;
+    auto* mm     = p.get_main_module();
+    auto s       = migraphx::shape{migraphx::shape::float_type, {2, 2, 5}};
+    auto op      = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths   = {2};
+    op.padding   = {0};
+    op.stride    = {2};
+    op.ceil_mode = true;
+
+    std::vector<float> data{0.4975, -0.1226, -0.0405, -0.2861, -0.1227, -0.6186, -0.9618,
+                            0.6022, -0.1912, 1.1925,  0.5493,  0.1692,  -0.8039, -1.0281,
+                            0.9907, 0.477,   1.5001,  -1.1603, -1.361,  1.2556};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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.4975,
-                                -0.0405,
-                                -0.1227,
-                                -0.6186,
-                                0.6022,
-                                1.1925,
-                                0.5493,
-                                -0.8039,
-                                0.9907,
-                                1.5001,
-                                -1.1603,
-                                1.2556};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.4975,
+                            -0.0405,
+                            -0.1227,
+                            -0.6186,
+                            0.6022,
+                            1.1925,
+                            0.5493,
+                            -0.8039,
+                            0.9907,
+                            1.5001,
+                            -1.1603,
+                            1.2556};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
 
+TEST_CASE(maxpool_rank5_test)
+{
     // 3D, input is 5D
-    {
-        migraphx::program p;
-        auto* mm   = p.get_main_module();
-        auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
-        auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
-        op.lengths = {2, 2, 2};
-        op.padding = {0, 0, 0};
-        op.stride  = {2, 2, 2};
-
-        std::vector<float> data{
-            -2.8029, 0.5861,  0.7015,  0.1297,  -1.44,   -1.9472, 0.7812,  2.408,   -0.3145,
-            0.3405,  -0.9146, 0.0624,  1.5064,  -0.8345, 1.7977,  1.8949,  1.0073,  -0.2102,
-            -0.042,  -0.7146, 0.6227,  -0.5263, -2.2598, 0.1713,  0.449,   0.5303,  -0.8622,
-            -0.5691, 0.907,   -0.0569, -1.5348, -0.4109, -0.1461, -0.5445, 0.4266,  0.2282,
-            1.3655,  -2.1519, 0.6068,  -0.2001, -0.4702, 0.3864,  1.7083,  0.9096,  0.4286,
-            -1.8866, 0.7034,  0.0293,  1.4587,  0.7672,  -2.8614, 0.8124,  -0.053,  1.0449,
-            0.845,   -0.0131, 0.1139,  -0.859,  -1.2681, -0.6337, -0.4644, 0.1938,  0.2889,
-            0.9035,  0.7118,  -0.5767, 0.4577,  -0.0549, 0.2237,  0.5756,  0.0677,  -0.0223,
-            -0.329,  0.2364,  2.7666,  -0.7417, -1.3196, -0.2655, 0.1698,  -0.1777, -0.9427,
-            2.6859,  -0.7501, 0.5175,  1.0029,  -2.6436, -0.4388, -1.2348, -0.1539, -0.6229,
-            -0.4136, 0.5085,  0.4136,  -0.6439, -1.1953, -0.406,  -0.0195, 0.1869,  -0.8664,
-            1.1364,  0.5041,  0.0647,  0.1941,  -1.0819, -0.4629, -0.5107, 0.3612,  -0.3583};
-        auto l0 = mm->add_literal(migraphx::literal{s, data});
-        mm->add_instruction(op, l0);
-        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{1.5064, 1.3655, 0.9035, 2.6859};
-        EXPECT(migraphx::verify_range(results_vector, gold));
-    }
+    migraphx::program p;
+    auto* mm   = p.get_main_module();
+    auto s     = migraphx::shape{migraphx::shape::float_type, {2, 2, 3, 3, 3}};
+    auto op    = migraphx::op::pooling{migraphx::op::pooling_mode::max};
+    op.lengths = {2, 2, 2};
+    op.padding = {0, 0, 0};
+    op.stride  = {2, 2, 2};
+
+    std::vector<float> data{
+        -2.8029, 0.5861,  0.7015,  0.1297,  -1.44,   -1.9472, 0.7812,  2.408,   -0.3145, 0.3405,
+        -0.9146, 0.0624,  1.5064,  -0.8345, 1.7977,  1.8949,  1.0073,  -0.2102, -0.042,  -0.7146,
+        0.6227,  -0.5263, -2.2598, 0.1713,  0.449,   0.5303,  -0.8622, -0.5691, 0.907,   -0.0569,
+        -1.5348, -0.4109, -0.1461, -0.5445, 0.4266,  0.2282,  1.3655,  -2.1519, 0.6068,  -0.2001,
+        -0.4702, 0.3864,  1.7083,  0.9096,  0.4286,  -1.8866, 0.7034,  0.0293,  1.4587,  0.7672,
+        -2.8614, 0.8124,  -0.053,  1.0449,  0.845,   -0.0131, 0.1139,  -0.859,  -1.2681, -0.6337,
+        -0.4644, 0.1938,  0.2889,  0.9035,  0.7118,  -0.5767, 0.4577,  -0.0549, 0.2237,  0.5756,
+        0.0677,  -0.0223, -0.329,  0.2364,  2.7666,  -0.7417, -1.3196, -0.2655, 0.1698,  -0.1777,
+        -0.9427, 2.6859,  -0.7501, 0.5175,  1.0029,  -2.6436, -0.4388, -1.2348, -0.1539, -0.6229,
+        -0.4136, 0.5085,  0.4136,  -0.6439, -1.1953, -0.406,  -0.0195, 0.1869,  -0.8664, 1.1364,
+        0.5041,  0.0647,  0.1941,  -1.0819, -0.4629, -0.5107, 0.3612,  -0.3583};
+    auto l0 = mm->add_literal(migraphx::literal{s, data});
+    mm->add_instruction(op, l0);
+    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{1.5064, 1.3655, 0.9035, 2.6859};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
+TEST_CASE(maxpool_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::float_type, {{1, 4, 0}, {3, 3, 0}, {4, 4, 0}}};
+    auto x   = mm->add_parameter("X", s);
+    mm->add_instruction(migraphx::make_op("pooling",
+                                          {{"mode", migraphx::op::pooling_mode::max},
+                                           {"lengths", {2}},
+                                           {"padding", {0}},
+                                           {"stride", {1}}}),
+                        x);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data{0.3, 0.2, 0.4, 0.1, 0.8, 0.5, 0.9, 0.1, 0.1, 0.7, 0.1, 0.6};
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 3, 4}};
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+    std::vector<float> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold{0.3, 0.4, 0.4, 0.8, 0.9, 0.9, 0.7, 0.7, 0.6};
+    EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
 TEST_CASE(min_test)
@@ -4090,7 +4272,7 @@ TEST_CASE(fmod_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(fmod_dynamic_test)
+TEST_CASE(fmod_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -4386,16 +4568,17 @@ TEST_CASE(neg_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
-TEST_CASE(neg_dynamic_test)
+TEST_CASE(neg_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s{migraphx::shape::float_type, {{2, 4, 0}, {3, 3, 0}}};
-    std::vector<float> a = {1.0f, 1.3f, -1.2f, 0.0f, -100.f, 200.f};
-    auto input           = mm->add_parameter("X", s);
-    auto ret             = mm->add_instruction(migraphx::make_op("neg"), input);
+    auto input = mm->add_parameter("X", s);
+    auto ret   = mm->add_instruction(migraphx::make_op("neg"), input);
     mm->add_return({ret});
     p.compile(migraphx::ref::target{});
+
+    std::vector<float> a = {1.0f, 1.3f, -1.2f, 0.0f, -100.f, 200.f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
@@ -4407,7 +4590,7 @@ TEST_CASE(neg_dynamic_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
-TEST_CASE(nms_dynamic_out_test)
+TEST_CASE(nms_dyn_out_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -4442,7 +4625,7 @@ TEST_CASE(nms_dynamic_out_test)
     EXPECT(migraphx::verify_range(result, gold));
 }
 
-TEST_CASE(nms_dynamic_batch_test)
+TEST_CASE(nms_dyn_batch_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -4488,7 +4671,7 @@ TEST_CASE(nms_dynamic_batch_test)
     EXPECT(migraphx::verify_range(result, gold));
 }
 
-TEST_CASE(nms_dynamic_boxes_test)
+TEST_CASE(nms_dyn_boxes_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -4531,7 +4714,7 @@ TEST_CASE(nms_dynamic_boxes_test)
     EXPECT(migraphx::verify_range(result, gold));
 }
 
-TEST_CASE(nms_dynamic_classes_test)
+TEST_CASE(nms_dyn_classes_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -4777,17 +4960,17 @@ TEST_CASE(not_test)
     }
 }
 
-TEST_CASE(not_dynamic_test)
+TEST_CASE(not_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{0, 8, 1, -32};
     mm->add_instruction(migraphx::make_op("not"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{0, 8, 1, -32};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {4}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -5511,17 +5694,17 @@ TEST_CASE(recip_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(recip_dynamic_test)
+TEST_CASE(recip_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-0.5f, 0.1f, 0.5f};
     mm->add_instruction(migraphx::make_op("recip"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-0.5f, 0.1f, 0.5f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -5819,17 +6002,17 @@ TEST_CASE(relu_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(relu_dynamic_test)
+TEST_CASE(relu_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1.f, 0.f, 1.f};
     mm->add_instruction(migraphx::make_op("relu"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1.f, 0.f, 1.f};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -6124,17 +6307,17 @@ TEST_CASE(round_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(round_dynamic_test)
+TEST_CASE(round_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{4, 10, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0};
     mm->add_instruction(migraphx::make_op("round"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{1.1, 1.5, 1.6, -1.1, -1.5, -1.6, 0.0, 2.0, -2.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {9}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -6160,17 +6343,17 @@ TEST_CASE(rsqrt_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(rsqrt_dynamic_test)
+TEST_CASE(rsqrt_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{4.0, 16.0, 64.0};
     mm->add_instruction(migraphx::make_op("rsqrt"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{4.0, 16.0, 64.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -6729,16 +6912,16 @@ TEST_CASE(sigmoid_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(sigmoid_dynamic_test)
+TEST_CASE(sigmoid_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s{migraphx::shape::float_type, {{2, 4, 0}, {2, 2, 0}}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{-1, 2, -3, 4};
     mm->add_instruction(migraphx::make_op("sigmoid"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{-1, 2, -3, 4};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 2}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -6765,17 +6948,17 @@ TEST_CASE(sign_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(sign_dynamic_test)
+TEST_CASE(sign_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
     auto input = mm->add_parameter("X", s);
-    std::vector<float> input_data{1.02481645, 0.85643062, -0.03404123, -0.92791926, 0.0};
     mm->add_instruction(migraphx::make_op("sign"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data{1.02481645, 0.85643062, -0.03404123, -0.92791926, 0.0};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {5}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -6804,17 +6987,17 @@ TEST_CASE(sin_test)
     EXPECT(migraphx::verify_range(results_vector, gold));
 }
 
-TEST_CASE(sin_dynamic_test)
+TEST_CASE(sin_dyn_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape::dynamic_dimension dd{3, 8, 0};
     migraphx::shape s{migraphx::shape::float_type, {dd}};
-    auto input                    = mm->add_parameter("X", s);
-    std::vector<float> input_data = {-1, 0, 1};
+    auto input = mm->add_parameter("X", s);
     mm->add_instruction(migraphx::make_op("sin"), input);
     p.compile(migraphx::ref::target{});
 
+    std::vector<float> input_data = {-1, 0, 1};
     migraphx::parameter_map params0;
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {3}};
     params0["X"] = migraphx::argument(input_fixed_shape0, input_data.data());
@@ -7336,11 +7519,6 @@ TEST_CASE(transpose_test)
         mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), l);
         p.compile(migraphx::ref::target{});
         auto result = p.eval({}).back();
-
-        result.visit([&](auto output) {
-            std::vector<size_t> new_lens = {1, 3, 2, 2};
-            EXPECT(bool{output.get_shape().lens() == new_lens});
-        });
     }
     {
         migraphx::program p;
@@ -7360,6 +7538,32 @@ TEST_CASE(transpose_test)
     }
 }
 
+TEST_CASE(transpose_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s{migraphx::shape::float_type, {{1, 4, 0}, {2, 2, 0}, {2, 2, 0}, {3, 3, 0}}};
+    auto l                    = mm->add_parameter("X", s);
+    std::vector<int64_t> perm = {0, 3, 1, 2};
+    mm->add_instruction(migraphx::make_op("transpose", {{"permutation", perm}}), l);
+    p.compile(migraphx::ref::target{});
+
+    std::vector<float> data(12);
+    std::iota(data.begin(), data.end(), 0);
+    migraphx::parameter_map params;
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {1, 2, 2, 3}};
+    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    auto result = p.eval(params).back();
+
+    std::vector<size_t> new_lens = {1, 3, 2, 2};
+    EXPECT(result.get_shape().lens() == new_lens);
+
+    std::vector<float> results_vector(12);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11};
+    EXPECT(migraphx::verify_range(results_vector, gold));
+}
+
 TEST_CASE(unsqueeze_test)
 {
     {