Merge branch 'develop' into enable_navi_32_ci

test/op_shape_test.cpp

@@ -88,6 +88,13 @@ TEST_CASE(allocate_static)
     expect_shape(out_shape, migraphx::make_op("allocate", {{"shape", to_value(out_shape)}}));
 }
 
+TEST_CASE(allocate_static_input_error)
+{
+    migraphx::shape input{migraphx::shape::int64_type, {3}};
+    migraphx::shape out_shape{migraphx::shape::float_type, {2, 3, 4}};
+    expect_shape(out_shape, migraphx::make_op("allocate", {{"shape", to_value(out_shape)}}), input);
+}
+
 TEST_CASE(allocate_dyn)
 {
     migraphx::shape input{migraphx::shape::int64_type, {2}};
@@ -109,6 +116,14 @@ TEST_CASE(allocate_dyn_with_shape_attr)
                  input);
 }
 
+TEST_CASE(allocate_dyn_no_input_error)
+{
+    migraphx::shape shape_attr{migraphx::shape::float_type,
+                               {{1, 4}, {3, 3}, {4, 8, {4, 6}}, {4, 8}, {4, 6}}};
+    expect_shape(shape_attr,
+                 migraphx::make_op("allocate", {{"shape", migraphx::to_value(shape_attr)}}));
+}
+
 TEST_CASE(argmax_axis0)
 {
     migraphx::shape input{migraphx::shape::half_type, {2, 3, 4, 5}};
@@ -2524,13 +2539,21 @@ TEST_CASE(reshape_shape)
         migraphx::shape output{migraphx::shape::float_type, lens};
         expect_shape(output, migraphx::make_op("reshape", {{"dims", new_shape}}), input);
     }
+}
 
+TEST_CASE(reshape_shape_invalid)
+{
+    migraphx::shape input{migraphx::shape::float_type, {24, 1, 1, 1}};
     for(auto&& new_shape :
         std::vector<std::vector<int64_t>>{{8, 3, 2, 2}, {1, 3, -1, -1}, {3, 0}, {3, 2}})
     {
         throws_shape(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
     }
+}
 
+TEST_CASE(reshape_shape_minus1_reshapes)
+{
+    migraphx::shape input{migraphx::shape::float_type, {24, 1, 1, 1}};
     std::vector<std::pair<std::vector<int64_t>, migraphx::shape>> minus1_tests{
         {{2, -1, 3}, {migraphx::shape::float_type, {2, 4, 3}}},
         {{0, -1, 0}, {migraphx::shape::float_type, {24, 1, 1}}},
@@ -2654,11 +2677,11 @@ TEST_CASE(reshape_broadcast_squeeze)
     expect_shape(output, migraphx::make_op("reshape", {{"dims", output.lens()}}), input);
 }
 
-TEST_CASE(reshape_broadcast_squeeze_error)
+TEST_CASE(reshape_broadcast_squeeze_memlayout_change)
 {
     migraphx::shape input{migraphx::shape::float_type, {2, 16, 16, 1280}, {0, 0, 0, 1}};
-    std::vector<int64_t> new_shape = {2, 16, 20480};
-    throws_shape(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
+    migraphx::shape output{migraphx::shape::float_type, {2, 16, 256, 80}, {0, 0, 0, 16}};
+    expect_shape(output, migraphx::make_op("reshape", {{"dims", output.lens()}}), input);
 }
 
 TEST_CASE(reshape_dyn_shape)
@@ -2706,6 +2729,199 @@ TEST_CASE(reshape_non_fixed_not_matching_error)
     throws_shape(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
 }
 
+TEST_CASE(reshape_lazy_shape)
+{
+    migraphx::shape input{migraphx::shape::float_type, {24, 1, 1, 1}};
+    for(auto&& new_shape :
+        std::vector<std::vector<int64_t>>{{8, 3, 1, 1}, {1, 3, 4, 2}, {1, 3, 4, 2}})
+    {
+        std::vector<std::size_t> lens(new_shape.size());
+        std::copy(new_shape.begin(), new_shape.end(), lens.begin());
+        migraphx::shape output{migraphx::shape::float_type, lens};
+        expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+    }
+
+    for(auto&& new_shape :
+        std::vector<std::vector<int64_t>>{{8, 3, 2, 2}, {1, 3, -1, -1}, {3, 0}, {3, 2}})
+    {
+        throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+    }
+
+    std::vector<std::pair<std::vector<int64_t>, migraphx::shape>> minus1_tests{
+        {{2, -1, 3}, {migraphx::shape::float_type, {2, 4, 3}}},
+        {{0, -1, 0}, {migraphx::shape::float_type, {24, 1, 1}}},
+        {{2, -1, 0}, {migraphx::shape::float_type, {2, 12, 1}}},
+        {{0, 0, -1}, {migraphx::shape::float_type, {24, 1, 1}}},
+        {{2, 0, -1}, {migraphx::shape::float_type, {2, 1, 12}}},
+        {{-1, 2, 3}, {migraphx::shape::float_type, {4, 2, 3}}},
+        {{-1, 0, 3}, {migraphx::shape::float_type, {8, 1, 3}}},
+        {{-1, 0, 0}, {migraphx::shape::float_type, {24, 1, 1}}},
+        {{-1, 3, 0}, {migraphx::shape::float_type, {8, 3, 1}}}};
+
+    for(auto& it : minus1_tests)
+    {
+        expect_shape(it.second, migraphx::make_op("reshape_lazy", {{"dims", it.first}}), input);
+    }
+}
+
+// This uses the permutation to compute the reshape_lazy since its simpler than
+// trying to calculate strides. As we collapse or expand dimensions, we
+// remove the collapsed dimensions or duplicate the expanded dimensions in
+// the permutation. Then we renumber the permutation. So for dimensions of 4,
+// 24, 1, 1, 1 with a permutation of 1, 0, 2, 3, 4 that reshape_lazys to 4, 1, 3,
+// 4, 2, we first remove the collapsed dimensions or duplicate the expanded
+// dimensions which gives 1, 0, 0, 0, 0. Then after renumbering we get a
+// final permutation of 4, 0, 1, 2, 3.
+TEST_CASE(reshape_lazy_nonstandard)
+{
+    auto input = migraphx::shape::from_permutation(migraphx::shape::float_type,
+                                                   {4, 24, 1, 1, 1},
+                                                   migraphx::invert_permutation({1, 0, 2, 3, 4}));
+    std::vector<std::pair<std::vector<std::size_t>, std::vector<int64_t>>> tests{
+        {{4, 24}, {1, 0}},
+        {{4, 24, 1, 1, 1, 1}, {1, 0, 2, 3, 4, 5}},
+        {{4, 8, 3, 1, 1}, {2, 0, 1, 3, 4}},
+        {{4, 1, 3, 4, 2}, {4, 0, 1, 2, 3}},
+        {{4, 1, 4, 3, 2}, {4, 0, 1, 2, 3}},
+        {{4, 2, 4, 3}, {3, 0, 1, 2}},
+        {{4, 2, 12, 1}, {2, 0, 1, 3}},
+        {{4, 2, 1, 12}, {3, 0, 1, 2}},
+        {{4, 4, 2, 3}, {3, 0, 1, 2}},
+        {{4, 8, 1, 3}, {3, 0, 1, 2}},
+        {{4, 8, 3, 1}, {2, 0, 1, 3}}};
+
+    for(const auto& [dims, perm] : tests)
+    {
+        migraphx::shape output = migraphx::shape::from_permutation(
+            migraphx::shape::float_type, dims, migraphx::invert_permutation(perm));
+        expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", dims}}), input);
+    }
+}
+
+TEST_CASE(reshape_lazy_nonstandard_squeeze)
+{
+    auto input = migraphx::shape::from_permutation(
+        migraphx::shape::float_type, {2, 16, 16, 1280}, migraphx::invert_permutation({0, 2, 3, 1}));
+    std::vector<std::size_t> lens = {2, 256, 1280};
+    migraphx::shape output        = migraphx::shape::from_permutation(
+        migraphx::shape::float_type, lens, migraphx::invert_permutation({0, 2, 1}));
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", lens}}), input);
+}
+
+TEST_CASE(reshape_lazy_nonstandard_error)
+{
+    auto input = migraphx::shape::from_permutation(migraphx::shape::float_type,
+                                                   {4, 24, 1, 1, 1},
+                                                   migraphx::invert_permutation({1, 0, 2, 3, 4}));
+    for(auto&& new_shape : std::vector<std::vector<int64_t>>{{4, 8, 3, 2, 2},
+                                                             {1},
+                                                             {4, 8, 4},
+                                                             {4, 24, 1, 1, 1, 1, 2},
+                                                             {8, 4, 4},
+                                                             {4, 1, 3, -1, -1},
+                                                             {4, 3, 0},
+                                                             {4, 3, 2},
+                                                             {3, 0},
+                                                             {3, 2}})
+    {
+        throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+    }
+}
+
+TEST_CASE(reshape_lazy_nonpacked_unsqueeze1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {4, 16}, {32, 2}};
+    migraphx::shape output{migraphx::shape::float_type, {4, 2, 8}, {32, 16, 2}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_nonpacked_unsqueeze2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {4, 16}, {32, 2}};
+    migraphx::shape output{migraphx::shape::float_type, {2, 2, 16}, {64, 32, 2}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_nonpacked_squeeze)
+{
+    migraphx::shape input{migraphx::shape::float_type, {4, 16}, {32, 2}};
+    migraphx::shape output{migraphx::shape::float_type, {64}, {2}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_broadcast_unsqueeze1)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 256, 1280}, {0, 0, 1}};
+    migraphx::shape output{migraphx::shape::float_type, {2, 16, 16, 1280}, {0, 0, 0, 1}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_broadcast_unsqueeze2)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 256, 1280}, {0, 0, 1}};
+    migraphx::shape output{migraphx::shape::float_type, {2, 256, 16, 80}, {0, 0, 80, 1}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_broadcast_squeeze)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 16, 16, 1280}, {0, 0, 0, 1}};
+    migraphx::shape output{migraphx::shape::float_type, {2, 256, 1280}, {0, 0, 1}};
+    expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", output.lens()}}), input);
+}
+
+TEST_CASE(reshape_lazy_broadcast_squeeze_error)
+{
+    migraphx::shape input{migraphx::shape::float_type, {2, 16, 16, 1280}, {0, 0, 0, 1}};
+    std::vector<int64_t> new_shape = {2, 16, 20480};
+    throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+}
+
+TEST_CASE(reshape_lazy_dyn_shape)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    for(auto&& new_shape : std::vector<std::vector<int64_t>>{
+            {-1, 1, 1, 24}, {0, 8, 3, 1}, {-1, 3, 4, 2}, {0, 2, 4, 3}})
+    {
+        std::vector<migraphx::shape::dynamic_dimension> out_dyn_dims{};
+        for(std::size_t i = 0; i < new_shape.size(); ++i)
+        {
+            if(new_shape[i] == 0 or new_shape[i] == -1)
+            {
+                out_dyn_dims.push_back(input.dyn_dims().at(i));
+            }
+            else
+            {
+                std::size_t d = new_shape[i];
+                out_dyn_dims.push_back({d, d});
+            }
+        }
+        migraphx::shape output{migraphx::shape::float_type, out_dyn_dims};
+        expect_shape(output, migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+    }
+}
+
+TEST_CASE(reshape_lazy_multiple_non_fixed_error)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {10, 20}, {1, 1}}};
+    std::vector<int64_t> new_shape = {0, 1, 0, 24};
+    throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+}
+
+TEST_CASE(reshape_lazy_fixed_ele_not_matching_error)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {10, 10}, {1, 1}}};
+    std::vector<int64_t> new_shape = {0, 1, 5, 24};
+    throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+}
+
+TEST_CASE(reshape_lazy_non_fixed_not_matching_error)
+{
+    migraphx::shape input{migraphx::shape::float_type, {{1, 4}, {24, 24}, {1, 1}, {1, 1}}};
+    std::vector<int64_t> new_shape = {2, 1, 1, 24};
+    throws_shape(migraphx::make_op("reshape_lazy", {{"dims", new_shape}}), input);
+}
+
 TEST_CASE(return_shape_tuple)
 {
     using migraphx::shape;

test/quantization.cpp

@@ -83,7 +83,7 @@ TEST_CASE(param_add)
         auto hs  = mm->add_instruction(migraphx::make_op("add"), hp1, hp2);
         auto fs  = mm->add_instruction(
             migraphx::make_op("convert",
-                              {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
+                               {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
             hs);
         if(add_return)
         {
@@ -1013,7 +1013,7 @@ TEST_CASE(target_copy)
         std::vector<float> orig_result;
         run_prog(p, ref_t, m, orig_result);
 
-        EXPECT(migraphx::verify::verify_range(ref_result, orig_result));
+        EXPECT(migraphx::verify::verify_rms_range(ref_result, orig_result));
     }
 }
 
@@ -1077,7 +1077,10 @@ TEST_CASE(int8_quantization_dot)
         std::vector<float> no_quant_result;
         run_prog(p, ref_t, m, no_quant_result);
 
-        EXPECT(migraphx::verify::verify_range(quant_result, no_quant_result, 30000));
+        EXPECT(migraphx::verify::verify_range_with_tolerance(
+            quant_result,
+            migraphx::verify::expected{no_quant_result},
+            migraphx::verify::tolerance{0.003}));
     }
 }
 
@@ -1122,7 +1125,7 @@ TEST_CASE(int8_quantization_conv)
         std::vector<float> no_quant_result;
         run_prog(p, ref_t, no_quant_result);
 
-        EXPECT(migraphx::verify::verify_range(quant_result, no_quant_result));
+        EXPECT(migraphx::verify::verify_rms_range(quant_result, no_quant_result));
     }
 }
 
@@ -1274,7 +1277,7 @@ TEST_CASE(test_op_capture)
     cap_res.visit([&](auto output) { cap_vec.assign(output.begin(), output.end()); });
     res.visit([&](auto output) { vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(vec, cap_vec));
+    EXPECT(migraphx::verify::verify_rms_range(vec, cap_vec));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/ref/abs.cpp

@@ -42,7 +42,7 @@ TEST_CASE(abs_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 2, 3, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(abs_dyn_test)
@@ -62,5 +62,5 @@ TEST_CASE(abs_dyn_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{1, 2, 3, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/acos.cpp

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

test/ref/acosh.cpp

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

test/ref/add.cpp

@@ -51,7 +51,7 @@ TEST_CASE(add_broadcast_test)
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(add_multibroadcast_test)
@@ -75,7 +75,7 @@ TEST_CASE(add_multibroadcast_test)
     std::vector<float> results_vector(12);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(add_test)
@@ -91,7 +91,7 @@ TEST_CASE(add_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 2, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(add_dyn_test)
@@ -115,7 +115,7 @@ TEST_CASE(add_dyn_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0, 2, 4};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fp16_test)
@@ -134,7 +134,7 @@ TEST_CASE(fp16_test)
     std::vector<migraphx::half> results_vector(1);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<migraphx::half> gold{c};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fp32_fp16_test)
@@ -159,7 +159,7 @@ TEST_CASE(fp32_fp16_test)
         auto result = p.eval({}).back();
         std::vector<float> res;
         result.visit([&](auto output) { res.assign(output.begin(), output.end()); });
-        EXPECT(migraphx::verify::verify_range(res, gold_res));
+        EXPECT(migraphx::verify::verify_rms_range(res, gold_res));
     };
 
     test_case({"all"});

test/ref/argmax.cpp

@@ -47,7 +47,7 @@ TEST_CASE(argmax_test_0)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmax_test_1)
@@ -66,7 +66,7 @@ TEST_CASE(argmax_test_1)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmax_test_2)
@@ -85,7 +85,7 @@ TEST_CASE(argmax_test_2)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmax_test_neg_2)
@@ -104,7 +104,7 @@ TEST_CASE(argmax_test_neg_2)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmax_dyn_test)
@@ -126,7 +126,7 @@ TEST_CASE(argmax_dyn_test)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
     std::vector<int64_t> res_gold = {0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1};
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmax_test_nonstd_shape)
@@ -145,5 +145,5 @@ TEST_CASE(argmax_test_nonstd_shape)
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
     std::vector<int64_t> res_gold_vec;
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold_vec));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }

test/ref/argmin.cpp

@@ -47,7 +47,7 @@ TEST_CASE(argmin_test_0)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmin_test_1)
@@ -66,7 +66,7 @@ TEST_CASE(argmin_test_1)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmin_test_2)
@@ -85,7 +85,7 @@ TEST_CASE(argmin_test_2)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmin_test_neg_1)
@@ -104,7 +104,7 @@ TEST_CASE(argmin_test_neg_1)
     std::vector<int64_t> result_vec;
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold));
 }
 
 TEST_CASE(argmin_test_nonstd_shape)
@@ -123,5 +123,5 @@ TEST_CASE(argmin_test_nonstd_shape)
     result.visit([&](auto output) { result_vec.assign(output.begin(), output.end()); });
     std::vector<int64_t> res_gold_vec;
     res_gold.visit([&](auto output) { res_gold_vec.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(result_vec, res_gold_vec));
+    EXPECT(migraphx::verify::verify_rms_range(result_vec, res_gold_vec));
 }

test/ref/asin.cpp

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

test/ref/asinh.cpp

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

test/ref/atan.cpp

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

test/ref/atanh.cpp

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

test/ref/broadcast.cpp

@@ -114,6 +114,6 @@ TEST_CASE(isnan_broadcast_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> correct = {0, 0, 0, 0, 1, 1};
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    std::vector<float> gold = {0, 0, 0, 0, 1, 1};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/ceil.cpp

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

test/ref/clip.cpp

@@ -48,7 +48,7 @@ TEST_CASE(clip_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.0, 0.0, 6.0};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(clip_dyn_test)
@@ -73,5 +73,5 @@ TEST_CASE(clip_dyn_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {0.0, 0.0, 6.0};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/concat.cpp

@@ -50,11 +50,11 @@ TEST_CASE(concat_test_1)
     std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
     std::vector<int> results_vector(2 * 6);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({2, 6})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({6, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({2, 6})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({6, 1})));
 }
 
 TEST_CASE(concat_test_2)
@@ -77,11 +77,11 @@ TEST_CASE(concat_test_2)
     std::vector<int> gold = {0, 1, 2, 3, 4, 10, 5, 6, 7, 8, 9, 20};
     std::vector<int> results_vector(2 * 6);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({2, 6})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({6, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({2, 6})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({6, 1})));
 }
 
 TEST_CASE(concat_test_3)
@@ -104,11 +104,11 @@ TEST_CASE(concat_test_3)
     std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::vector<int> results_vector(6 * 2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({2, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({2, 1})));
 }
 
 TEST_CASE(concat_test_4)
@@ -131,11 +131,11 @@ TEST_CASE(concat_test_4)
     std::vector<int> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
     std::vector<int> results_vector(6 * 2);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().strides(),
-                                          std::vector<std::size_t>({2, 1})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
+                                              std::vector<std::size_t>({2, 1})));
 }
 
 TEST_CASE(concat_dyn_test)
@@ -169,7 +169,7 @@ TEST_CASE(concat_dyn_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
     std::vector<float> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
-    EXPECT(migraphx::verify::verify_range(result.get_shape().lens(),
-                                          std::vector<std::size_t>({6, 2})));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().lens(),
+                                              std::vector<std::size_t>({6, 2})));
 }

test/ref/contiguous.cpp

@@ -50,7 +50,7 @@ TEST_CASE(contiguous_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
     std::vector<float> gold = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(contiguous_param_test)
@@ -74,7 +74,7 @@ TEST_CASE(contiguous_param_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_CASE(contiguous_dyn_test)
@@ -100,5 +100,5 @@ TEST_CASE(contiguous_dyn_test)
     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/convolution.cpp

@@ -78,23 +78,6 @@ TEST_CASE(conv_dyn_batch_test)
         -0.06269585, 0.18658121,  -0.03944227, 0.0111798,   -0.17731084, 0.11789055,  -0.09982193,
         0.08142821,  0.0729029,   0.11303909,  0.12735154,  0.03885292};
 
-    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};
-
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3, 4, 4}};
 
     migraphx::parameter_map params0;
@@ -104,8 +87,23 @@ TEST_CASE(conv_dyn_batch_test)
     auto result = p.eval(params0).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));
+    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));
 }
 
 TEST_CASE(conv_dyn_img_shape_test)
@@ -139,8 +137,6 @@ TEST_CASE(conv_dyn_img_shape_test)
                             0.15479768, 0.46534674, 0.16970931, 0.49704618, 0.07062198, 0.01678321,
                             0.53150934, 0.39244495, 0.9963813};
 
-    std::vector<float> sol = {6.1329393, 4.3199925, 5.448438, 3.8497565};
-
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {1, 3, 4, 4}};
 
     migraphx::parameter_map params0;
@@ -151,7 +147,9 @@ TEST_CASE(conv_dyn_img_shape_test)
     std::vector<float> results_vector(72);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    std::vector<float> gold = {6.1329393, 4.3199925, 5.448438, 3.8497565};
+
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 
     a = {0.95600171, 0.20768181, 0.82844489, 0.14928212, 0.51280462, 0.1359196,  0.68903648,
          0.84174772, 0.425509,   0.956926,   0.82533291, 0.33821531, 0.57576055, 0.75330186,
@@ -172,18 +170,18 @@ TEST_CASE(conv_dyn_img_shape_test)
          0.14407301, 0.80968594, 0.38216188, 0.35692557, 0.2568538,  0.83587388, 0.43654904,
          0.04974508, 0.80375029, 0.25350374, 0.1820275,  0.23369029, 0.54358755};
 
-    sol = {6.305986,
-           5.564665,
-           6.122996,
-           5.7262855,
-           5.5546584,
-           5.779489,
-           5.798161,
-           5.160476,
-           6.702436,
-           5.4851074,
-           6.227567,
-           5.2016754};
+    gold = {6.305986,
+            5.564665,
+            6.122996,
+            5.7262855,
+            5.5546584,
+            5.779489,
+            5.798161,
+            5.160476,
+            6.702436,
+            5.4851074,
+            6.227567,
+            5.2016754};
     migraphx::shape input_fixed_shape1{migraphx::shape::float_type, {1, 3, 6, 5}};
 
     migraphx::parameter_map params1;
@@ -193,7 +191,7 @@ TEST_CASE(conv_dyn_img_shape_test)
     result = p.eval(params1).back();
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_weights_shape_test)
@@ -221,27 +219,18 @@ TEST_CASE(conv_dyn_weights_shape_test)
                             0.77388606, 0.1752363,  0.74631394, 0.24604889, 0.53600244, 0.22116457,
                             0.81217463, 0.10789447, 0.43083784, 0.63371852, 0.69742316, 0.09536905};
 
-    std::vector<float> c   = {0.98411968,
-                              0.2899219,
-                              0.44638833,
-                              0.30390816,
-                              0.03989896,
-                              0.2445332,
-                              0.32700131,
-                              0.57517075,
-                              0.06956476,
-                              0.93079306,
-                              0.19882314,
-                              0.52940601};
-    std::vector<float> sol = {1.9939406,
-                              2.2703054,
-                              1.8896171,
-                              2.062202,
-                              2.3035214,
-                              1.629366,
-                              2.1606991,
-                              2.1917608,
-                              1.6797699};
+    std::vector<float> c = {0.98411968,
+                            0.2899219,
+                            0.44638833,
+                            0.30390816,
+                            0.03989896,
+                            0.2445332,
+                            0.32700131,
+                            0.57517075,
+                            0.06956476,
+                            0.93079306,
+                            0.19882314,
+                            0.52940601};
 
     migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
 
@@ -252,14 +241,23 @@ TEST_CASE(conv_dyn_weights_shape_test)
     auto result = p.eval(params0).back();
     std::vector<float> results_vector(72);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
-
-    c   = {0.98411968, 0.2899219,  0.44638833, 0.30390816, 0.03989896, 0.2445332,  0.32700131,
-           0.57517075, 0.06956476, 0.93079306, 0.19882314, 0.52940601, 0.35624753, 0.35938406,
-           0.9111428,  0.88923574, 0.61040283, 0.2797513,  0.15479768, 0.46534674, 0.16970931,
-           0.49704618, 0.07062198, 0.01678321, 0.53150934, 0.39244495, 0.9963813};
-    sol = {6.1329393, 4.3199925, 5.448438, 3.8497565};
+    std::vector<float> gold = {1.9939406,
+                               2.2703054,
+                               1.8896171,
+                               2.062202,
+                               2.3035214,
+                               1.629366,
+                               2.1606991,
+                               2.1917608,
+                               1.6797699};
+
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
+
+    c    = {0.98411968, 0.2899219,  0.44638833, 0.30390816, 0.03989896, 0.2445332,  0.32700131,
+            0.57517075, 0.06956476, 0.93079306, 0.19882314, 0.52940601, 0.35624753, 0.35938406,
+            0.9111428,  0.88923574, 0.61040283, 0.2797513,  0.15479768, 0.46534674, 0.16970931,
+            0.49704618, 0.07062198, 0.01678321, 0.53150934, 0.39244495, 0.9963813};
+    gold = {6.1329393, 4.3199925, 5.448438, 3.8497565};
     migraphx::shape weights_fixed_shape1{migraphx::shape::float_type, {1, 3, 3, 3}};
 
     migraphx::parameter_map params1;
@@ -269,7 +267,7 @@ TEST_CASE(conv_dyn_weights_shape_test)
     result = p.eval(params1).back();
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_img_same_upper_test)
@@ -313,23 +311,6 @@ TEST_CASE(conv_dyn_img_same_upper_test)
         7.9253986e-02, 7.3943835e-01, 1.7813577e-01, 1.0780835e-01, 4.2304707e-01,
         4.0084350e-01, 1.1114500e-01, 4.4846520e-01, 5.0109702e-01};
 
-    std::vector<float> sol = {3.013387,
-                              3.7111127,
-                              4.2946506,
-                              3.579301,
-                              4.5306826,
-                              6.1262493,
-                              6.332169,
-                              4.495293,
-                              4.46013,
-                              6.0938954,
-                              5.848162,
-                              4.514299,
-                              2.9587686,
-                              4.117671,
-                              3.5187216,
-                              2.3236327};
-
     migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {1, 3, 4, 4}};
 
     migraphx::parameter_map params0;
@@ -339,7 +320,23 @@ TEST_CASE(conv_dyn_img_same_upper_test)
     auto result = p.eval(params0).back();
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    std::vector<float> gold = {3.013387,
+                               3.7111127,
+                               4.2946506,
+                               3.579301,
+                               4.5306826,
+                               6.1262493,
+                               6.332169,
+                               4.495293,
+                               4.46013,
+                               6.0938954,
+                               5.848162,
+                               4.514299,
+                               2.9587686,
+                               4.117671,
+                               3.5187216,
+                               2.3236327};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_upper_test)
@@ -361,47 +358,31 @@ TEST_CASE(conv_dyn_kernel_same_upper_test)
 
     p.compile(migraphx::make_target("ref"));
 
-    std::vector<float> a   = {0.63321185, 0.6466339,  0.8515352,  0.44240063, 0.5018913,  0.5068494,
-                              0.75330657, 0.7383877,  0.15870683, 0.8171611,  0.56118083, 0.87004256,
-                              0.24401724, 0.8815178,  0.4222333,  0.27191755,
-
-                              0.41633207, 0.2460619,  0.32004243, 0.6962248,  0.12284133, 0.2620491,
-                              0.96931046, 0.6030955,  0.7623861,  0.2395751,  0.61440414, 0.577285,
-                              0.80087787, 0.12776066, 0.26566318, 0.46569306,
-
-                              0.96701574, 0.3850145,  0.14165345, 0.5887347,  0.7152134,  0.5295342,
-                              0.6303507,  0.4037548,  0.18556239, 0.79416305, 0.29107493, 0.18770285,
-                              0.6870904,  0.30701008, 0.314684,   0.91075855};
-    std::vector<float> c   = {2.8150102e-01,
-                              3.3198616e-01,
-                              9.5149356e-01,
-                              7.4039467e-02,
-
-                              9.6555042e-01,
-                              2.8815505e-01,
-                              2.5100240e-01,
-                              5.2186239e-01,
-
-                              2.3850012e-01,
-                              8.2963020e-01,
-                              3.0763101e-04,
-                              6.7026985e-01};
-    std::vector<float> sol = {2.453681,
-                              2.536207,
-                              3.0187201,
-                              1.7912633,
-                              2.1738236,
-                              2.9695358,
-                              3.2319589,
-                              1.859269,
-                              2.5953722,
-                              2.50734,
-                              2.7736917,
-                              1.2229807,
-                              1.5900216,
-                              0.9225286,
-                              1.43048,
-                              0.74341124};
+    std::vector<float> a = {0.63321185, 0.6466339,  0.8515352,  0.44240063, 0.5018913,  0.5068494,
+                            0.75330657, 0.7383877,  0.15870683, 0.8171611,  0.56118083, 0.87004256,
+                            0.24401724, 0.8815178,  0.4222333,  0.27191755,
+
+                            0.41633207, 0.2460619,  0.32004243, 0.6962248,  0.12284133, 0.2620491,
+                            0.96931046, 0.6030955,  0.7623861,  0.2395751,  0.61440414, 0.577285,
+                            0.80087787, 0.12776066, 0.26566318, 0.46569306,
+
+                            0.96701574, 0.3850145,  0.14165345, 0.5887347,  0.7152134,  0.5295342,
+                            0.6303507,  0.4037548,  0.18556239, 0.79416305, 0.29107493, 0.18770285,
+                            0.6870904,  0.30701008, 0.314684,   0.91075855};
+    std::vector<float> c = {2.8150102e-01,
+                            3.3198616e-01,
+                            9.5149356e-01,
+                            7.4039467e-02,
+
+                            9.6555042e-01,
+                            2.8815505e-01,
+                            2.5100240e-01,
+                            5.2186239e-01,
+
+                            2.3850012e-01,
+                            8.2963020e-01,
+                            3.0763101e-04,
+                            6.7026985e-01};
 
     migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
 
@@ -412,7 +393,23 @@ TEST_CASE(conv_dyn_kernel_same_upper_test)
     auto result = p.eval(params0).back();
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    std::vector<float> gold = {2.453681,
+                               2.536207,
+                               3.0187201,
+                               1.7912633,
+                               2.1738236,
+                               2.9695358,
+                               3.2319589,
+                               1.859269,
+                               2.5953722,
+                               2.50734,
+                               2.7736917,
+                               1.2229807,
+                               1.5900216,
+                               0.9225286,
+                               1.43048,
+                               0.74341124};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_lower_test)
@@ -434,47 +431,31 @@ TEST_CASE(conv_dyn_kernel_same_lower_test)
 
     p.compile(migraphx::make_target("ref"));
 
-    std::vector<float> a   = {0.63321185, 0.6466339,  0.8515352,  0.44240063, 0.5018913,  0.5068494,
-                              0.75330657, 0.7383877,  0.15870683, 0.8171611,  0.56118083, 0.87004256,
-                              0.24401724, 0.8815178,  0.4222333,  0.27191755,
-
-                              0.41633207, 0.2460619,  0.32004243, 0.6962248,  0.12284133, 0.2620491,
-                              0.96931046, 0.6030955,  0.7623861,  0.2395751,  0.61440414, 0.577285,
-                              0.80087787, 0.12776066, 0.26566318, 0.46569306,
-
-                              0.96701574, 0.3850145,  0.14165345, 0.5887347,  0.7152134,  0.5295342,
-                              0.6303507,  0.4037548,  0.18556239, 0.79416305, 0.29107493, 0.18770285,
-                              0.6870904,  0.30701008, 0.314684,   0.91075855};
-    std::vector<float> c   = {2.8150102e-01,
-                              3.3198616e-01,
-                              9.5149356e-01,
-                              7.4039467e-02,
-
-                              9.6555042e-01,
-                              2.8815505e-01,
-                              2.5100240e-01,
-                              5.2186239e-01,
-
-                              2.3850012e-01,
-                              8.2963020e-01,
-                              3.0763101e-04,
-                              6.7026985e-01};
-    std::vector<float> sol = {0.91231215,
-                              1.1416453,
-                              1.00216,
-                              1.6813052,
-                              1.7131033,
-                              2.453681,
-                              2.536207,
-                              3.0187201,
-                              1.3293691,
-                              2.1738236,
-                              2.9695358,
-                              3.2319589,
-                              1.3228729,
-                              2.5953722,
-                              2.50734,
-                              2.7736917};
+    std::vector<float> a = {0.63321185, 0.6466339,  0.8515352,  0.44240063, 0.5018913,  0.5068494,
+                            0.75330657, 0.7383877,  0.15870683, 0.8171611,  0.56118083, 0.87004256,
+                            0.24401724, 0.8815178,  0.4222333,  0.27191755,
+
+                            0.41633207, 0.2460619,  0.32004243, 0.6962248,  0.12284133, 0.2620491,
+                            0.96931046, 0.6030955,  0.7623861,  0.2395751,  0.61440414, 0.577285,
+                            0.80087787, 0.12776066, 0.26566318, 0.46569306,
+
+                            0.96701574, 0.3850145,  0.14165345, 0.5887347,  0.7152134,  0.5295342,
+                            0.6303507,  0.4037548,  0.18556239, 0.79416305, 0.29107493, 0.18770285,
+                            0.6870904,  0.30701008, 0.314684,   0.91075855};
+    std::vector<float> c = {2.8150102e-01,
+                            3.3198616e-01,
+                            9.5149356e-01,
+                            7.4039467e-02,
+
+                            9.6555042e-01,
+                            2.8815505e-01,
+                            2.5100240e-01,
+                            5.2186239e-01,
+
+                            2.3850012e-01,
+                            8.2963020e-01,
+                            3.0763101e-04,
+                            6.7026985e-01};
 
     migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
 
@@ -485,7 +466,24 @@ TEST_CASE(conv_dyn_kernel_same_lower_test)
     auto result = p.eval(params0).back();
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, sol));
+    std::vector<float> gold = {0.91231215,
+                               1.1416453,
+                               1.00216,
+                               1.6813052,
+                               1.7131033,
+                               2.453681,
+                               2.536207,
+                               3.0187201,
+                               1.3293691,
+                               2.1738236,
+                               2.9695358,
+                               3.2319589,
+                               1.3228729,
+                               2.5953722,
+                               2.50734,
+                               2.7736917};
+
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_padding_stride_test)
@@ -518,23 +516,6 @@ TEST_CASE(conv2d_padding_stride_test)
         -0.06269585, 0.18658121,  -0.03944227, 0.0111798,   -0.17731084, 0.11789055,  -0.09982193,
         0.08142821,  0.0729029,   0.11303909,  0.12735154,  0.03885292};
 
-    std::vector<float> s = {-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};
-
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
 
@@ -548,7 +529,24 @@ TEST_CASE(conv2d_padding_stride_test)
 
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    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));
 }
 
 TEST_CASE(conv2d_padding_test)
@@ -581,18 +579,6 @@ TEST_CASE(conv2d_padding_test)
         0.14747436,  -0.06199479, -0.01166052, -0.12432006, -0.04494537, -0.17581205, 0.09475745,
         0.1149437,   -0.1014564,  0.0274073,   -0.01323579, -0.11092556};
 
-    std::vector<float> s = {
-        -0.0201216,  0.40407312,  -0.39005592, -0.0631946,  0.37963012,  -0.64611685, 0.1349397,
-        -0.54113752, 0.28533003,  0.27667275,  -0.16442731, -0.181494,   0.30564839,  0.58744538,
-        0.32015014,  0.24969585,  -0.27367792, -0.53308117, 0.41236052,  0.26136363,  -0.01489828,
-        0.57652152,  -0.38506854, 0.119615,    0.0437076,   0.04779706,  0.57887721,  0.23126155,
-        0.05695833,  -0.68200272, 0.02063358,  -0.10267162, 0.8062973,   -0.38149622, -0.40134856,
-        -0.03353126, 0.38991132,  -0.3478111,  0.03661491,  0.25783631,  0.62772679,  -0.1961118,
-        0.76423508,  -0.36241418, -0.20994355, -0.12368261, -0.9406727,  0.02340185,  -0.08793129,
-        -0.02471633, -0.58163726, -0.02211772, -0.42014724, 0.77525634,  0.504951,    -0.20537445,
-        -0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194,  0.49579027,
-        0.46527559};
-
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
 
@@ -606,7 +592,18 @@ TEST_CASE(conv2d_padding_test)
 
     std::vector<float> results_vector(64);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    std::vector<float> gold = {
+        -0.0201216,  0.40407312,  -0.39005592, -0.0631946,  0.37963012,  -0.64611685, 0.1349397,
+        -0.54113752, 0.28533003,  0.27667275,  -0.16442731, -0.181494,   0.30564839,  0.58744538,
+        0.32015014,  0.24969585,  -0.27367792, -0.53308117, 0.41236052,  0.26136363,  -0.01489828,
+        0.57652152,  -0.38506854, 0.119615,    0.0437076,   0.04779706,  0.57887721,  0.23126155,
+        0.05695833,  -0.68200272, 0.02063358,  -0.10267162, 0.8062973,   -0.38149622, -0.40134856,
+        -0.03353126, 0.38991132,  -0.3478111,  0.03661491,  0.25783631,  0.62772679,  -0.1961118,
+        0.76423508,  -0.36241418, -0.20994355, -0.12368261, -0.9406727,  0.02340185,  -0.08793129,
+        -0.02471633, -0.58163726, -0.02211772, -0.42014724, 0.77525634,  0.504951,    -0.20537445,
+        -0.20369984, -0.83037728, -1.40423918, -0.46160448, -0.22944322, 0.36074194,  0.49579027,
+        0.46527559};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_test)
@@ -642,22 +639,6 @@ TEST_CASE(conv2d_test)
         1.61106288e-02,  -1.35080189e-01, 1.49512306e-01,  3.86456847e-02,  1.29330024e-01,
         -3.22975963e-02, -5.60784787e-02, -5.41997552e-02, 4.78562862e-02};
 
-    std::vector<float> s = {0.27039781,
-                            0.19105849,
-                            -0.06339942,
-                            -0.65087199,
-                            0.40867025,
-                            0.05063812,
-                            -0.14907975,
-                            0.49018705,
-                            -0.49197209,
-                            0.33236548,
-                            -0.39374301,
-                            0.16012701,
-                            0.06574871,
-                            0.71606487,
-                            -0.55201721,
-                            -0.46427044};
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
 
@@ -670,7 +651,24 @@ TEST_CASE(conv2d_test)
 
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+
+    std::vector<float> gold = {0.27039781,
+                               0.19105849,
+                               -0.06339942,
+                               -0.65087199,
+                               0.40867025,
+                               0.05063812,
+                               -0.14907975,
+                               0.49018705,
+                               -0.49197209,
+                               0.33236548,
+                               -0.39374301,
+                               0.16012701,
+                               0.06574871,
+                               0.71606487,
+                               -0.55201721,
+                               -0.46427044};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv3d_test)
@@ -706,22 +704,6 @@ TEST_CASE(conv3d_test)
         1.61106288e-02,  -1.35080189e-01, 1.49512306e-01,  3.86456847e-02,  1.29330024e-01,
         -3.22975963e-02, -5.60784787e-02, -5.41997552e-02, 4.78562862e-02};
 
-    std::vector<float> s = {0.27039781,
-                            0.19105849,
-                            -0.06339942,
-                            -0.65087199,
-                            0.40867025,
-                            0.05063812,
-                            -0.14907975,
-                            0.49018705,
-                            -0.49197209,
-                            0.33236548,
-                            -0.39374301,
-                            0.16012701,
-                            0.06574871,
-                            0.71606487,
-                            -0.55201721,
-                            -0.46427044};
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4, 1}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
 
@@ -738,5 +720,21 @@ TEST_CASE(conv3d_test)
 
     std::vector<float> results_vector(16);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    std::vector<float> gold = {0.27039781,
+                               0.19105849,
+                               -0.06339942,
+                               -0.65087199,
+                               0.40867025,
+                               0.05063812,
+                               -0.14907975,
+                               0.49018705,
+                               -0.49197209,
+                               0.33236548,
+                               -0.39374301,
+                               0.16012701,
+                               0.06574871,
+                               0.71606487,
+                               -0.55201721,
+                               -0.46427044};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/convolution_backwards.cpp

@@ -52,7 +52,7 @@ TEST_CASE(convolution_backwards_1d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2d)
@@ -75,7 +75,7 @@ TEST_CASE(convolution_backwards_2d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_3d)
@@ -113,7 +113,7 @@ TEST_CASE(convolution_backwards_3d)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_padding1)
@@ -139,7 +139,7 @@ TEST_CASE(convolution_backwards_padding1)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_padding2)
@@ -165,7 +165,7 @@ TEST_CASE(convolution_backwards_padding2)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2stride)
@@ -192,7 +192,7 @@ TEST_CASE(convolution_backwards_2stride)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_2dilation)
@@ -219,7 +219,7 @@ TEST_CASE(convolution_backwards_2dilation)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_dyn_batch1)
@@ -247,7 +247,7 @@ TEST_CASE(convolution_backwards_dyn_batch1)
                             27, 15, 9, 20, 33, 24, 13, 6,  13, 21, 15, 8};
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(convolution_backwards_dyn_batch2)
@@ -288,5 +288,5 @@ TEST_CASE(convolution_backwards_dyn_batch2)
 
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/cos.cpp

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