fix the argument order, add atol,rtols etc.

src/driver/verify.cpp

@@ -22,6 +22,7 @@
  * THE SOFTWARE.
  */
 #include "verify.hpp"
+#include "migraphx/verify.hpp"
 #include "perf.hpp"
 
 #include <migraphx/register_target.hpp>
@@ -84,7 +85,7 @@ void verify_program(const std::string& name,
     std::size_t output_num = x.size();
     for(std::size_t i = 0; i < output_num; ++i)
     {
-        verify_args_with_threshold(name, x[i], y[i], threshold);
+        verify_args_with_threshold(name, x[i], y[i], verify::threshold{threshold});
     }
 }
 

src/include/migraphx/verify.hpp

@@ -189,7 +189,7 @@ double rms_range(const R1& r1, const R2& r2)
 }
 
 template <class R>
-double get_threshold(const R&, std::size_t tolerance = 80)
+double get_rms_tol(const R&, std::size_t tolerance = 80)
 {
     double threshold = std::numeric_limits<range_value<R>>::epsilon() * tolerance;
     return threshold;
@@ -214,13 +214,39 @@ struct expected
 template <class T>
 expected(const T&) -> expected<T>;
 
+struct threshold
+{
+    double rms_tol = 0.001;
+    double atol    = 0.001;
+    double rtol    = 0.001;
+};
+
+template <class R1, class R2>
+bool allclose(const R1& r1, const R2& r2, threshold thres)
+{
+    std::size_t n = range_distance(r1);
+    if(n == range_distance(r2))
+    {
+        auto idx = mismatch_idx(r1, r2, [&](auto x, auto y) {
+            return abs_diff(double(x), double(y)) > thres.atol + thres.rtol * std::abs(double(y));
+        });
+        if(idx < range_distance(r1))
+        {
+            return false;
+        }
+        return true;
+    }
+    else
+        return false;
+}
+
 template <class R1, class R2>
 bool verify_range(const R1& r1,
                   const R2& r2,
                   std::size_t tolerance = 80,
                   double* out_error     = nullptr)
 {
-    double threshold = get_threshold(r1, tolerance);
+    double threshold = get_rms_tol(r1, tolerance);
     auto error       = rms_range(r1, r2);
     if(out_error != nullptr)
         *out_error = error;
@@ -230,13 +256,14 @@ bool verify_range(const R1& r1,
 template <class R1, class R2>
 bool verify_range_with_threshold(const R1& r1,
                                  const expected<R2>& r2,
-                                 double threshold,
+                                 threshold tols    = threshold{},
                                  double* out_error = nullptr)
 {
-    auto error = rms_range(r1, r2.data());
+    auto rms_error = rms_range(r1, r2.data());
+    // auto ewise_verify = allclose(r1, r2.data(), tols);
     if(out_error != nullptr)
-        *out_error = error;
-    return error <= threshold;
+        *out_error = rms_error;
+    return rms_error <= tols.rms_tol;
 }
 
 // expected argument should be passed as second, but if it is passed as the first by mistake then
@@ -244,10 +271,10 @@ bool verify_range_with_threshold(const R1& r1,
 template <class R1, class R2>
 bool verify_range_with_threshold(const expected<R1>& r1,
                                  const R2& r2,
-                                 double threshold,
+                                 threshold tols    = threshold{},
                                  double* out_error = nullptr)
 {
-    return verify_range(r2, r1, threshold, out_error);
+    return verify_range(r2, r1, tols, out_error);
 }
 
 } // namespace verify

src/include/migraphx/verify_args.hpp

@@ -34,11 +34,11 @@ inline namespace MIGRAPHX_INLINE_NS {
 MIGRAPHX_EXPORT bool verify_args_with_threshold(const std::string& name,
                                                 const argument& ref_arg,
                                                 const argument& target_arg,
-                                                double threshold);
+                                                verify::threshold);
 
 MIGRAPHX_EXPORT bool verify_args(const std::string& name,
-                                 const argument& ref_arg,
                                  const argument& target_arg,
+                                 const argument& ref_arg,
                                  std::size_t tolerance = 80);
 
 } // namespace MIGRAPHX_INLINE_NS

src/verify_args.cpp

@@ -30,13 +30,12 @@ inline namespace MIGRAPHX_INLINE_NS {
 bool verify_args_with_threshold(const std::string& name,
                                 const argument& target_arg,
                                 const argument& ref_arg,
-                                double threshold)
+                                verify::threshold tols)
 {
     bool passed = true;
     visit_all(ref_arg, target_arg)([&](auto ref, auto target) {
         double error;
-        passed =
-            verify::verify_range_with_threshold(target, verify::expected{ref}, threshold, &error);
+        passed = verify::verify_range_with_threshold(target, verify::expected{ref}, tols, &error);
         if(not passed)
         {
             // TODO: Check for nans
@@ -95,13 +94,14 @@ bool verify_args_with_threshold(const std::string& name,
 }
 
 bool verify_args(const std::string& name,
-                 const argument& ref_arg,
                  const argument& target_arg,
+                 const argument& ref_arg,
                  std::size_t tolerance)
 {
-    double threshold = 0.001;
-    target_arg.visit([&](auto ta) { threshold = verify::get_threshold(ta, tolerance); });
-    return verify_args_with_threshold(name, target_arg, ref_arg, threshold);
+    double rms_tol = 0.001;
+    target_arg.visit([&](auto ta) { rms_tol = verify::get_rms_tol(ta, tolerance); });
+    verify::threshold tols{rms_tol};
+    return verify_args_with_threshold(name, target_arg, ref_arg, tols);
 }
 
 } // namespace MIGRAPHX_INLINE_NS

test/gpu/codegen_literal.cpp

@@ -80,7 +80,7 @@ TEST_CASE(mul_literal_round_test)
     migraphx::target gpu_t = migraphx::make_target("gpu");
     run_prog(p, gpu_t, m, gpu_result);
 
-    EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
+    EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/gpu/manage_host_buffer.cpp

@@ -53,7 +53,6 @@ TEST_CASE(host_same_buffer_copy)
     migraphx::parameter_map pp;
     std::vector<float> a_vec(ss.elements(), -1);
     std::vector<float> b_vec(ss.elements(), 2);
-    std::vector<float> c_vec(ss.elements(), 0);
     pp["a"] = migraphx::argument(ss, a_vec.data());
     pp["b"] = migraphx::argument(ss, b_vec.data());
     std::vector<float> gpu_result;
@@ -64,7 +63,8 @@ TEST_CASE(host_same_buffer_copy)
     auto result = p.eval(pp).back();
     std::vector<float> results_vector(ss.elements(), -1);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c_vec, results_vector));
+    std::vector<float> gold_vec(ss.elements(), 0);
+    EXPECT(migraphx::verify::verify_range(results_vector, gold_vec));
 }
 
 TEST_CASE(arguments_lifetime)

test/gpu/mlir.cpp

@@ -133,7 +133,7 @@ bool verify_mlir(const migraphx::module& mmlir)
     auto inputs = generate_params(ref);
 
     auto mlir = create_program_from_mlir(mmlir);
-    return migraphx::verify_args("mlir", run_ref(ref, inputs), run_gpu(mlir, inputs));
+    return migraphx::verify_args("mlir", run_gpu(mlir, inputs), run_ref(ref, inputs));
 }
 
 TEST_CASE(conv)

test/gpu/quantization.cpp

@@ -40,7 +40,6 @@
 TEST_CASE(gpu_target_copy)
 {
     migraphx::target gpu_t = migraphx::make_target("gpu");
-    migraphx::target ref_t = migraphx::make_target("ref");
     migraphx::shape s{migraphx::shape::int8_type, {2, 3, 4, 5}};
 
     auto ref_arg_orig  = migraphx::generate_argument(s, 0x123456L);
@@ -118,9 +117,12 @@ TEST_CASE(int8_quantization)
         // the regular pipeline uses the rewrite_quantization in the much
         // earlier stage.
         if(migraphx::gpu::mlir_enabled())
-            EXPECT(migraphx::verify::verify_range_with_threshold(gpu_result, migraphx::verify::expected{ref_result}, 0.01));
+            EXPECT(migraphx::verify::verify_range_with_threshold(
+                gpu_result,
+                migraphx::verify::expected{ref_result},
+                migraphx::verify::threshold{0.01}));
         else
-            EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
+            EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
     }
 }
 

test/onnx/verify_onnx.cpp

@@ -309,12 +309,12 @@ TEST_CASE(celu_verify_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> correct(6);
+    std::vector<float> gold(6);
     float alpha = 0.5;
-    std::transform(data.begin(), data.end(), correct.begin(), [&](auto x) {
+    std::transform(data.begin(), data.end(), gold.begin(), [&](auto x) {
         return std::max(0.0f, x) + std::min(0.0f, alpha * std::expm1(x / alpha));
     });
-    EXPECT(migraphx::verify::verify_range(result_vector, correct));
+    EXPECT(migraphx::verify::verify_range(result_vector, gold));
 }
 
 TEST_CASE(clip_args_type_mismatch)
@@ -374,11 +374,11 @@ TEST_CASE(spacetodepth_depthtospace_test)
     // space to depth
     auto p1 = migraphx::parse_onnx("spacetodepth_simple_test.onnx");
     p1.compile(migraphx::make_target("ref"));
-    std::vector<float> data_in(48);
-    std::iota(std::begin(data_in), std::end(data_in), 0);
+    std::vector<float> gold_data_in(48);
+    std::iota(std::begin(gold_data_in), std::end(gold_data_in), 0);
     migraphx::shape s_x_1{migraphx::shape::float_type, {1, 2, 4, 6}};
     migraphx::parameter_map pp1;
-    pp1["x"]     = migraphx::argument(s_x_1, data_in.data());
+    pp1["x"]     = migraphx::argument(s_x_1, gold_data_in.data());
     auto result1 = p1.eval(pp1).back();
     // depth to space
     auto p2 = migraphx::parse_onnx("depthtospace_simple_test.onnx");
@@ -388,7 +388,7 @@ TEST_CASE(spacetodepth_depthtospace_test)
     auto result2 = p2.eval(pp2).back();
     std::vector<float> result_vector2;
     result2.visit([&](auto output) { result_vector2.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(result_vector2, data_in));
+    EXPECT(migraphx::verify::verify_range(result_vector2, gold_data_in));
 }
 
 TEST_CASE(eyelike_verify_test)
@@ -405,8 +405,8 @@ TEST_CASE(eyelike_verify_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
-    EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
+    std::vector<float> gold_eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
+    EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
 }
 
 TEST_CASE(eyelike_verify_negk_test)
@@ -423,8 +423,8 @@ TEST_CASE(eyelike_verify_negk_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
-    EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
+    std::vector<float> gold_eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
+    EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
 }
 
 TEST_CASE(gather_elements)
@@ -1012,7 +1012,7 @@ TEST_CASE(lpnormalization_2norm)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> correct{0.f,
+    std::vector<float> gold{0.f,
                             2.f / 3.f,
                             -2.f / 3.f,
                             1.f / 3.f,
@@ -1024,7 +1024,7 @@ TEST_CASE(lpnormalization_2norm)
                             3.f / 5.f,
                             0.f,
                             0.f};
-    EXPECT(migraphx::verify::verify_range(result_vector, correct));
+    EXPECT(migraphx::verify::verify_range(result_vector, gold));
 }
 
 TEST_CASE(mean_broadcast_test)

test/quantization.cpp

@@ -1078,7 +1078,9 @@ TEST_CASE(int8_quantization_dot)
         run_prog(p, ref_t, m, no_quant_result);
 
         EXPECT(migraphx::verify::verify_range_with_threshold(
-            quant_result, migraphx::verify::expected{no_quant_result}, 0.003));
+            quant_result,
+            migraphx::verify::expected{no_quant_result},
+            migraphx::verify::threshold{0.003}));
     }
 }
 

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_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_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_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_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_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_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_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_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_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_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_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_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_range(results_vector, gold));
 }

test/ref/dot_op.cpp

@@ -56,7 +56,17 @@ void dot_2d_test()
                             1.53027987e+00,
                             -3.81407415e-04,
                             -3.29650255e-01};
-    std::vector<float> c = {-1.56327541e+00,
+
+    migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {4, 5}};
+    auto al = mm->add_literal(migraphx::literal{a_shape, a});
+    migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {5, 3}};
+    auto bl = mm->add_literal(migraphx::literal{b_shape, b});
+    mm->add_instruction(migraphx::make_op("dot"), al, bl);
+    p.compile(migraphx::make_target("ref"));
+    auto result = p.eval({}).back();
+    std::vector<T> results_vector;
+    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
+    std::vector<float> gold = {-1.56327541e+00,
                                -7.09570140e-01,
                                -5.37424982e-01,
                                -2.22994831e-01,
@@ -68,16 +78,7 @@ void dot_2d_test()
                                -1.29885596e+00,
                                2.16294914e+00,
                                -1.48101497e-01};
-    migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {4, 5}};
-    auto al = mm->add_literal(migraphx::literal{a_shape, a});
-    migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {5, 3}};
-    auto bl = mm->add_literal(migraphx::literal{b_shape, b});
-    mm->add_instruction(migraphx::make_op("dot"), al, bl);
-    p.compile(migraphx::make_target("ref"));
-    auto result = p.eval({}).back();
-    std::vector<T> results_vector;
-    result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 TEST_CASE_REGISTER(dot_2d_test<float>)
 TEST_CASE_REGISTER(dot_2d_test<double>)
@@ -107,7 +108,7 @@ void dot_4d_test()
                                1.53027987e+00,
                                -3.81407415e-04,
                                -3.29650255e-01};
-    std::vector<float> c = {-1.56327541e+00,
+    std::vector<float> gold = {-1.56327541e+00,
                                -7.09570140e-01,
                                -5.37424982e-01,
                                -2.22994831e-01,
@@ -128,7 +129,7 @@ void dot_4d_test()
     auto result = p.eval({}).back();
     std::vector<T> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 TEST_CASE_REGISTER(dot_4d_test<float>)
 TEST_CASE_REGISTER(dot_4d_test<double>)
@@ -166,7 +167,7 @@ TEST_CASE(dot_3D_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -183,7 +184,7 @@ TEST_CASE(dot_3D_test)
                                 0.40245487,
                                 1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test0)
@@ -242,7 +243,7 @@ TEST_CASE(dot_3D_C_test0)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -259,7 +260,7 @@ TEST_CASE(dot_3D_C_test0)
                                 0.40245487,
                                 1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test1)
@@ -309,7 +310,7 @@ TEST_CASE(dot_3D_C_test1)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -318,7 +319,7 @@ TEST_CASE(dot_3D_C_test1)
                                 -0.95536130,
                                 2.27996211};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_test1)
@@ -351,13 +352,13 @@ TEST_CASE(dot_4D_test1)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.26735861,  -4.30770895, 1.05257728,  -1.19954265, 0.50493170,
+    std::vector<float> gold = {0.26735861,  -4.30770895, 1.05257728,  -1.19954265, 0.50493170,
                                 -0.18729756, 1.09137941,  -1.09298312, 3.42956915,  -0.41681939,
                                 0.17833257,  0.26040336,  0.15351280,  1.87632715,  -0.63545406,
                                 -0.95467340, -1.74728628, -2.42477030, 0.76262372,  0.15539164,
                                 3.32281958,  0.96769613,  0.43727545,  2.43019906};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_test)
@@ -405,13 +406,13 @@ TEST_CASE(dot_4D_alpha_beta_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
+    std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
                                 0.50928632,  0.06919868, -0.80382802, -0.05125718, -0.06685650,
                                 -0.06972163, 0.32407764, 0.45677396,  0.25909489,  0.56911252,
                                 -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                 0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_C_test)
@@ -457,13 +458,13 @@ TEST_CASE(dot_4D_alpha_beta_C_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
+    std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
                                 0.50928632,  0.06919868, -0.80382802, -0.05125718, -0.06685650,
                                 -0.06972163, 0.32407764, 0.45677396,  0.25909489,  0.56911252,
                                 -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                 0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_2D_C_test0)
@@ -1202,7 +1203,7 @@ TEST_CASE(dot_dyn_2D_test)
     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> c = {-1.56327541e+00,
+    std::vector<float> gold = {-1.56327541e+00,
                                -7.09570140e-01,
                                -5.37424982e-01,
                                -2.22994831e-01,
@@ -1214,7 +1215,7 @@ TEST_CASE(dot_dyn_2D_test)
                                -1.29885596e+00,
                                2.16294914e+00,
                                -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(dot_dyn_4D_test)
@@ -1256,7 +1257,7 @@ TEST_CASE(dot_dyn_4D_test)
     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> c = {-1.56327541e+00,
+    std::vector<float> gold = {-1.56327541e+00,
                                -7.09570140e-01,
                                -5.37424982e-01,
                                -2.22994831e-01,
@@ -1268,7 +1269,7 @@ TEST_CASE(dot_dyn_4D_test)
                                -1.29885596e+00,
                                2.16294914e+00,
                                -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_1)

test/ref/im2col.cpp

@@ -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_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,
+    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_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_stride_2_no_pad_test)
@@ -128,7 +128,7 @@ 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,
+    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};
 
@@ -136,7 +136,7 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_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, correct));
+    EXPECT(migraphx::verify::verify_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_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,
+    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_range(results_vector, gold));
 }

test/ref/isnan.cpp

@@ -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_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_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_range(results_vector, gold));
 }

test/ref/multinomial.cpp

@@ -79,5 +79,5 @@ TEST_CASE(multinomial_test)
         return static_cast<double>(n) / res_dist_sum;
     });
     EXPECT(migraphx::verify::verify_range_with_threshold(
-        res_norm, migraphx::verify::expected{norm}, 0.01));
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::threshold{0.01}));
 }

test/ref/pooling.cpp

@@ -565,12 +565,6 @@ TEST_CASE(maxpool_test)
         -0.88503587, 0.6629802,   1.47319221,  -1.05829155, -0.97027361, -0.93187737, -1.39954746,
         -0.52359426, -0.14743951, 1.51522756,  0.2078452,   -1.28156149, -1.19363916, -0.78680223,
         -0.89094824, 1.30212069,  -0.77974445, -0.58411664, 0.48764706,  -0.67132682};
-    std::vector<float> c = {1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
-                            1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
-                            1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
-                            1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
-                            1.33624589, 1.16736257, 0.6126079,  1.36892557, 2.40126371, 1.53441942,
-                            0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 6, 6}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     mm->add_instruction(migraphx::make_op("pooling",
@@ -583,7 +577,15 @@ TEST_CASE(maxpool_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(36);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, c));
+    std::vector<float> gold = {
+        1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
+        1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
+        1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
+        1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
+        1.33624589, 1.16736257, 0.6126079,  1.36892557, 2.40126371, 1.53441942,
+        0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
+
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(maxpool_pad_test)
@@ -591,7 +593,6 @@ TEST_CASE(maxpool_pad_test)
     migraphx::program p;
     auto* mm             = p.get_main_module();
     std::vector<float> a = {-6, -5, -4, -3, -5, -1, 0, 1, 2, 3, 4, 5};
-    std::vector<float> c = {-4, -3, -4, -1, 2, 3, 4, 5};
     migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 3, 2}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     mm->add_instruction(migraphx::make_op("pooling",
@@ -611,8 +612,8 @@ TEST_CASE(maxpool_pad_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(8);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-
-    EXPECT(migraphx::verify::verify_range(results_vector, c));
+    std::vector<float> gold = {-4, -3, -4, -1, 2, 3, 4, 5};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(maxpool_rank3_test0)

test/ref/quant_convolution.cpp

@@ -47,7 +47,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int32_t> s = {4521,
+    std::vector<int32_t> gold = {4521,
                               7014,
                               7830,
                               11952,
@@ -65,7 +65,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
                               82746};
     std::vector<int32_t> 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_range(results_vector, gold));
 }
 
 TEST_CASE(quant_conv2d_padding_test)
@@ -84,7 +84,7 @@ TEST_CASE(quant_conv2d_padding_test)
         migraphx::make_op("quant_convolution", {{"padding", {1, 1}}, {"stride", {1, 1}}}), al, cl);
     p.compile(migraphx::make_target("ref"));
     auto result               = p.eval({}).back();
-    std::vector<int32_t> s = {
+    std::vector<int32_t> gold = {
         4521,  6753,  7014,  4635,  6858,  10197, 10548, 6939,  7830,  11601, 11952, 7839,  5007,
         7383,  7590,  4953,  10515, 15987, 16734, 11277, 16821, 25506, 26586, 17874, 19737, 29826,
         30906, 20718, 13593, 20505, 21198, 14187, 13161, 19281, 19542, 12699, 18522, 27045, 27396,
@@ -93,7 +93,7 @@ TEST_CASE(quant_conv2d_padding_test)
 
     std::vector<int32_t> 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_range(results_vector, gold));
 }
 
 TEST_CASE(quant_conv2d_test)
@@ -114,7 +114,7 @@ TEST_CASE(quant_conv2d_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int32_t> s = {10197,
+    std::vector<int32_t> gold = {10197,
                                  10548,
                                  11601,
                                  11952,
@@ -133,5 +133,5 @@ TEST_CASE(quant_conv2d_test)
 
     std::vector<int32_t> 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_range(results_vector, gold));
 }

test/ref/random_uniform.cpp

@@ -68,8 +68,9 @@ TEST_CASE(random_uniform_test)
     std::uniform_real_distribution<> dis(0.0, 1.0);
     std::vector<float> rand_samples(sample_size);
     std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range_with_threshold(
-        result_vec, migraphx::verify::expected{rand_samples}, 0.00001));
+    EXPECT(migraphx::verify::verify_range_with_threshold(result_vec,
+                                                         migraphx::verify::expected{rand_samples},
+                                                         migraphx::verify::threshold{0.00001}));
 }
 
 TEST_CASE(random_uniform_int_test)
@@ -103,9 +104,9 @@ TEST_CASE(random_uniform_int_test)
     // Compare result with the STL's mt19937 generator
     std::mt19937 gen(seed);
     std::uniform_int_distribution<uint16_t> dis;
-    std::vector<uint16_t> rand_samples(sample_size);
-    std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
+    std::vector<uint16_t> gold_rand_samples(sample_size);
+    std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
+    EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
 }
 
 TEST_CASE(random_uniform_dyn_test)
@@ -142,9 +143,9 @@ TEST_CASE(random_uniform_dyn_test)
     // Compare result with the STL's mt19937 generator
     std::mt19937 gen(seed);
     std::uniform_real_distribution<> dis(0.0, 1.0);
-    std::vector<float> rand_samples(sample_size);
-    std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
+    std::vector<float> gold_rand_samples(sample_size);
+    std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
+    EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
 }
 
 TEST_CASE(random_uniform_and_seed_test)

test/ref/reshape.cpp

@@ -33,52 +33,52 @@
 TEST_CASE(reshape_test0)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {8, 3, 1, 1};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     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, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_test1)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {1, 3, 4, 2};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     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, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_test2)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {1, 2, 3, 4};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     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, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_dyn_test)
@@ -91,13 +91,13 @@ TEST_CASE(reshape_dyn_test)
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
     p.compile(migraphx::make_target("ref"));
 
-    std::vector<float> data(48);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::parameter_map params;
     migraphx::shape input_fixed_shape{migraphx::shape::float_type, {2, 24, 1, 1}};
-    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    params["X"] = migraphx::argument(input_fixed_shape, gold.data());
     auto result = p.eval(params).back();
     std::vector<float> results_vector{};
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }