Merge

test/ref/erf.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <migraphx/instruction.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/onnx.hpp>
+#include <migraphx/register_target.hpp>
+#include <migraphx/verify.hpp>
+
+#include <test.hpp>
+
+TEST_CASE(fill_static_int)
+{
+    // Note this case can be simplified to a literal
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape lit_shape{migraphx::shape::int64_type, {1}, {0}};
+    std::vector<int64_t> lit_data = {3};
+    auto l                        = mm->add_literal(migraphx::literal{lit_shape, lit_data});
+    migraphx::shape data_shape{migraphx::shape::int64_type, {3, 4, 4}};
+    auto input = mm->add_parameter("x", data_shape);
+    mm->add_instruction(migraphx::make_op("fill"), l, input);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<int64_t> input_data(48);
+    migraphx::parameter_map params;
+    params["x"] = migraphx::argument(data_shape, input_data.data());
+    auto result = p.eval(params).back();
+    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_rms_range(results_vector, gold));
+}
+
+TEST_CASE(fill_dyn_float)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape lit_shape{migraphx::shape::float_type, {1}, {0}};
+    std::vector<float> lit_data = {7.36};
+    auto l                      = mm->add_literal(migraphx::literal{lit_shape, lit_data});
+    migraphx::shape data_shape{migraphx::shape::float_type,
+                               {{1, 4}, {4, 8, {4, 6, 8}}, {4, 8, {4, 6, 8}}}};
+    auto input = mm->add_parameter("x", data_shape);
+    mm->add_instruction(migraphx::make_op("fill"), l, input);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> input_data(72);
+    migraphx::parameter_map params;
+    migraphx::shape static_shape = {migraphx::shape::float_type, {2, 6, 6}};
+    params["x"]                  = migraphx::argument(static_shape, input_data.data());
+    auto result                  = p.eval(params).back();
+    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_rms_range(results_vector, gold));
+}
+
+TEST_CASE(fill_var_default_value)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape dv_shape{migraphx::shape::int64_type, {1}, {0}};
+    auto dv = mm->add_parameter("dv", dv_shape);
+    migraphx::shape data_shape{migraphx::shape::int64_type, {3, 4, 4}};
+    auto input = mm->add_parameter("x", data_shape);
+    mm->add_instruction(migraphx::make_op("fill"), dv, input);
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<int64_t> dv_data = {2};
+    std::vector<int64_t> input_data(48);
+    migraphx::parameter_map params;
+    params["x"]  = migraphx::argument(data_shape, input_data.data());
+    params["dv"] = migraphx::argument(dv_shape, dv_data.data());
+    auto result  = p.eval(params).back();
+    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_rms_range(results_vector, gold));
+}

test/ref/floor.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -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)

test/ref/greater.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 

test/ref/identity.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 

test/ref/if.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 

test/ref/im2col.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -40,14 +40,14 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     std::size_t channels = 1;
 
     std::vector<int32_t> weights(channels * f[0] * f[1]);
-    std::vector<int32_t> input(channels * size[0] * size[1]);
-    std::iota(input.begin(), input.end(), 0);
+    std::vector<int32_t> gold(channels * size[0] * size[1]);
+    std::iota(gold.begin(), gold.end(), 0);
 
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
     migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
-    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
+    auto l_image   = mm->add_literal(migraphx::literal{s_image, gold});
     auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
     mm->add_instruction(
         migraphx::make_op("im2col",
@@ -61,7 +61,7 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, input));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_no_pad_test)
@@ -91,14 +91,14 @@ TEST_CASE(im2col_3x3_no_pad_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
-                                4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};
+    std::vector<int> gold = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
+                             4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_stride_2_no_pad_test)
@@ -128,15 +128,15 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
-                                8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
-                                24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
+    std::vector<int> gold = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
+                             8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
+                             24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_channels_identity_test)
@@ -149,14 +149,14 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     std::size_t channels = 2;
 
     std::vector<int32_t> weights(channels * f[0] * f[1]);
-    std::vector<int32_t> input(channels * size[0] * size[1]);
-    std::iota(input.begin(), input.end(), 0);
+    std::vector<int32_t> gold(channels * size[0] * size[1]);
+    std::iota(gold.begin(), gold.end(), 0);
 
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
     migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
-    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
+    auto l_image   = mm->add_literal(migraphx::literal{s_image, gold});
     auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
     mm->add_instruction(
         migraphx::make_op("im2col",
@@ -170,7 +170,7 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, input));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_padding_test)
@@ -200,12 +200,12 @@ TEST_CASE(im2col_3x3_with_padding_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
-                                0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
+    std::vector<int> gold = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
+                             0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/isnan.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -45,8 +45,8 @@ TEST_CASE(isnan_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, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, correct));
+        std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+        EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     }
 
     // half test
@@ -64,8 +64,8 @@ TEST_CASE(isnan_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, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, correct));
+        std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+        EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
     }
 }
 
@@ -86,6 +86,6 @@ TEST_CASE(isnan_dyn_test)
     auto result  = p.eval(params0).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> correct = {0, 0, 1, 1, 0, 0};
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/leaky_relu.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -42,5 +42,5 @@ TEST_CASE(leaky_relu_test)
     std::vector<float> results_vector(3);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
     std::vector<float> gold = {-0.01f, 0.f, 1.f};
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/less.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 

test/ref/log.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -45,7 +45,7 @@ TEST_CASE(log_test)
     std::vector<float> gold = data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return logf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(log_dyn_test)
@@ -68,5 +68,5 @@ TEST_CASE(log_dyn_test)
     std::vector<float> gold = input_data;
     std::transform(
         gold.begin(), gold.end(), gold.begin(), [](float n) -> float { return logf(n); });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/logical_and.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -49,7 +49,7 @@ TEST_CASE(logical_and_test)
         data1.begin(), data1.end(), data2.begin(), gold.begin(), [](bool n1, bool n2) -> bool {
             return n1 and n2;
         });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(logical_and_dyn_test)
@@ -78,5 +78,5 @@ TEST_CASE(logical_and_dyn_test)
                    right_data.begin(),
                    gold.begin(),
                    [](bool n1, bool n2) -> bool { return n1 and n2; });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/logical_or.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -49,7 +49,7 @@ TEST_CASE(logical_or_test)
         data1.begin(), data1.end(), data2.begin(), gold.begin(), [](bool n1, bool n2) -> bool {
             return n1 or n2;
         });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(logical_or_dyn_test)
@@ -78,5 +78,5 @@ TEST_CASE(logical_or_dyn_test)
                    right_data.begin(),
                    gold.begin(),
                    [](bool n1, bool n2) -> bool { return n1 or n2; });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/logical_xor.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -49,7 +49,7 @@ TEST_CASE(logical_xor_test)
         data1.begin(), data1.end(), data2.begin(), gold.begin(), [](bool n1, bool n2) -> bool {
             return n1 ^ n2;
         });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }
 
 TEST_CASE(logical_xor_dyn_test)
@@ -78,5 +78,5 @@ TEST_CASE(logical_xor_dyn_test)
                    right_data.begin(),
                    gold.begin(),
                    [](bool n1, bool n2) -> bool { return n1 ^ n2; });
-    EXPECT(migraphx::verify::verify_range(results_vector, gold));
+    EXPECT(migraphx::verify::verify_rms_range(results_vector, gold));
 }

test/ref/logsoftmax.cpp

@@ -24,7 +24,7 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/onnx.hpp>
+#include <migraphx/program.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
 
@@ -61,7 +61,7 @@ TEST_CASE(logsoftmax_test_axis_0)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     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, s));
 }
 
 TEST_CASE(logsoftmax_test_axis_1)
@@ -95,7 +95,7 @@ TEST_CASE(logsoftmax_test_axis_1)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     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, s));
 }
 
 TEST_CASE(logsoftmax_test_axis_2)
@@ -129,7 +129,7 @@ TEST_CASE(logsoftmax_test_axis_2)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     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, s));
 }
 
 TEST_CASE(logsoftmax_test_axis_3)
@@ -163,5 +163,5 @@ TEST_CASE(logsoftmax_test_axis_3)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     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, s));
 }

test/ref/loop.cpp

@@ -21,15 +21,12 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#include <iostream>
-#include <vector>
-#include <cmath>
-#include <migraphx/literal.hpp>
 #include <migraphx/instruction.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/make_op.hpp>
 #include <migraphx/quantization.hpp>
 #include <migraphx/register_target.hpp>
 #include <migraphx/verify.hpp>
-#include <migraphx/make_op.hpp>
 
 #include "test.hpp"