Merge branch 'develop' into dyn_gemm

.github/workflows/performance.yaml

@@ -5,14 +5,14 @@ on:
     branches: [develop]
     types: [opened, synchronize, closed]
   schedule:
-    - cron: "0 5 * * 1-6"
+    - cron: "0 6 * * 1-6"
 
   workflow_dispatch:
     inputs:
       rocm_release:
         description: ROCm Version
         required: true
-        default: '5.2'
+        default: '5.3'
       performance_reports_repo:
         description: Result repository
         required: true
@@ -30,9 +30,9 @@ concurrency: "perftest-${{ github.head_ref ||  github.base_ref || 'schedule' }}"
 
 jobs:
   release:
-    uses: rocmsoftwareplatform/migraphx-benchmark/.github/workflows/perf-test.yml@main
+    uses: ROCmSoftwarePlatform/migraphx-benchmark/.github/workflows/perf-test.yml@main
     with:
-      rocm_release: ${{ github.event.inputs.rocm_release || '5.2' }}
+      rocm_release: ${{ github.event.inputs.rocm_release || '5.3' }}
       result_number: ${{ github.event.inputs.result_number || '10' }}
       flags: ${{ github.event.inputs.flags || '-s' }} 
       performance_reports_repo: ${{ github.event.inputs.performance_reports_repo || 'ROCmSoftwarePlatform/migraphx-reports' }} 

examples/migraphx/migraphx_driver/README.md

@@ -29,6 +29,7 @@ See below for a comprehensive list of commands and option arguments, as well as
 | --tf | Load file as a tensorflow graph |
 | --migraphx | Load file as a migraphx graph |
 | --migraphx-json | Load file as a migraphx JSON graph |
+| --batch | Set batch size for the model | 
 | --nhwc | Treat tensorflow format as nhwc | 
 | --nchw | Treat tensorflow format as nchw |
 | --skip-unknown-operators | Skip unknown operators when parsing and continue to parse |

src/eliminate_contiguous.cpp

@@ -42,6 +42,13 @@ static bool try_compute_shape(instruction_ref ins,
     try
     {
         shape new_shape = ins->get_operator().compute_shape(inputs, mods);
+
+        // Cannot tell if a dynamic shape will need to be made contiguous
+        if(new_shape.dynamic())
+        {
+            return false;
+        }
+
         // If the output shape is a standard shape, no need to try its output
         if(new_shape.standard())
         {
@@ -133,14 +140,20 @@ static void remove_contiguous(const std::string& op_name, module& m, F f)
         }
     }
 
-    // Perform evaluations in parallel
+    // Perform static contiguous evaluations in parallel
     std::vector<argument> literals(const_instructions.size());
     par_for(const_instructions.size(), 1, [&](const auto i) {
-        auto c      = op::contiguous{};
-        auto prev   = const_instructions[i]->inputs().front();
-        literals[i] = c.compute(c.compute_shape({prev->get_shape()}), {prev->eval()});
+        auto c    = op::contiguous{};
+        auto prev = const_instructions[i]->inputs().front();
+        // compute the output contiguous shape from the previous instruction shape
+        shape computed_shape                   = c.compute_shape({prev->get_shape()});
+        const std::vector<argument>& prev_eval = {prev->eval()};
+        // prev_eval should not be used in make_compute_output_shape() as computed_shape is static
+        auto co_shape = make_compute_output_shape(pack(c, computed_shape, prev_eval));
+        literals[i]   = c.compute(co_shape, prev_eval);
     });
 
+    // Replace static contiguous operations with a literal
     for(size_t i = 0; i < const_instructions.size(); i++)
     {
         auto l = m.add_literal(literals[i].get_shape(), literals[i].data());

src/fuse_pointwise.cpp

@@ -45,7 +45,16 @@ static literal get_scalar(instruction_ref ins)
         return {};
     auto e = ins->eval();
     literal r{};
-    e.visit_at([&](auto x) { r = literal{x}; });
+    // needed for bool as visit_at invokes as() which promotes bool to int8
+    // Without this we'll break type checks for logical ops that are fused.
+    if(e.get_shape().type() == shape::bool_type)
+    {
+        r = literal{e.at<bool>()};
+    }
+    else
+    {
+        e.visit_at([&](auto x) { r = literal{x}; });
+    }
     return r;
 }
 

src/include/migraphx/op/contiguous.hpp

@@ -28,6 +28,7 @@
 #include <migraphx/argument.hpp>
 #include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/dyn_output.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -42,19 +43,27 @@ namespace op {
 struct contiguous
 {
     std::string name() const { return "contiguous"; }
+
     shape compute_shape(std::vector<shape> inputs) const
     {
-        check_shapes{inputs, *this}.has(1);
-        if(inputs.front().standard())
-            return inputs.front();
-        auto lens = inputs.at(0).lens();
-        auto t    = inputs.at(0).type();
-        return {t, lens};
+        check_shapes{inputs, *this, true}.has(1);
+        auto s0 = inputs.front();
+        if(s0.dynamic() or s0.standard())
+        {
+            return s0;
+        }
+        else
+        {
+            const auto& lens = s0.lens();
+            auto t           = s0.type();
+            return {t, lens};
+        }
     }
-    argument compute(const shape& output_shape, std::vector<argument> args) const
+
+    argument compute(const dyn_output& dyn_out, std::vector<argument> args) const
     {
-        assert(output_shape.standard());
-        argument result{output_shape};
+        assert(dyn_out.computed_shape.standard());
+        argument result{dyn_out.computed_shape};
         visit_all(result, args[0])([&](auto output, auto input) {
             shape_for_each(output.get_shape(), [&](const auto& idx) {
                 output(idx.begin(), idx.end()) = input(idx.begin(), idx.end());

src/include/migraphx/op/transpose.hpp

@@ -29,6 +29,7 @@
 #include <migraphx/config.hpp>
 #include <migraphx/value.hpp>
 #include <migraphx/op/normalize_attribute.hpp>
+#include <migraphx/dyn_output.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -45,17 +46,15 @@ struct transpose
     }
 
     std::string name() const { return "transpose"; }
+
     shape compute_shape(std::vector<shape> inputs) const
     {
-        check_shapes{inputs, *this}.has(1);
-        auto input         = inputs.at(0);
-        auto input_lens    = input.lens();
-        auto input_strides = input.strides();
-        auto t             = input.type();
+        check_shapes{inputs, *this, true}.has(1);
+        auto input = inputs.at(0);
 
-        if(dims.size() != input_lens.size())
+        if(dims.size() != input.ndim())
         {
-            MIGRAPHX_THROW("Permutation has wrong number of axes");
+            MIGRAPHX_THROW("TRANSPOSE: Permutation has wrong number of axes");
         }
         std::vector<int64_t> axes(dims.size());
         std::iota(axes.begin(), axes.end(), 0);
@@ -63,19 +62,36 @@ struct transpose
         {
             MIGRAPHX_THROW("TRANSPOSE: Invalid permutation");
         }
-        std::vector<size_t> output_lens(input_lens.size());
-        std::vector<size_t> output_strides(input_lens.size());
-        for(std::size_t i = 0; i < output_lens.size(); i++)
+
+        if(input.dynamic())
         {
-            output_lens[i]    = input_lens[dims[i]];
-            output_strides[i] = input_strides[dims[i]];
+            std::vector<shape::dynamic_dimension> output_dyn_dims(input.ndim());
+            std::transform(dims.cbegin(), dims.cend(), output_dyn_dims.begin(), [&](auto dim) {
+                return input.dyn_dims()[dim];
+            });
+            return {input.type(), output_dyn_dims};
+        }
+        else
+        {
+            auto input_lens    = input.lens();
+            auto input_strides = input.strides();
+
+            std::vector<size_t> output_lens(input.ndim());
+            std::vector<size_t> output_strides(input.ndim());
+            for(std::size_t i = 0; i < input.ndim(); i++)
+            {
+                output_lens[i]    = input_lens[dims[i]];
+                output_strides[i] = input_strides[dims[i]];
+            }
+            return {input.type(), output_lens, output_strides};
         }
-        return {t, output_lens, output_strides};
     }
-    argument compute(shape output_shape, std::vector<argument> args) const
+
+    argument compute(const dyn_output& dyn_out, std::vector<argument> args) const
     {
-        return args[0].reshape(output_shape);
+        return args[0].reshape(dyn_out.computed_shape);
     }
+
     std::ptrdiff_t output_alias(const std::vector<shape>&) const { return 0; }
 };
 

src/onnx/parse_transpose.cpp

@@ -47,7 +47,7 @@ struct parse_transpose : op_parser<parse_transpose>
         }
 
         // if perm is empty, use the default value
-        auto n_dim = args.front()->get_shape().lens().size();
+        auto n_dim = args.front()->get_shape().ndim();
         if(perm.empty())
         {
             perm.resize(n_dim);

src/targets/gpu/CMakeLists.txt

@@ -233,11 +233,14 @@ get_target_property(MIOPEN_LOCATION MIOpen LOCATION)
 check_library_exists(MIOpen "miopenHiddenSetConvolutionFindMode" "${MIOPEN_LOCATION}" HAS_FIND_MODE_API)
 check_library_exists(MIOpen "miopenFindSolutions" "${MIOPEN_LOCATION}" HAS_FIND_2_API)
 
-if(HAS_FIND_2_API) 
+# TODO: Set default to HAS_FIND_2_API
+set(MIGRAPHX_USE_FIND_2_API OFF CACHE BOOL "")
+
+if(MIGRAPHX_USE_FIND_2_API) 
     target_compile_definitions(migraphx_gpu PUBLIC -DMIGRAPHX_HAS_FIND_2_API)
     message(STATUS "MIGraphx is using Find-2.0 API of MIOpen")
 else()
-    message(STATUS "MIOpen does not have Find-2.0 API")
+    message(STATUS "MIGraphx is using legacy Find API in MIOpen")
 endif()
 
 if(HAS_FIND_MODE_API)

test/fuse_pointwise.cpp

@@ -272,6 +272,35 @@ TEST_CASE(contiguous_input)
     EXPECT(p1 == p2);
 }
 
+TEST_CASE(contiguous_boolean_input)
+{
+
+    migraphx::shape s{migraphx::shape::bool_type, {2, 3}};
+    migraphx::shape s_lit{migraphx::shape::bool_type, {1}, {0}};
+    migraphx::program p1;
+    {
+        auto* mm = p1.get_main_module();
+        auto x   = mm->add_parameter("x", s);
+        auto one = mm->add_literal(migraphx::literal(s_lit, {1.0}));
+        auto yb =
+            mm->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", s.lens()}}), one);
+        auto y    = mm->add_instruction(migraphx::make_op("contiguous"), yb);
+        auto xor1 = mm->add_instruction(migraphx::make_op("logical_xor"), x, y);
+        mm->add_return({xor1});
+    }
+    run_pass(p1);
+    migraphx::program p2;
+    {
+        auto* mm  = p2.get_main_module();
+        auto x    = mm->add_parameter("x", s);
+        auto xor1 = add_pointwise(p2, "main:pointwise0", {x}, [=](auto* pm, const auto& inputs) {
+            auto y = pm->add_literal(migraphx::literal(s_lit, {1}));
+            return pm->add_instruction(migraphx::make_op("logical_xor"), inputs[0], y);
+        });
+        mm->add_return({xor1});
+    }
+}
+
 TEST_CASE(all_scalar_input)
 {
     migraphx::shape s{migraphx::shape::float_type};

test/onnx/gen_onnx.py

@@ -6277,6 +6277,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

@@ -5973,6 +5973,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

@@ -365,6 +365,12 @@ TEST_CASE(contiguous_shape)
     expect_shape(single, migraphx::make_op("contiguous"), single);
 }
 
+TEST_CASE(contiguous_dyn_shape)
+{
+    migraphx::shape s0{migraphx::shape::float_type, {{1, 4, 0}, {2, 2, 2}}};
+    expect_shape(s0, migraphx::make_op("contiguous"), s0);
+}
+
 TEST_CASE(contiguous_shape_scalar)
 {
     migraphx::shape output{migraphx::shape::float_type};
@@ -2273,6 +2279,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());
@@ -758,17 +759,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());
@@ -925,6 +926,33 @@ TEST_CASE(contiguous_test)
     EXPECT(migraphx::verify_range(results_vector, data));
 }
 
+TEST_CASE(contiguous_dyn_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape dyn_shape{migraphx::shape::float_type,
+                              {{1, 1, 0}, {2, 6, 0}, {2, 2, 0}, {2, 2, 0}}};
+    auto input = mm->add_parameter("X", dyn_shape);
+    mm->add_instruction(migraphx::make_op("contiguous"), input);
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape static_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);
+    migraphx::parameter_map params;
+    params["X"] = migraphx::argument(static_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(conv_dynamic_batch_test)
 {
     migraphx::program p;
@@ -1042,7 +1070,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();
@@ -1131,7 +1159,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();
@@ -1208,7 +1236,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();
@@ -1279,7 +1307,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();
@@ -1353,7 +1381,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();
@@ -1698,17 +1726,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());
@@ -1739,17 +1767,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());
@@ -1972,18 +2000,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());
@@ -2090,17 +2118,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());
@@ -2131,17 +2159,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());
@@ -2172,17 +2200,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());
@@ -2776,16 +2804,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());
@@ -3022,17 +3050,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());
@@ -3393,17 +3421,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());
@@ -4063,7 +4091,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();
@@ -4359,16 +4387,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());
@@ -4380,7 +4409,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();
@@ -4415,7 +4444,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();
@@ -4461,7 +4490,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();
@@ -4504,7 +4533,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();
@@ -4750,17 +4779,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());
@@ -5484,17 +5513,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());
@@ -5792,17 +5821,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());
@@ -6097,17 +6126,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());
@@ -6133,17 +6162,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());
@@ -6702,16 +6731,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());
@@ -6738,17 +6767,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());
@@ -6777,17 +6806,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());
@@ -7309,11 +7338,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;
@@ -7333,6 +7357,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)
 {
     {