Merge branch 'develop' into simplify-more-reshapes

test/onnx/.onnxrt-commit

-ad4db1269972f92fdba932bb5770943291be3ca5
+c294040bac0e34bd7ef0cb97424bace7998900e7

test/onnx/onnx_test.cpp

@@ -4959,13 +4959,13 @@ TEST_CASE(reducemax_dyn_test)
     migraphx::program p;
     auto* mm = p.get_main_module();
     auto l0  = mm->add_parameter(
-        "x", migraphx::shape{migraphx::shape::float_type, {{3, 3}, {4, 4}, {5, 5}, {6, 6}}});
+        "x", migraphx::shape{migraphx::shape::float_type, {{3, 5}, {4, 4}, {5, 5}, {6, 6}}});
     auto r0 = mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2}}}), l0);
     auto r1 = mm->add_instruction(migraphx::make_op("squeeze", {{"axes", {2}}}), r0);
     mm->add_return({r1});
 
     migraphx::onnx_options options;
-    options.map_dyn_input_dims["x"] = {{3, 3}, {4, 4}, {5, 5}, {6, 6}};
+    options.map_dyn_input_dims["x"] = {{3, 5}, {4, 4}, {5, 5}, {6, 6}};
     auto prog                       = migraphx::parse_onnx("reducemax_dyn_test.onnx", options);
 
     EXPECT(p == prog);
@@ -6953,6 +6953,23 @@ TEST_CASE(variable_batch_user_input_test6)
     EXPECT(test::throws([&] { migraphx::parse_onnx("variable_batch_test.onnx", options); }));
 }
 
+TEST_CASE(variable_batch_user_input_test7)
+{
+    // if entry in map_dyn_input_dims is all fixed dynamic_dimensions, convert it to a static shape
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l0  = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 16, 16}});
+    auto r   = mm->add_instruction(migraphx::make_op("identity"), l0);
+    mm->add_return({r});
+
+    migraphx::onnx_options options;
+    options.map_dyn_input_dims["0"] = {{2, 2, {2}}, {3, 3}, {16, 16}, {16, 16}};
+
+    auto prog = migraphx::parse_onnx("variable_batch_test.onnx", options);
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(variable_batch_leq_zero_test)
 {
     migraphx::program p;

test/op_shape_test.cpp

@@ -1822,6 +1822,33 @@ TEST_CASE(pad_dyn_shape1)
     expect_shape(output, migraphx::make_op("pad", {{"pads", {0, 0, 1, 1, 0, 0, 1, 1}}}), input);
 }
 
+TEST_CASE(pointwise_no_module)
+{
+    migraphx::shape input{migraphx::shape::float_type, {0}, {0}};
+    throws_shape(migraphx::make_op("pointwise"), input);
+}
+
+TEST_CASE(pointwise_no_input)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::module m;
+    std::vector<migraphx::instruction_ref> args{};
+    auto output = migraphx::shape(migraphx::shape::float_type, {1}, {0});
+    auto l      = m.add_literal(migraphx::literal(output, {1}));
+    m.add_return({l});
+    EXPECT(test::throws([&] { mm->add_instruction(migraphx::make_op("pointwise"), args, {&m}); }));
+}
+
+TEST_CASE(pointwise_no_output)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::module m;
+    std::vector<migraphx::instruction_ref> args{};
+    EXPECT(test::throws([&] { mm->add_instruction(migraphx::make_op("pointwise"), args, {&m}); }));
+}
+
 TEST_CASE(pooling_shape0)
 {
     migraphx::shape input{migraphx::shape::float_type, {4, 3, 3, 3}};

test/py/test_instruction.py

+#####################################################################################
+# 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.
+#####################################################################################
+import migraphx
+
+
+def test_instruction_shape():
+    p = migraphx.program()
+    mm = p.get_main_module()
+    input_shape = migraphx.shape(lens=[4, 4, 64], type="half_type")
+    i = mm.add_parameter("x", input_shape)
+    i2 = mm.add_instruction(migraphx.op("reshape", dims=[16, 64]), [i])
+    out_shape = i2.shape()
+
+    assert out_shape.lens() == [16, 64]
+    assert out_shape.strides() == [64, 1]
+    assert out_shape.type_string() == "half_type"
+
+
+def test_instruction_op():
+    p = migraphx.program()
+    mm = p.get_main_module()
+    input_shape = migraphx.shape(lens=[2, 24])
+    i = mm.add_parameter("x", input_shape)
+    i2 = mm.add_instruction(migraphx.op("relu"), [i])
+    out_op = i2.op()
+
+    assert out_op.name() == "relu"
+
+
+if __name__ == "__main__":
+    test_instruction_shape()
+    test_instruction_op()

test/py/test_shape.py

@@ -49,6 +49,16 @@ def test_create_shape_type():
     assert s.type_size() == 4
 
 
+def test_type_enum():
+    mgx_types = [
+        'bool_type', 'double_type', 'float_type', 'half_type', 'int16_type',
+        'int32_type', 'int64_type', 'int8_type', 'uint16_type', 'uint32_type',
+        'uint64_type', 'uint8_type'
+    ]
+    for t in mgx_types:
+        assert hasattr(migraphx.shape.type_t, t)
+
+
 if __name__ == "__main__":
     test_create_shape()
     test_create_shape_broadcast()

test/shape_test.cpp

@@ -30,6 +30,7 @@
 #include <array>
 #include <algorithm>
 #include <numeric>
+#include <migraphx/verify.hpp>
 #include "test.hpp"
 
 TEST_CASE(test_shape_default)
@@ -929,4 +930,16 @@ TEST_CASE(test_with_type)
     EXPECT(s.strides() == new_s.strides());
 }
 
+TEST_CASE(test_multi_index)
+{
+    migraphx::shape s{migraphx::shape::float_type, {2, 4, 6}};
+    EXPECT(migraphx::verify_range(s.multi(0), std::vector<size_t>{0, 0, 0}));
+    EXPECT(migraphx::verify_range(s.multi(4), std::vector<size_t>{0, 0, 4}));
+    EXPECT(migraphx::verify_range(s.multi(6), std::vector<size_t>{0, 1, 0}));
+    EXPECT(migraphx::verify_range(s.multi(8), std::vector<size_t>{0, 1, 2}));
+    EXPECT(migraphx::verify_range(s.multi(24), std::vector<size_t>{1, 0, 0}));
+    EXPECT(migraphx::verify_range(s.multi(30), std::vector<size_t>{1, 1, 0}));
+    EXPECT(migraphx::verify_range(s.multi(34), std::vector<size_t>{1, 1, 4}));
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/split_single_dyn_dim_test.cpp

@@ -49,9 +49,9 @@ TEST_CASE(dynamic_batch)
             migraphx::shape sm_shape{migraphx::shape::float_type, {batch_size, 4}};
             auto sm_input = submod->add_parameter("data", sm_shape);
             migraphx::shape lit_s{migraphx::shape{migraphx::shape::float_type, {1}}};
-            auto literal_ins = submod->add_literal(migraphx::literal{lit_s, {6}});
-            auto broadcast_lit =
-                submod->add_instruction(migraphx::make_op("multibroadcast"), literal_ins, sm_input);
+            auto literal_ins   = submod->add_literal(migraphx::literal{lit_s, {6}});
+            auto broadcast_lit = submod->add_instruction(
+                migraphx::make_op("multibroadcast", {{"out_lens", sm_shape.lens()}}), literal_ins);
             auto add_ins =
                 submod->add_instruction(migraphx::make_op("add"), sm_input, broadcast_lit);
             submod->add_return({add_ins});
@@ -106,9 +106,9 @@ TEST_CASE(multiple_outputs)
             migraphx::shape sm_shape{migraphx::shape::float_type, {batch_size, 4}};
             auto sm_input = submod->add_parameter("data", sm_shape);
             migraphx::shape lit_s{migraphx::shape{migraphx::shape::float_type, {1}}};
-            auto literal_ins = submod->add_literal(migraphx::literal{lit_s, {6}});
-            auto broadcast_lit =
-                submod->add_instruction(migraphx::make_op("multibroadcast"), literal_ins, sm_input);
+            auto literal_ins   = submod->add_literal(migraphx::literal{lit_s, {6}});
+            auto broadcast_lit = submod->add_instruction(
+                migraphx::make_op("multibroadcast", {{"out_lens", sm_shape.lens()}}), literal_ins);
             auto add0_ins =
                 submod->add_instruction(migraphx::make_op("add"), sm_input, broadcast_lit);
             auto add1_ins = submod->add_instruction(migraphx::make_op("add"), sm_input, sm_input);
@@ -157,4 +157,64 @@ TEST_CASE(multiple_outputs)
     EXPECT(p0 == p1);
 }
 
+TEST_CASE(broadcast_match)
+{
+    // Slightly different from ref_ops_test in that the literal is copied over the submodules.
+    // A different compiler pass will pull the literals from the submodules to the main module.
+    migraphx::program p0;
+    {
+        auto* mm0 = p0.get_main_module();
+
+        // create batch submodules
+        auto create_submodule = [&](std::size_t batch_size, const std::string& module_name) {
+            auto* submod = p0.create_module(module_name);
+            migraphx::shape sm_shape{migraphx::shape::float_type, {batch_size, 4}};
+            auto sm_input = submod->add_parameter("data", sm_shape);
+            migraphx::shape lit_s{migraphx::shape{migraphx::shape::float_type, {4}}};
+            auto literal_ins   = submod->add_literal(migraphx::literal{lit_s, {6, 5, 4, 3}});
+            auto broadcast_lit = submod->add_instruction(
+                migraphx::make_op("broadcast", {{"axis", 1}, {"out_lens", sm_shape.lens()}}),
+                literal_ins);
+            auto add_ins =
+                submod->add_instruction(migraphx::make_op("add"), sm_input, broadcast_lit);
+            submod->add_return({add_ins});
+            return submod;
+        };
+        auto* dim1 = create_submodule(1, "dim_1");
+        auto* dim2 = create_submodule(2, "dim_2");
+        auto* dim3 = create_submodule(3, "dim_3");
+        auto* dim4 = create_submodule(4, "dim_4");
+
+        migraphx::shape s{migraphx::shape::float_type, {{1, 4}, {4, 4}}};
+        auto input0                             = mm0->add_parameter("data", s);
+        std::vector<migraphx::shape> sub_shapes = {};
+        sub_shapes.push_back(migraphx::shape{migraphx::shape::float_type, {{1, 4}, {4, 4}}});
+        migraphx::shape out_attr = migraphx::shape{sub_shapes};
+        auto sm_ins              = mm0->add_instruction(
+            migraphx::make_op("select_module",
+                              {{"output_dyn_shapes", migraphx::to_value(out_attr)}}),
+            {input0},
+            {dim1, dim2, dim3, dim4});
+        auto ret =
+            mm0->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), sm_ins);
+        mm0->add_return({ret});
+    }
+
+    migraphx::program p1;
+    {
+        auto* mm1 = p1.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {{1, 4}, {4, 4}}};
+        auto input1 = mm1->add_parameter("data", s);
+        migraphx::shape lit_s{migraphx::shape{migraphx::shape::float_type, {4}}};
+        auto literal_ins   = mm1->add_literal(migraphx::literal{lit_s, {6, 5, 4, 3}});
+        auto broadcast_lit = mm1->add_instruction(
+            migraphx::make_op("broadcast", {{"axis", 1}}), literal_ins, input1);
+        auto add_ins = mm1->add_instruction(migraphx::make_op("add"), input1, broadcast_lit);
+        mm1->add_return({add_ins});
+    }
+    run_pass(p1);
+
+    EXPECT(p0 == p1);
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/targets.cpp

@@ -41,10 +41,12 @@ TEST_CASE(make_invalid_target)
 
 TEST_CASE(targets)
 {
+    // GCC doesn't load libmigraphx_ref unless necesssary even though it is linked to the test.
+    // Force it to load by making ref target
+#if defined(__GNUC__) && !defined(__clang__)
+    auto ref_target = migraphx::make_target("ref");
+#endif
     auto ts = migraphx::get_targets();
-    EXPECT(ts.size() == 0);
-    auto ref_t = migraphx::make_target("ref");
-    ts         = migraphx::get_targets();
     EXPECT(ts.size() == 1);
 }
 

test/verify/test_reduce_mean_bias_half.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>
+#include <migraphx/instruction.hpp>
+
+struct test_reduce_mean_bias_half : verify_program<test_reduce_mean_bias_half>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::half_type, {1, 32, 128}};
+        migraphx::shape bs{migraphx::shape::half_type, {1, 32, 128}};
+        auto x      = mm->add_parameter("x", s);
+        auto reduce = mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2}}}), x);
+        auto bias   = mm->add_parameter("bias", reduce->get_shape());
+        auto add    = mm->add_instruction(migraphx::make_op("add"), reduce, bias);
+        auto abs    = mm->add_instruction(migraphx::make_op("abs"), add);
+        auto sqrt   = mm->add_instruction(migraphx::make_op("sqrt"), abs);
+        mm->add_return({sqrt});
+        return p;
+    };
+};

test/verify/test_softmax4.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_softmax4 : verify_program<test_softmax4>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto x =
+            mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {1, 12, 384, 384}});
+        mm->add_instruction(migraphx::make_op("softmax", {{"axis", 3}}), x);
+        return p;
+    }
+};

tools/build_and_test_onnxrt.sh

@@ -26,8 +26,13 @@ pip3 install -r requirements-dev.txt
 # Add newer cmake to the path
 export PATH="/opt/cmake/bin:$PATH"
 export CXXFLAGS="-D__HIP_PLATFORM_AMD__=1 -w"
-./build.sh --config Release  --cmake_extra_defines CMAKE_HIP_COMPILER=/opt/rocm/llvm/bin/clang++ --update --build --parallel --cmake_extra_defines ONNXRUNTIME_VERSION=$(cat ./VERSION_NUMBER) --skip_tests --rocm_home /opt/rocm --use_migraphx --migraphx_home /opt/rocm --rocm_version=`cat /opt/rocm/.info/version-dev`
+./build.sh --config Release  --cmake_extra_defines CMAKE_HIP_COMPILER=/opt/rocm/llvm/bin/clang++ --update --build --parallel --cmake_extra_defines ONNXRUNTIME_VERSION=$(cat ./VERSION_NUMBER) --skip_tests --rocm_home /opt/rocm --use_migraphx --migraphx_home /opt/rocm --rocm_version=`cat /opt/rocm/.info/version-dev` --allow_running_as_root
 
 cd build/Linux/Release
 #Add test launcher for onnxrt tests
+
+echo 'InferenceSessionTests.CheckRunProfilerWithSessionOptions' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
+echo 'InferenceSessionTests.CheckRunProfilerWithSessionOptions2' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
+echo 'InferenceSessionTests.Test3LayerNestedSubgraph' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
+echo 'InferenceSessionTests.Test2LayerNestedSubgraph' >> ../../../tools/ci_build/github/pai/migraphx-excluded-tests.txt
 ../../../tools/ci_build/github/pai/migraphx_test_launcher.sh