Merge branch 'develop' into threads_register_target

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,10 +50,10 @@ 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(),
+    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_range(result.get_shape().strides(),
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
                                               std::vector<std::size_t>({6, 1})));
 }
 
@@ -77,10 +77,10 @@ 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(),
+    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_range(result.get_shape().strides(),
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
                                               std::vector<std::size_t>({6, 1})));
 }
 
@@ -104,10 +104,10 @@ 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(),
+    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_range(result.get_shape().strides(),
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
                                               std::vector<std::size_t>({2, 1})));
 }
 
@@ -131,10 +131,10 @@ 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(),
+    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_range(result.get_shape().strides(),
+    EXPECT(migraphx::verify::verify_rms_range(result.get_shape().strides(),
                                               std::vector<std::size_t>({2, 1})));
 }
 
@@ -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(),
+    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,7 +78,16 @@ 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,
+    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3, 4, 4}};
+
+    migraphx::parameter_map params0;
+    params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
+    params0["W"] = migraphx::argument(weights_shape, c.data());
+
+    auto result = p.eval(params0).back();
+    std::vector<float> results_vector(64);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {-0.20817225,
                                0.87965256,
                                0.14958936,
                                -1.24887264,
@@ -94,18 +103,7 @@ TEST_CASE(conv_dyn_batch_test)
                                0.44276932,
                                -0.16138598,
                                0.79344082};
-
-    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {2, 3, 4, 4}};
-
-    migraphx::parameter_map params0;
-    params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
-    params0["W"] = migraphx::argument(weights_shape, c.data());
-
-    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));
+    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,7 +170,7 @@ 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,
+    gold = {6.305986,
             5.564665,
             6.122996,
             5.7262855,
@@ -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)
@@ -233,15 +231,6 @@ TEST_CASE(conv_dyn_weights_shape_test)
                             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};
 
     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()); });
+    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_range(results_vector, sol));
+    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};
-    sol = {6.1329393, 4.3199925, 5.448438, 3.8497565};
+    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,7 +311,16 @@ 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,
+    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {1, 3, 4, 4}};
+
+    migraphx::parameter_map params0;
+    params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
+    params0["W"] = migraphx::argument(weights_shape, c.data());
+
+    auto result = p.eval(params0).back();
+    std::vector<float> results_vector(16);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {3.013387,
                                3.7111127,
                                4.2946506,
                                3.579301,
@@ -329,17 +336,7 @@ TEST_CASE(conv_dyn_img_same_upper_test)
                                4.117671,
                                3.5187216,
                                2.3236327};
-
-    migraphx::shape input_fixed_shape0{migraphx::shape::float_type, {1, 3, 4, 4}};
-
-    migraphx::parameter_map params0;
-    params0["X"] = migraphx::argument(input_fixed_shape0, a.data());
-    params0["W"] = migraphx::argument(weights_shape, c.data());
-
-    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));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_upper_test)
@@ -386,7 +383,17 @@ TEST_CASE(conv_dyn_kernel_same_upper_test)
                             8.2963020e-01,
                             3.0763101e-04,
                             6.7026985e-01};
-    std::vector<float> sol = {2.453681,
+
+    migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
+
+    migraphx::parameter_map params0;
+    params0["X"] = migraphx::argument(input_shape, a.data());
+    params0["W"] = migraphx::argument(weight_fixed_shape0, c.data());
+
+    auto result = p.eval(params0).back();
+    std::vector<float> results_vector(16);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {2.453681,
                                2.536207,
                                3.0187201,
                                1.7912633,
@@ -402,17 +409,7 @@ TEST_CASE(conv_dyn_kernel_same_upper_test)
                                0.9225286,
                                1.43048,
                                0.74341124};
-
-    migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
-
-    migraphx::parameter_map params0;
-    params0["X"] = migraphx::argument(input_shape, a.data());
-    params0["W"] = migraphx::argument(weight_fixed_shape0, c.data());
-
-    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));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv_dyn_kernel_same_lower_test)
@@ -459,7 +456,17 @@ TEST_CASE(conv_dyn_kernel_same_lower_test)
                             8.2963020e-01,
                             3.0763101e-04,
                             6.7026985e-01};
-    std::vector<float> sol = {0.91231215,
+
+    migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
+
+    migraphx::parameter_map params0;
+    params0["X"] = migraphx::argument(input_shape, a.data());
+    params0["W"] = migraphx::argument(weight_fixed_shape0, c.data());
+
+    auto result = p.eval(params0).back();
+    std::vector<float> results_vector(16);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {0.91231215,
                                1.1416453,
                                1.00216,
                                1.6813052,
@@ -476,16 +483,7 @@ TEST_CASE(conv_dyn_kernel_same_lower_test)
                                2.50734,
                                2.7736917};
 
-    migraphx::shape weight_fixed_shape0{migraphx::shape::float_type, {1, 3, 2, 2}};
-
-    migraphx::parameter_map params0;
-    params0["X"] = migraphx::argument(input_shape, a.data());
-    params0["W"] = migraphx::argument(weight_fixed_shape0, c.data());
-
-    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));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(conv2d_padding_stride_test)
@@ -518,7 +516,20 @@ 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,
+    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
+    auto al = mm->add_literal(migraphx::literal{a_shape, a});
+
+    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
+    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
+
+    mm->add_instruction(
+        migraphx::make_op("convolution", {{"padding", {1, 1}}, {"stride", {2, 2}}}), al, cl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector(16);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {-0.20817225,
                                0.87965256,
                                0.14958936,
                                -1.24887264,
@@ -535,20 +546,7 @@ TEST_CASE(conv2d_padding_stride_test)
                                -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});
-
-    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
-    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
-
-    mm->add_instruction(
-        migraphx::make_op("convolution", {{"padding", {1, 1}}, {"stride", {2, 2}}}), al, cl);
-    p.compile(migraphx::make_target("ref"));
-    auto result = p.eval({}).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, s));
+    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,7 +639,20 @@ 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,
+    migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 4, 4}};
+    auto al = mm->add_literal(migraphx::literal{a_shape, a});
+
+    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
+    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
+
+    mm->add_instruction(migraphx::make_op("convolution"), al, cl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+
+    std::vector<float> results_vector(16);
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold = {0.27039781,
                                0.19105849,
                                -0.06339942,
                                -0.65087199,
@@ -658,19 +668,7 @@ TEST_CASE(conv2d_test)
                                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});
-
-    migraphx::shape c_shape{migraphx::shape::float_type, {2, 3, 3, 3}};
-    auto cl = mm->add_literal(migraphx::literal{c_shape, c});
-
-    mm->add_instruction(migraphx::make_op("convolution"), al, cl);
-    p.compile(migraphx::make_target("ref"));
-    auto result = p.eval({}).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, s));
+    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));
 }

test/ref/cosh.cpp

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

test/ref/dimensions_of.cpp

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

test/ref/div.cpp

@@ -46,7 +46,7 @@ TEST_CASE(div_test)
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold(data1.size());
     std::transform(data1.begin(), data1.end(), data2.begin(), gold.begin(), std::divides<float>());
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(div_dyn_test)
@@ -72,5 +72,5 @@ TEST_CASE(div_dyn_test)
     std::vector<float> gold(x_data.size());
     std::transform(
         x_data.begin(), x_data.end(), y_data.begin(), gold.begin(), std::divides<float>());
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/elu.cpp

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

test/ref/erf.cpp

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

test/ref/exp.cpp

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

test/ref/fill.cpp

@@ -51,7 +51,7 @@ TEST_CASE(fill_static_int)
     std::vector<int64_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold(48, 3);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fill_dyn_float)
@@ -75,7 +75,7 @@ TEST_CASE(fill_dyn_float)
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold(72, 7.36);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fill_var_default_value)
@@ -98,5 +98,5 @@ TEST_CASE(fill_var_default_value)
     std::vector<int64_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<int64_t> gold(48, 2);
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/floor.cpp

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

test/ref/fmod.cpp

@@ -45,7 +45,7 @@ TEST_CASE(fmod_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1, 0, -3};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fmod_dyn_test)
@@ -73,7 +73,7 @@ TEST_CASE(fmod_dyn_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1, 0, -3};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(fmod_float_test)
@@ -92,5 +92,5 @@ TEST_CASE(fmod_float_test)
     std::vector<float> results_vector(4);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold{-1.2f, 0.5f, -3.3f};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/gather.cpp

@@ -52,7 +52,7 @@ TEST_CASE(gather_non_std_test)
             0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f, 0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
         std::vector<float> res_data;
         result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-        EXPECT(migraphx::verify::verify_range(res_data, golden));
+        EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
     }
 }
 
@@ -75,7 +75,7 @@ TEST_CASE(gather_test_1)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_2)
@@ -97,7 +97,7 @@ TEST_CASE(gather_test_2)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 1.5f, 2.5f, 6.5f, 7.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_3)
@@ -119,7 +119,7 @@ TEST_CASE(gather_test_3)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_4)
@@ -141,7 +141,7 @@ TEST_CASE(gather_test_4)
     std::vector<float> res_data(4 * 5);
     std::vector<float> golden = {0.5f, 2.5f, 3.5f, 5.5f, 6.5f, 8.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_5)
@@ -164,7 +164,7 @@ TEST_CASE(gather_test_5)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f, 3.5f, 6.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_6)
@@ -187,7 +187,7 @@ TEST_CASE(gather_test_6)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f, 3.5f, 6.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_test_7)
@@ -210,7 +210,7 @@ TEST_CASE(gather_test_7)
     std::vector<float> res_data{};
     std::vector<float> golden = {0.5f};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, golden));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, golden));
 }
 
 TEST_CASE(gather_dyn_test0)
@@ -243,7 +243,7 @@ TEST_CASE(gather_dyn_test0)
     std::vector<int> gold = {1, 2, 4, 5};
     std::vector<int> results_vector(2 * 1 * 2);
     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));
     migraphx::shape sfinal{migraphx::shape::int32_type, {2, 1, 2}};
     EXPECT(result.get_shape() == sfinal);
 }
@@ -280,7 +280,7 @@ TEST_CASE(gather_dyn_test1)
     std::vector<int> results_vector(1 * 2 * 4);
     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));
     migraphx::shape sfinal{migraphx::shape::int32_type, {1, 2, 4}};
     EXPECT(result.get_shape() == sfinal);
 }

test/ref/gathernd.cpp

@@ -52,7 +52,7 @@ TEST_CASE(gathernd_test_1)
     std::vector<float> gold{0, 3};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_2)
@@ -77,7 +77,7 @@ TEST_CASE(gathernd_test_2)
     std::vector<float> gold{2, 3, 0, 1};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_3)
@@ -102,7 +102,7 @@ TEST_CASE(gathernd_test_3)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_4)
@@ -128,7 +128,7 @@ TEST_CASE(gathernd_test_4)
     std::vector<float> gold{0, 1, 2, 3, 4, 5, 18, 19, 20, 21, 22, 23};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_5)
@@ -155,7 +155,7 @@ TEST_CASE(gathernd_test_5)
     std::vector<float> gold{0, 4, 8, 11, 13, 15};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_test_6)
@@ -215,7 +215,7 @@ TEST_CASE(gathernd_dynamic0)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic1)
@@ -251,7 +251,7 @@ TEST_CASE(gathernd_dynamic1)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic2)
@@ -287,7 +287,7 @@ TEST_CASE(gathernd_dynamic2)
     std::vector<float> gold{3, 4, 5, 0, 1, 2, 0, 1, 2, 3, 4, 5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic3)
@@ -323,7 +323,7 @@ TEST_CASE(gathernd_dynamic3)
     std::vector<float> res_data{};
     std::vector<float> gold{1, 0, 3, 4};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_dynamic4)
@@ -358,7 +358,7 @@ TEST_CASE(gathernd_dynamic4)
     std::vector<float> res_data{};
     std::vector<float> gold{5};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_negative_index_test_1)
@@ -383,7 +383,7 @@ TEST_CASE(gathernd_negative_index_test_1)
     std::vector<float> gold{2, 3, 0, 1};
     result.visit([&](auto output) { res_data.assign(output.begin(), output.end()); });
 
-    EXPECT(migraphx::verify::verify_range(res_data, gold));
+    EXPECT(migraphx::verify::verify_rms_range(res_data, gold));
 }
 
 TEST_CASE(gathernd_negative_index_test_2)