Merge branch 'develop' into enable_navi_32_ci

test/py/test_numpy.py

 #####################################################################################
 # The MIT License (MIT)
 #
-# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -21,11 +21,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #####################################################################################
-import migraphx, sys
-try:
-    import numpy as np
-except:
-    sys.exit()
+import migraphx
+import numpy as np
 
 
 def test_add_op():

test/ref/argmax.cpp

@@ -147,3 +147,37 @@ TEST_CASE(argmax_test_nonstd_shape)
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }
+
+TEST_CASE(argmax_test_select_last_index_0)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {2.0305, -1.853, 2.0305, -1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {2, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmax", {{"axis", 1}, {"select_last_index", true}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}
+
+TEST_CASE(argmax_test_select_last_index_1)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {2.0305, -1.853, 2.0305, -1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {0, 1};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmax", {{"axis", 1}, {"select_last_index", false}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}

test/ref/argmin.cpp

@@ -125,3 +125,37 @@ TEST_CASE(argmin_test_nonstd_shape)
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }
+
+TEST_CASE(argmin_test_select_last_index_0)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {-2.0305, 0.853, -2.0305, 1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {2, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmin", {{"axis", 1}, {"select_last_index", true}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}
+
+TEST_CASE(argmin_test_select_last_index_1)
+{
+    migraphx::program p;
+    auto* mm                      = p.get_main_module();
+    std::vector<float> data       = {-2.0305, 0.853, -2.0305, 1.5706, 0.7545, 0.7545};
+    std::vector<int64_t> res_gold = {0, 1};
+    migraphx::shape data_shape{migraphx::shape::float_type, {2, 3}};
+    auto dl = mm->add_literal(migraphx::literal{data_shape, data});
+    mm->add_instruction(migraphx::make_op("argmin", {{"axis", 1}, {"select_last_index", false}}),
+                        dl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<int64_t> result_vec;
+    result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
+}

test/ref/reshape.cpp

@@ -153,7 +153,7 @@ TEST_CASE(reshape_test2)
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
-TEST_CASE(reshape_dyn_test)
+TEST_CASE(reshape_dyn_1in_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
@@ -173,3 +173,79 @@ TEST_CASE(reshape_dyn_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
+
+TEST_CASE(reshape_2in_test0)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{1, 4}, {6, 6}, {4, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    migraphx::shape input_fixed_shape{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 4, 1}};
+    params["X"] = migraphx::argument(input_fixed_shape, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    auto result = p.eval(params).back();
+    EXPECT(result.get_shape() == output_fixed_shape);
+    std::vector<float> results_vector{};
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(reshape_2in_test1)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{2, 4}, {6, 6}, {2, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 4, 1}};
+    params["X"] = migraphx::argument(s_in, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    auto result = p.eval(params).back();
+    EXPECT(result.get_shape() == output_fixed_shape);
+    std::vector<float> results_vector{};
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+}
+
+TEST_CASE(reshape_2in_elements_runtime_error)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape s_in{migraphx::shape::float_type, {2, 24, 1, 1}};
+    migraphx::shape s_out{migraphx::shape::float_type, {{2, 4}, {6, 6}, {2, 4}, {1, 1}}};
+    auto input         = mm->add_parameter("X", s_in);
+    auto output_buffer = mm->add_parameter("Y", s_out);
+    mm->add_instruction(migraphx::make_op("reshape"), input, output_buffer);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3.);
+    std::vector<float> buffer(48);
+    std::iota(buffer.begin(), buffer.end(), 0.);
+    migraphx::parameter_map params;
+    // elements do not match up
+    migraphx::shape output_fixed_shape{migraphx::shape::float_type, {2, 6, 2, 1}};
+    params["X"] = migraphx::argument(s_in, gold.data());
+    params["Y"] = migraphx::argument(output_fixed_shape, buffer.data());
+    EXPECT(test::throws([&] { std::ignore = p.eval(params).back(); }));
+}

test/replace_allocate.cpp

@@ -54,7 +54,7 @@ struct allocate_no_out : migraphx::auto_register_op<allocate_no_out>
                                const migraphx::shape& output_shape,
                                const std::vector<migraphx::argument>&) const
     {
-        return {output_shape};
+        return migraphx::argument{output_shape};
     }
 };
 
@@ -78,7 +78,7 @@ struct allocate_with_out : migraphx::auto_register_op<allocate_with_out>
                                const migraphx::shape& output_shape,
                                const std::vector<migraphx::argument>&) const
     {
-        return {output_shape};
+        return migraphx::argument{output_shape};
     }
 };
 

test/rewrite_quantization_test.cpp

@@ -31,10 +31,13 @@
 #include <migraphx/ranges.hpp>
 #include <test.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/env.hpp>
 
 #include <migraphx/serialize.hpp>
 #include <migraphx/pass_manager.hpp>
 
+MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_ENABLE_CK_WORKAROUNDS);
+
 bool is_quantizelinear(migraphx::instruction& ins) { return ins.name() == "quantizelinear"; }
 bool is_dequantizelinear(migraphx::instruction& ins) { return ins.name() == "dequantizelinear"; }
 bool is_clip_scalar(migraphx::instruction& ins)
@@ -82,7 +85,11 @@ TEST_CASE(quantizelinear)
     EXPECT(any_of(*p1.get_main_module(), &is_quantizelinear));
     EXPECT(none_of(*p2.get_main_module(), &is_quantizelinear));
     // ensure clip literals created in quantized program are scalar
-    EXPECT(any_of(*p2.get_main_module(), &is_clip_scalar));
+    // unless CK workarounds are enabled
+    if(migraphx::enabled(MIGRAPHX_ENABLE_CK_WORKAROUNDS{}))
+        EXPECT(none_of(*p2.get_main_module(), &is_clip_scalar));
+    else
+        EXPECT(any_of(*p2.get_main_module(), &is_clip_scalar));
 }
 
 TEST_CASE(dequantizelinear)

test/simplify_algebra_test.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -669,6 +669,23 @@ TEST_CASE(simplify_inner_broadcast_different_broadcasts)
     EXPECT(m1 == m2);
 }
 
+TEST_CASE(simplify_inner_broadcast_no_common_axis)
+{
+    auto b = migraphx::make_op("multibroadcast", {{"out_lens", {1, 5, 10}}});
+    migraphx::module m1;
+    {
+        auto x   = m1.add_parameter("x", {migraphx::shape::int32_type, {5, 10}});
+        auto y   = m1.add_parameter("y", {migraphx::shape::int32_type, {1, 5, 1}});
+        auto xb  = m1.add_instruction(b, x);
+        auto yb  = m1.add_instruction(b, y);
+        auto sum = m1.add_instruction(migraphx::make_op("add"), xb, yb);
+        m1.add_instruction(pass_op{}, sum);
+    }
+    migraphx::module m2 = m1;
+    run_pass(m1);
+    EXPECT(m1 == m2);
+}
+
 TEST_CASE(simplify_add_conv1)
 {
     migraphx::module m;

test/simplify_reshapes_test.cpp

@@ -67,6 +67,57 @@ migraphx::module make_concat_multibroadcast(const std::vector<size_t>& in_lens,
     return m;
 }
 
+TEST_CASE(broadcast_transpose)
+{
+    migraphx::module m1;
+    {
+        auto l = m1.add_parameter("x", {migraphx::shape::float_type, {5}});
+        auto mb =
+            m1.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 5}}}), l);
+        auto t1 =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {2, 0, 1}}}), mb);
+        m1.add_return({t1});
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto l  = m2.add_parameter("x", {migraphx::shape::float_type, {5}});
+        auto u1 = m2.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0, 1}}}), l);
+        auto t1 =
+            m2.add_instruction(migraphx::make_op("transpose", {{"permutation", {2, 0, 1}}}), u1);
+        auto mb =
+            m2.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {5, 2, 3}}}), t1);
+        m2.add_return({mb});
+    }
+
+    EXPECT(m1 == m2);
+}
+
+TEST_CASE(broadcast_transpose_opt)
+{
+    // extra transpose from transformation will be optimized out
+    migraphx::module m1;
+    {
+        auto l = m1.add_parameter("x", {migraphx::shape::float_type, {5}});
+        auto mb =
+            m1.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 3, 5}}}), l);
+        auto t1 =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0, 2}}}), mb);
+        m1.add_return({t1});
+    }
+    run_pass(m1);
+    migraphx::module m2;
+    {
+        auto l  = m2.add_parameter("x", {migraphx::shape::float_type, {5}});
+        auto u1 = m2.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0, 1}}}), l);
+        auto mb =
+            m2.add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {3, 2, 5}}}), u1);
+        m2.add_return({mb});
+    }
+
+    EXPECT(m1 == m2);
+}
+
 TEST_CASE(broadcast_transpose_scalar)
 {
     migraphx::module m1;

test/verify/ck_gemm_softmax_gemm.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct ck_gemm_softmax_gemm : verify_program<ck_gemm_softmax_gemm>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape m1_shape{migraphx::shape::half_type, {1, 12, 256, 256}};
+        migraphx::shape m2_shape{migraphx::shape::half_type, {1, 12, 256, 256}};
+        auto m2_elements = m2_shape.elements();
+        auto a           = mm->add_parameter("1", m1_shape);
+        auto b           = mm->add_parameter("2", m1_shape);
+        auto b1          = mm->add_parameter("3", m1_shape);
+        std::vector<float> eights(m2_elements, 0.125);
+        auto eight = mm->add_literal(migraphx::literal{m2_shape, eights});
+        std::vector<float> zeros(m2_elements, 0);
+        auto zero = mm->add_literal(migraphx::literal{m2_shape, zeros});
+
+        b = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), b);
+        auto gemm1   = mm->add_instruction(migraphx::make_op("dot"), a, b);
+        auto scale   = mm->add_instruction(migraphx::make_op("mul"), gemm1, eight);
+        auto bias    = mm->add_instruction(migraphx::make_op("add"), scale, zero);
+        auto softmax = mm->add_instruction(migraphx::make_op("softmax", {{"axis", -1}}), bias);
+        mm->add_instruction(migraphx::make_op("dot"), softmax, b1);
+
+        return p;
+    }
+};

test/verify/run_verify.cpp

@@ -44,8 +44,7 @@ MIGRAPHX_DECLARE_ENV_VAR(MIGRAPHX_DUMP_TEST)
 
 // An improved async, that doesn't block
 template <class Function>
-std::future<typename std::result_of<Function()>::type> detach_async(Function&& f,
-                                                                    bool parallel = true)
+std::future<std::invoke_result_t<Function>> detach_async(Function&& f, bool parallel = true)
 {
     if(parallel)
     {

test/verify/test_arg_ops.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,8 +29,8 @@
 #include <migraphx/op/argmax.hpp>
 #include <migraphx/op/argmin.hpp>
 
-template <class T, int Axis, int NonStdShape>
-struct test_arg_ops : verify_program<test_arg_ops<T, Axis, NonStdShape>>
+template <class T, int Axis, bool LastIndex, int NonStdShape>
+struct test_arg_ops : verify_program<test_arg_ops<T, Axis, LastIndex, NonStdShape>>
 {
     migraphx::program create_program() const
     {
@@ -54,63 +54,111 @@ struct test_arg_ops : verify_program<test_arg_ops<T, Axis, NonStdShape>>
             break;
         default: break;
         }
-        mm->add_instruction(T{Axis}, param);
+        mm->add_instruction(T{Axis, LastIndex}, param);
         return p;
     }
 };
 // transpose argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 0>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 0>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 0>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 0>;
 // transpose argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 0>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 0>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 0>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 0>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 0>;
 // broadcast argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 1>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 1>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 1>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 1>;
 // broadcast argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 1>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 1>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 1>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 1>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 1>;
 // slice argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 2>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 2>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 2>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 2>;
 // slice argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 2>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 2>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 2>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 2>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 2>;
 // default case, standard shape argmax tests
-template struct test_arg_ops<migraphx::op::argmax, 0, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 1, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 2, 3>;
-template struct test_arg_ops<migraphx::op::argmax, 3, 3>;
-template struct test_arg_ops<migraphx::op::argmax, -1, 3>;
-template struct test_arg_ops<migraphx::op::argmax, -2, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 0, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 0, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 2, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, 3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmax, -2, false, 3>;
 // default case, standard shape argmin tests
-template struct test_arg_ops<migraphx::op::argmin, 0, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 1, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 2, 3>;
-template struct test_arg_ops<migraphx::op::argmin, 3, 3>;
-template struct test_arg_ops<migraphx::op::argmin, -3, 3>;
-template struct test_arg_ops<migraphx::op::argmin, -4, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 0, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 0, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 1, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 1, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 2, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 2, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, 3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -3, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -3, false, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -4, true, 3>;
+template struct test_arg_ops<migraphx::op::argmin, -4, false, 3>;

test/verify/test_flatten_dot_relu.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_flatten_dot_relu : verify_program<test_flatten_dot_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto a =
+            mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 2, 3, 3, 5}});
+        a = mm->add_instruction(migraphx::make_op("flatten", {{"axis", 3}}), a);
+        auto b =
+            mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 5, 3, 3, 1}});
+        b        = mm->add_instruction(migraphx::make_op("flatten", {{"axis", 3}}), b);
+        auto dot = mm->add_instruction(migraphx::make_op("dot"), a, b);
+        mm->add_instruction(migraphx::make_op("relu"), dot);
+        return p;
+    }
+};

test/verify/test_scatter_nonstandard_shape.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_scatter_nonstandard_shape : verify_program<test_scatter_nonstandard_shape>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape sd{migraphx::shape::float_type, {3, 1, 3}, {1, 3, 2}};
+        migraphx::shape si{migraphx::shape::int32_type, {2, 1, 3}, {1, 3, 2}};
+        std::vector<int> vi = {1, 0, 2, 0, 2, 1};
+        migraphx::shape su{migraphx::shape::float_type, {2, 1, 3}, {1, 2, 3}};
+
+        auto pd = mm->add_parameter("data", sd);
+        auto li = mm->add_literal(migraphx::literal{si, vi});
+        auto pu = mm->add_parameter("update", su);
+        auto r = mm->add_instruction(migraphx::make_op("scatter_none", {{"axis", -1}}), pd, li, pu);
+        mm->add_return({r});
+
+        return p;
+    }
+};

test/verify/test_shrink.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/op/common.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/common.hpp>
+
+template <migraphx::shape::type_t T>
+struct test_shrink : verify_program<test_shrink<T>>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        float bias  = 1.5;
+        float lambd = 1.5;
+        auto* mm    = p.get_main_module();
+        migraphx::shape is{T, {2, 3}};
+        std::vector<float> data;
+        migraphx::shape::visit(T, [&](auto as) {
+            as.is_signed() ? data.assign({-3.0, -2.0, -1.0, 0.0, 1.0, 2.0})
+                           : data.assign({3.0, 2.0, 1.0, 0.0, 1.0, 2.0});
+        });
+        auto x        = mm->add_literal(migraphx::literal{is, data});
+        auto lit_bias = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {bias}});
+        auto lit_neg_lambd =
+            mm->add_literal(migraphx::literal{migraphx::shape::float_type, {-lambd}});
+        auto lit_lambd = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {lambd}});
+
+        auto x_plus_bias = add_common_op(*mm, migraphx::make_op("add"), {x, lit_bias});
+        auto x_min_bias  = add_common_op(*mm, migraphx::make_op("sub"), {x, lit_bias});
+
+        auto cond1   = add_common_op(*mm, migraphx::make_op("less"), {x, lit_neg_lambd});
+        auto cond2_a = add_common_op(*mm, migraphx::make_op("not"), {cond1});
+        auto cond2_b = add_common_op(*mm, migraphx::make_op("greater"), {x, lit_lambd});
+        auto cond2   = add_common_op(*mm, migraphx::make_op("logical_and"), {cond2_a, cond2_b});
+
+        auto mul1 = mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), cond1);
+        auto mul2 = mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), cond2);
+
+        auto first  = add_common_op(*mm, migraphx::make_op("mul"), {mul1, x_plus_bias});
+        auto second = add_common_op(*mm, migraphx::make_op("mul"), {mul2, x_min_bias});
+        auto ret    = add_common_op(*mm, migraphx::make_op("add"), {first, second});
+        if(ret->get_shape().type() != T)
+        {
+            mm->add_instruction(migraphx::make_op("convert", {{"target_type", T}}), ret);
+        }
+        return p;
+    }
+};
+
+template struct test_shrink<migraphx::shape::double_type>;
+template struct test_shrink<migraphx::shape::float_type>;
+template struct test_shrink<migraphx::shape::half_type>;
+template struct test_shrink<migraphx::shape::int64_type>;
+template struct test_shrink<migraphx::shape::int32_type>;
+template struct test_shrink<migraphx::shape::int16_type>;
+template struct test_shrink<migraphx::shape::int8_type>;
+template struct test_shrink<migraphx::shape::uint64_type>;
+template struct test_shrink<migraphx::shape::uint32_type>;
+template struct test_shrink<migraphx::shape::uint16_type>;
+template struct test_shrink<migraphx::shape::uint8_type>;

test/verify/test_squeeze_conv_relu.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_squeeze_conv_relu : verify_program<test_squeeze_conv_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto input =
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 1, 3, 3}});
+        input = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), input);
+        auto weights =
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto conv = mm->add_instruction(migraphx::make_op("convolution"), input, weights);
+        mm->add_instruction(migraphx::make_op("relu"), conv);
+        return p;
+    }
+};

test/verify/test_unsqueeze_conv_relu.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+struct test_unsqueeze_conv_relu : verify_program<test_unsqueeze_conv_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto input =
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 3, 3, 3}});
+        auto weights =
+            mm->add_parameter("w", migraphx::shape{migraphx::shape::float_type, {3, 3, 3}});
+        weights   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {0}}}), weights);
+        auto conv = mm->add_instruction(migraphx::make_op("convolution"), input, weights);
+        mm->add_instruction(migraphx::make_op("relu"), conv);
+        return p;
+    }
+};

tools/CMakeLists.txt

@@ -22,4 +22,16 @@
 # THE SOFTWARE.
 #####################################################################################
 
-add_custom_target(generate bash ${CMAKE_CURRENT_SOURCE_DIR}/generate.sh)
+find_package(Python 3 COMPONENTS Interpreter)
+if(NOT Python_EXECUTABLE)
+    message(WARNING "Python 3 interpreter not found - skipping 'generate' target!")
+    return()
+endif()
+
+find_program(CLANG_FORMAT clang-format PATHS /opt/rocm/llvm ENV HIP_PATH PATH_SUFFIXES bin)
+if(NOT CLANG_FORMAT)
+    message(WARNING "clang-format not found - skipping 'generate' target!")
+    return()
+endif()
+
+add_custom_target(generate ${Python_EXECUTABLE} generate.py -f ${CLANG_FORMAT} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

tools/accuracy/accuracy_checker.py

@@ -82,6 +82,27 @@ def parse_args():
                         default=False,
                         help='Turn on ort VERBOSE logging via session options')
 
+    parser.add_argument(
+        '--disable-offload-copy',
+        dest="offload_copy",
+        action='store_false',
+        default=True,
+        help=
+        'Disable offload copying (user must handle copy to and from device)')
+
+    parser.add_argument(
+        '--disable-fast-math',
+        dest="fast_math",
+        action='store_false',
+        default=True,
+        help='Disable fast math optimizations (etc: rewrite_gelu)')
+
+    parser.add_argument('--exhaustive_tune',
+                        dest="exhaustive_tune",
+                        action='store_true',
+                        default=False,
+                        help='Enable exhaustive tuning for solutions')
+
     args = parser.parse_args()
 
     return args
@@ -177,7 +198,12 @@ def main():
         print(model)
 
     if not args.ort_run:
-        model.compile(migraphx.get_target(args.target))
+        model.compile(
+            migraphx.get_target(args.target),
+            offload_copy=args.offload_copy,
+            fast_math=args.fast_math,
+            exhaustive_tune=args.exhaustive_tune,
+        )
 
     params = {}
     test_inputs = {}
@@ -194,10 +220,16 @@ def main():
         else:
             test_input = np.zeros(in_shape).astype(get_np_datatype(in_type))
         test_inputs[name] = test_input
-        params[name] = migraphx.argument(test_input)
+        migraphx_arg = migraphx.argument(test_input)
+        if not args.offload_copy:
+            migraphx_arg = migraphx.to_gpu(migraphx_arg)
+        params[name] = migraphx_arg
 
     if not args.ort_run:
-        pred_migx = np.array(model.run(params)[-1])
+        if not args.offload_copy:
+            pred_migx = np.array(migraphx.from_gpu(model.run(params)[-1]))
+        else:
+            pred_migx = np.array(model.run(params)[-1])
 
     if use_onnx:
         sess_op = ort.SessionOptions()

tools/accuracy/requirements.txt

@@ -22,4 +22,4 @@
 # THE SOFTWARE.
 #####################################################################################
 numpy==1.21.6
-onnxruntime==1.10.0
+onnxruntime==1.16.1

tools/api.py

@@ -27,6 +27,7 @@ import re
 import runpy
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from pathlib import Path
 
 type_map: Dict[str, Callable[['Parameter'], None]] = {}
 cpp_type_map: Dict[str, str] = {}
@@ -1281,18 +1282,17 @@ def template_eval(template, **kwargs):
     return template
 
 
-def run(args: List[str]) -> None:
-    runpy.run_path(args[0])
-    if len(args) > 1:
-        f = open(args[1]).read()
-        r = template_eval(f)
+def run(path: Union[Path, str]) -> str:
+    return template_eval(open(path).read())
+
+
+if __name__ == "__main__":
+    sys.modules['api'] = sys.modules['__main__']
+    runpy.run_path(sys.argv[1])
+    if len(sys.argv) > 2:
+        r = run(sys.argv[2])
         sys.stdout.write(r)
     else:
         sys.stdout.write(generate_c_header())
         sys.stdout.write(generate_c_api_body())
         # sys.stdout.write(generate_cpp_header())
-
-
-if __name__ == "__main__":
-    sys.modules['api'] = sys.modules['__main__']
-    run(sys.argv[1:])