Merge branch 'develop' of https://github.com/ROCmSoftwarePlatform/AMDMIGraphX...

Merge branch 'develop' of https://github.com/ROCmSoftwarePlatform/AMDMIGraphX into bcast_transpose_generic

test/ref/softmax.cpp

@@ -33,9 +33,9 @@
 TEST_CASE(softmax_simple_test)
 {
     migraphx::program p;
-    auto* mm             = p.get_main_module();
-    std::vector<float> a = {0.25, 0.75};
-    std::vector<float> s = {0.377541, 0.622459};
+    auto* mm                = p.get_main_module();
+    std::vector<float> a    = {0.25, 0.75};
+    std::vector<float> gold = {0.377541, 0.622459};
     migraphx::shape a_shape{migraphx::shape::float_type, {1, 2}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     mm->add_instruction(migraphx::make_op("softmax", {{"axis", 1}}), al);
@@ -43,7 +43,7 @@ TEST_CASE(softmax_simple_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(softmax_test)
@@ -76,7 +76,7 @@ TEST_CASE(softmax_test)
         2.02392387e+00,  -9.42091495e-02, -3.77683818e-01, 2.05638766e+00,  2.93796062e-01,
         -6.02131486e-01, 2.70461679e-01,  -8.92358482e-01, 1.04388881e+00,  2.66154885e-01};
 
-    std::vector<float> s = {
+    std::vector<float> gold = {
         0.30191708, 0.59879845, 0.50029165, 0.24915339, 0.36823985, 0.13190967, 0.0349741,
         0.18750034, 0.21905553, 0.27000085, 0.0547399,  0.56318235, 0.47422904, 0.78964758,
         0.91381913, 0.44601166, 0.47902739, 0.13120073, 0.4449684,  0.18766427, 0.15753111,
@@ -103,7 +103,7 @@ TEST_CASE(softmax_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(120);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(softmax_dyn_test)
@@ -147,7 +147,7 @@ TEST_CASE(softmax_dyn_test)
     auto result = p.eval(params).back();
     std::vector<float> results_vector(120);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> s = {
+    std::vector<float> gold = {
         0.30191708, 0.59879845, 0.50029165, 0.24915339, 0.36823985, 0.13190967, 0.0349741,
         0.18750034, 0.21905553, 0.27000085, 0.0547399,  0.56318235, 0.47422904, 0.78964758,
         0.91381913, 0.44601166, 0.47902739, 0.13120073, 0.4449684,  0.18766427, 0.15753111,
@@ -166,5 +166,5 @@ TEST_CASE(softmax_dyn_test)
         0.13268511, 0.61795473, 0.49703068, 0.41696799, 0.10175809, 0.71028161, 0.29929739,
         0.17377149, 0.76075399, 0.20071237, 0.32632929, 0.36892858, 0.09416146, 0.26656723,
         0.42914796};
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/sqdiff.cpp

@@ -43,7 +43,7 @@ TEST_CASE(sqdiff_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {4, 4, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(sqdiff_dyn_test)
@@ -67,5 +67,5 @@ TEST_CASE(sqdiff_dyn_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {4, 4, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/sqrt.cpp

@@ -45,7 +45,7 @@ TEST_CASE(sqrt_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return sqrtf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(sqrt_dynamic_test)
@@ -68,5 +68,5 @@ TEST_CASE(sqrt_dynamic_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return sqrtf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/sub.cpp

@@ -43,7 +43,7 @@ TEST_CASE(sub_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-2, -2, -2};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(sub_dyn_test)
@@ -67,5 +67,5 @@ TEST_CASE(sub_dyn_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-2, -2, -2};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/tan.cpp

@@ -45,7 +45,7 @@ TEST_CASE(tan_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return tanf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(tan_dynamic_test)
@@ -68,5 +68,5 @@ TEST_CASE(tan_dynamic_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return tanf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/tanh.cpp

@@ -45,7 +45,7 @@ TEST_CASE(tanh_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return tanhf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(tanh_dynamic_test)
@@ -68,5 +68,5 @@ TEST_CASE(tanh_dynamic_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return tanhf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/transpose.cpp

@@ -59,7 +59,7 @@ TEST_CASE(transpose_test)
         std::vector<float> results_vector(12);
         result2.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::verify_range(results_vector, gold));
+        EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     }
 }
 
@@ -86,5 +86,5 @@ TEST_CASE(transpose_dyn_test)
     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::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/where.cpp

@@ -54,7 +54,7 @@ TEST_CASE(where_test)
     for(int i = 0; i < gold.size(); ++i)
         gold[i] = b[i] ? x[i] : y[i];
 
-    EXPECT(migraphx::verify::verify_range(result_vec, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, gold));
 }
 
 TEST_CASE(where_dyn_test)
@@ -85,7 +85,7 @@ TEST_CASE(where_dyn_test)
     std::vector<float> results_vector(3 * 3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 1, 1, 2, 2, 2, 1, 2, 1};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(where_broadcasted_inputs_test)
@@ -113,5 +113,5 @@ TEST_CASE(where_broadcasted_inputs_test)
     for(int i = 0; i < gold.size(); ++i)
         gold[i] = b[i] ? x[i] : y[i];
 
-    EXPECT(migraphx::verify::verify_range(result_vec, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, gold));
 }

test/ref_dev_examples.cpp

@@ -140,24 +140,6 @@ TEST_CASE(handling_tensors)
         -0.06269585, 0.18658121,  -0.03944227, 0.0111798,   -0.17731084, 0.11789055,  -0.09982193,
         0.08142821,  0.0729029,   0.11303909,  0.12735154,  0.03885292};
 
-    // Solution vector
-    std::vector<float> sol = {-0.20817225,
-                              0.87965256,
-                              0.14958936,
-                              -1.24887264,
-                              -0.06540672,
-                              0.20778663,
-                              0.40456355,
-                              -0.99900877,
-                              0.4917807,
-                              0.1994698,
-                              0.64205718,
-                              0.37798831,
-                              -0.25315839,
-                              0.44276932,
-                              -0.16138598,
-                              0.79344082};
-
     // Create the arguments in a parameter_map
     migraphx::parameter_map params;
     params["X"] = migraphx::argument(input_shape, a.data());
@@ -167,8 +149,25 @@ TEST_CASE(handling_tensors)
     auto result = p.eval(params).back();
     std::vector<float> results_vector(64);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    // Solution vector
+    std::vector<float> gold = {-0.20817225,
+                               0.87965256,
+                               0.14958936,
+                               -1.24887264,
+                               -0.06540672,
+                               0.20778663,
+                               0.40456355,
+                               -0.99900877,
+                               0.4917807,
+                               0.1994698,
+                               0.64205718,
+                               0.37798831,
+                               -0.25315839,
+                               0.44276932,
+                               -0.16138598,
+                               0.79344082};
+
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/rewrite_pooling_test.cpp

@@ -50,10 +50,10 @@ TEST_CASE(rewrite_pooling_test)
         migraphx::module m;
         auto input = m.add_parameter("x", s);
         auto ret   = m.add_instruction(migraphx::make_op("pooling",
-                                                       {{"mode", mode},
-                                                        {"padding", {0, 0, 0}},
-                                                        {"stride", {1, 1, 1}},
-                                                        {"lengths", {3, 4, 5}}}),
+                                                         {{"mode", mode},
+                                                          {"padding", {0, 0, 0}},
+                                                          {"stride", {1, 1, 1}},
+                                                          {"lengths", {3, 4, 5}}}),
                                      input);
         m.add_return({ret});
         return m;
@@ -62,11 +62,8 @@ TEST_CASE(rewrite_pooling_test)
     auto opt_program = [&](const migraphx::operation& reduce_op) {
         migraphx::module m;
         auto input = m.add_parameter("x", s);
-        auto rsp   = m.add_instruction(migraphx::make_op("reshape", {{"dims", {4, -1}}}), input);
-        auto rdm   = m.add_instruction(reduce_op, rsp);
-        auto ret =
-            m.add_instruction(migraphx::make_op("reshape", {{"dims", {2, 2, 1, 1, 1}}}), rdm);
-        m.add_return({ret});
+        auto rdm   = m.add_instruction(reduce_op, input);
+        m.add_return({rdm});
         return m;
     };
 
@@ -78,8 +75,9 @@ TEST_CASE(rewrite_pooling_test)
     };
 
     test_rewrite(migraphx::op::pooling_mode::average,
-                 migraphx::make_op("reduce_mean", {{"axes", {1}}}));
-    test_rewrite(migraphx::op::pooling_mode::max, migraphx::make_op("reduce_max", {{"axes", {1}}}));
+                 migraphx::make_op("reduce_mean", {{"axes", {2, 3, 4}}}));
+    test_rewrite(migraphx::op::pooling_mode::max,
+                 migraphx::make_op("reduce_max", {{"axes", {2, 3, 4}}}));
 }
 
 TEST_CASE(rewrite_avepooling_na1_test)
@@ -140,10 +138,10 @@ TEST_CASE(rewrite_avepooling_na3_test)
 
         auto input = m.add_parameter("x", s);
         auto ret   = m.add_instruction(migraphx::make_op("pooling",
-                                                       {{"mode", migraphx::op::pooling_mode::max},
-                                                        {"padding", {0, 0, 0}},
-                                                        {"stride", {1, 1, 1}},
-                                                        {"lengths", {3, 3, 5}}}),
+                                                         {{"mode", migraphx::op::pooling_mode::max},
+                                                          {"padding", {0, 0, 0}},
+                                                          {"stride", {1, 1, 1}},
+                                                          {"lengths", {3, 3, 5}}}),
                                      input);
         m.add_return({ret});
         return m;
@@ -168,10 +166,10 @@ TEST_CASE(literal_rewrite_pooling_test)
         auto* mm   = p.get_main_module();
         auto input = mm->add_literal(migraphx::literal(s, data));
         auto ret   = mm->add_instruction(migraphx::make_op("pooling",
-                                                         {{"mode", mode},
-                                                          {"padding", {0, 0, 0}},
-                                                          {"stride", {1, 1, 1}},
-                                                          {"lengths", {3, 4, 5}}}),
+                                                           {{"mode", mode},
+                                                            {"padding", {0, 0, 0}},
+                                                            {"stride", {1, 1, 1}},
+                                                            {"lengths", {3, 4, 5}}}),
                                        input);
         mm->add_return({ret});
         return p;
@@ -199,7 +197,7 @@ TEST_CASE(literal_rewrite_pooling_test)
         auto result1 = p1.eval({}).back();
         auto result2 = p2.eval({}).back();
         visit_all(result1, result2)(
-            [&](auto r1, auto r2) { EXPECT(migraphx::verify::verify_range(r1, r2)); });
+            [&](auto r1, auto r2) { EXPECT(migraphx::verify::verify_rms_range(r1, r2)); });
     };
 
     test_rewrite_pooling(migraphx::op::pooling_mode::max,

test/run_on_target_test.cpp

@@ -68,7 +68,7 @@ TEST_CASE(eval_run_on_target)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.5, 0.25, 0.125};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/shape_test.cpp

@@ -956,13 +956,13 @@ TEST_CASE(test_with_type)
 TEST_CASE(test_multi_index)
 {
     migraphx::shape s{migraphx::shape::float_type, {2, 4, 6}};
-    EXPECT(migraphx::verify::verify_range(s.multi(0), std::vector<size_t>{0, 0, 0}));
-    EXPECT(migraphx::verify::verify_range(s.multi(4), std::vector<size_t>{0, 0, 4}));
-    EXPECT(migraphx::verify::verify_range(s.multi(6), std::vector<size_t>{0, 1, 0}));
-    EXPECT(migraphx::verify::verify_range(s.multi(8), std::vector<size_t>{0, 1, 2}));
-    EXPECT(migraphx::verify::verify_range(s.multi(24), std::vector<size_t>{1, 0, 0}));
-    EXPECT(migraphx::verify::verify_range(s.multi(30), std::vector<size_t>{1, 1, 0}));
-    EXPECT(migraphx::verify::verify_range(s.multi(34), std::vector<size_t>{1, 1, 4}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(0), std::vector<size_t>{0, 0, 0}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(4), std::vector<size_t>{0, 0, 4}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(6), std::vector<size_t>{0, 1, 0}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(8), std::vector<size_t>{0, 1, 2}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(24), std::vector<size_t>{1, 0, 0}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(30), std::vector<size_t>{1, 1, 0}));
+    EXPECT(migraphx::verify::verify_rms_range(s.multi(34), std::vector<size_t>{1, 1, 4}));
 }
 
 TEST_CASE(find_permutation_2d_standard)

test/simplify_qdq_test.cpp

@@ -479,11 +479,11 @@ TEST_CASE(conv_pooling_dot)
         auto q1  = add_quantize_op(m1, "quantizelinear", input, scale, zero);
         auto d5  = add_quantize_op(m1, "dequantizelinear", q1, scale, zero);
         auto c1  = m1.add_instruction(migraphx::make_op("convolution",
-                                                       {{"padding", {0, 0, 0, 0}},
-                                                        {"stride", {1, 1}},
-                                                        {"dilation", {1, 1}},
-                                                        {"group", 1},
-                                                        {"padding_mode", 0}}),
+                                                        {{"padding", {0, 0, 0, 0}},
+                                                         {"stride", {1, 1}},
+                                                         {"dilation", {1, 1}},
+                                                         {"group", 1},
+                                                         {"padding_mode", 0}}),
                                      d5,
                                      d1);
         auto bc1 = m1.add_instruction(
@@ -526,11 +526,11 @@ TEST_CASE(conv_pooling_dot)
         auto d3  = add_quantize_op(m2, "dequantizelinear", ab, scale, zero);
         auto q1  = add_quantize_op(m2, "quantizelinear", input, scale, zero);
         auto c1  = m2.add_instruction(migraphx::make_op("quant_convolution",
-                                                       {{"padding", {0, 0, 0, 0}},
-                                                        {"stride", {1, 1}},
-                                                        {"dilation", {1, 1}},
-                                                        {"group", 1},
-                                                        {"padding_mode", 0}}),
+                                                        {{"padding", {0, 0, 0, 0}},
+                                                         {"stride", {1, 1}},
+                                                         {"dilation", {1, 1}},
+                                                         {"group", 1},
+                                                         {"padding_mode", 0}}),
                                      q1,
                                      weights);
         auto d5  = add_quantize_op(m2, "dequantizelinear", c1, scale1);
@@ -585,11 +585,11 @@ TEST_CASE(mobilenet_snippet)
         auto q1  = add_quantize_op(mm, "quantizelinear", input, scale, zero);
         auto d5  = add_quantize_op(mm, "dequantizelinear", q1, scale, zero);
         auto c1  = mm.add_instruction(migraphx::make_op("convolution",
-                                                       {{"padding", {0, 0, 0, 0}},
-                                                        {"stride", {1, 1}},
-                                                        {"dilation", {1, 1}},
-                                                        {"group", 1},
-                                                        {"padding_mode", 0}}),
+                                                        {{"padding", {0, 0, 0, 0}},
+                                                         {"stride", {1, 1}},
+                                                         {"dilation", {1, 1}},
+                                                         {"group", 1},
+                                                         {"padding_mode", 0}}),
                                      d5,
                                      d1);
         auto bc1 = mm.add_instruction(
@@ -700,7 +700,7 @@ TEST_CASE(conv_correctness)
     auto result2 = p2.eval({{"input", input}, {"weights", weights}}).back();
     std::vector<float> rv2(16);
     result2.visit([&](auto output) { rv2.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(rv1, rv2));
+    EXPECT(migraphx::verify::verify_rms_range(rv1, rv2));
 }
 
 TEST_CASE(dot_correctness)
@@ -750,7 +750,7 @@ TEST_CASE(dot_correctness)
     auto result2 = p2.eval({{"a", a}, {"b", b}}).back();
     std::vector<float> rv2(sh3.elements());
     result2.visit([&](auto output) { rv2.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(rv1, rv2));
+    EXPECT(migraphx::verify::verify_rms_range(rv1, rv2));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/verify/run_verify.cpp

@@ -251,7 +251,8 @@ void run_verify::verify(const std::string& name,
             std::size_t num = gold.size();
             for(std::size_t i = 0; ((i < num) and passed); ++i)
             {
-                passed &= migraphx::verify_args(tname, gold[i], result[i]);
+                passed &= migraphx::verify_args_with_tolerance(
+                    tname, result[i], migraphx::verify::expected{gold[i]});
             }
 
             if(not passed or migraphx::enabled(MIGRAPHX_TRACE_TEST{}))

test/verify/test_reduce_add.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_add : verify_program<test_reduce_add>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {4, 1000, 2, 2}};
+        migraphx::shape bs{migraphx::shape::half_type, {1, 32, 128}};
+        auto x = mm->add_parameter("x", s);
+        auto reduce_mean =
+            mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), x);
+        auto reduce_max =
+            mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2, 3}}}), x);
+        auto add = mm->add_instruction(migraphx::make_op("add"), reduce_mean, reduce_max);
+        mm->add_return({add});
+        return p;
+    };
+};

test/verify/test_reduce_noop_add.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_noop_add : verify_program<test_reduce_noop_add>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        migraphx::shape s{migraphx::shape::float_type, {4, 1000, 1, 1}};
+        migraphx::shape bs{migraphx::shape::half_type, {1, 32, 128}};
+        auto x = mm->add_parameter("x", s);
+        auto reduce_mean =
+            mm->add_instruction(migraphx::make_op("reduce_mean", {{"axes", {2, 3}}}), x);
+        auto reduce_max =
+            mm->add_instruction(migraphx::make_op("reduce_max", {{"axes", {2, 3}}}), x);
+        auto add = mm->add_instruction(migraphx::make_op("add"), reduce_mean, reduce_max);
+        mm->add_return({add});
+        return p;
+    };
+};

tools/docker/sles.docker

@@ -3,7 +3,7 @@ FROM registry.suse.com/suse/sle15:15.4
 RUN sh -c 'echo -e "\
 [rocm]\n\
 name=rocm\n\
-baseurl=https://repo.radeon.com/rocm/zyp/5.6/main\n\
+baseurl=https://repo.radeon.com/rocm/zyp/5.7/main\n\
 enabled=1\n\
 gpgcheck=1\n\
 gpgkey=https://repo.radeon.com/rocm/rocm.gpg.key\n\

tools/docker/ubuntu_2204.dockerfile

@@ -10,7 +10,7 @@ RUN apt-get update && apt-get install -y gnupg2 --no-install-recommends curl &&
     curl -fsSL http://repo.radeon.com/rocm/rocm.gpg.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/rocm-keyring.gpg
 
 # Add rocm repository
-RUN sh -c "echo 'deb [arch=amd64 signed-by=/etc/apt/trusted.gpg.d/rocm-keyring.gpg] http://repo.radeon.com/rocm/apt/5.5 jammy main' > /etc/apt/sources.list.d/rocm.list"
+RUN sh -c "echo 'deb [arch=amd64 signed-by=/etc/apt/trusted.gpg.d/rocm-keyring.gpg] http://repo.radeon.com/rocm/apt/5.7 jammy main' > /etc/apt/sources.list.d/rocm.list"
 
 # From docs.amd.com for installing rocm. Needed to install properly
 RUN sh -c "echo 'Package: *\nPin: release o=repo.radeon.com\nPin-priority: 600' > /etc/apt/preferences.d/rocm-pin-600"
@@ -87,7 +87,7 @@ RUN test -f /usr/local/hash || exit 1
 RUN pip3 install yapf==0.28.0
 
 # Install doc requirements
-ADD doc/requirements.txt /doc-requirements.txt
+ADD docs/.sphinx/requirements.txt /doc-requirements.txt
 RUN pip3 install -r /doc-requirements.txt
 
 # Download real models to run onnx unit tests