Added preliminary support for the xNRM2 routines

2 files changed, 23 insertions, 19 deletions

diff --git a/test/correctness/testblas.cc b/test/correctness/testblas.cc
index febd7504..1329b2c5 100644
--- a/test/correctness/testblas.cc
+++ b/test/correctness/testblas.cc
@@ -58,14 +58,14 @@ TestBlas<T,U>::TestBlas(int argc, char *argv[], const bool silent,
   b_source_.resize(std::max(max_mat, max_matvec)*std::max(max_ld, max_matvec) + max_offset);
   c_source_.resize(std::max(max_mat, max_matvec)*std::max(max_ld, max_matvec) + max_offset);
   ap_source_.resize(std::max(max_mat, max_matvec)*std::max(max_mat, max_matvec) + max_offset);
-  dot_source_.resize(std::max(max_mat, max_matvec) + max_offset);
+  scalar_source_.resize(std::max(max_mat, max_matvec) + max_offset);
   PopulateVector(x_source_);
   PopulateVector(y_source_);
   PopulateVector(a_source_);
   PopulateVector(b_source_);
   PopulateVector(c_source_);
   PopulateVector(ap_source_);
-  PopulateVector(dot_source_);
+  PopulateVector(scalar_source_);
 }
 
 // ===============================================================================================
@@ -86,15 +86,15 @@ void TestBlas<T,U>::TestRegular(std::vector<Arguments<U>> &test_vector, const st
     auto b_mat1 = Buffer<T>(context_, args.b_size);
     auto c_mat1 = Buffer<T>(context_, args.c_size);
     auto ap_mat1 = Buffer<T>(context_, args.ap_size);
-    auto dot1 = Buffer<T>(context_, args.dot_size);
+    auto scalar1 = Buffer<T>(context_, args.scalar_size);
     x_vec1.Write(queue_, args.x_size, x_source_);
     y_vec1.Write(queue_, args.y_size, y_source_);
     a_mat1.Write(queue_, args.a_size, a_source_);
     b_mat1.Write(queue_, args.b_size, b_source_);
     c_mat1.Write(queue_, args.c_size, c_source_);
     ap_mat1.Write(queue_, args.ap_size, ap_source_);
-    dot1.Write(queue_, args.dot_size, dot_source_);
-    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, ap_mat1, dot1};
+    scalar1.Write(queue_, args.scalar_size, scalar_source_);
+    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, ap_mat1, scalar1};
     auto status1 = run_reference_(args, buffers1, queue_);
 
     // Runs the CLBlast code
@@ -104,15 +104,15 @@ void TestBlas<T,U>::TestRegular(std::vector<Arguments<U>> &test_vector, const st
     auto b_mat2 = Buffer<T>(context_, args.b_size);
     auto c_mat2 = Buffer<T>(context_, args.c_size);
     auto ap_mat2 = Buffer<T>(context_, args.ap_size);
-    auto dot2 = Buffer<T>(context_, args.dot_size);
+    auto scalar2 = Buffer<T>(context_, args.scalar_size);
     x_vec2.Write(queue_, args.x_size, x_source_);
     y_vec2.Write(queue_, args.y_size, y_source_);
     a_mat2.Write(queue_, args.a_size, a_source_);
     b_mat2.Write(queue_, args.b_size, b_source_);
     c_mat2.Write(queue_, args.c_size, c_source_);
     ap_mat2.Write(queue_, args.ap_size, ap_source_);
-    dot2.Write(queue_, args.dot_size, dot_source_);
-    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, ap_mat2, dot2};
+    scalar2.Write(queue_, args.scalar_size, scalar_source_);
+    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, ap_mat2, scalar2};
     auto status2 = run_routine_(args, buffers2, queue_);
 
     // Tests for equality of the two status codes
@@ -162,32 +162,32 @@ void TestBlas<T,U>::TestInvalid(std::vector<Arguments<U>> &test_vector, const st
     auto b1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.b_size*sizeof(T), nullptr,nullptr);
     auto c1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.c_size*sizeof(T), nullptr,nullptr);
     auto ap1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.ap_size*sizeof(T), nullptr,nullptr);
-    auto d1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.dot_size*sizeof(T), nullptr,nullptr);
+    auto d1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.scalar_size*sizeof(T), nullptr,nullptr);
     auto x_vec1 = Buffer<T>(x1);
     auto y_vec1 = Buffer<T>(y1);
     auto a_mat1 = Buffer<T>(a1);
     auto b_mat1 = Buffer<T>(b1);
     auto c_mat1 = Buffer<T>(c1);
     auto ap_mat1 = Buffer<T>(ap1);
-    auto dot1 = Buffer<T>(d1);
+    auto scalar1 = Buffer<T>(d1);
     auto x2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.x_size*sizeof(T), nullptr,nullptr);
     auto y2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.y_size*sizeof(T), nullptr,nullptr);
     auto a2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.a_size*sizeof(T), nullptr,nullptr);
     auto b2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.b_size*sizeof(T), nullptr,nullptr);
     auto c2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.c_size*sizeof(T), nullptr,nullptr);
     auto ap2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.ap_size*sizeof(T), nullptr,nullptr);
-    auto d2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.dot_size*sizeof(T), nullptr,nullptr);
+    auto d2 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.scalar_size*sizeof(T), nullptr,nullptr);
     auto x_vec2 = Buffer<T>(x2);
     auto y_vec2 = Buffer<T>(y2);
     auto a_mat2 = Buffer<T>(a2);
     auto b_mat2 = Buffer<T>(b2);
     auto c_mat2 = Buffer<T>(c2);
     auto ap_mat2 = Buffer<T>(ap2);
-    auto dot2 = Buffer<T>(d2);
+    auto scalar2 = Buffer<T>(d2);
 
     // Runs the two routines
-    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, ap_mat1, dot1};
-    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, ap_mat2, dot2};
+    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, ap_mat1, scalar1};
+    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, ap_mat2, scalar2};
     auto status1 = run_reference_(args, buffers1, queue_);
     auto status2 = run_routine_(args, buffers2, queue_);
 
diff --git a/test/correctness/testblas.h b/test/correctness/testblas.h
index bfd1763c..7c9032bd 100644
--- a/test/correctness/testblas.h
+++ b/test/correctness/testblas.h
@@ -92,7 +92,7 @@ class TestBlas: public Tester<T,U> {
   std::vector<T> b_source_;
   std::vector<T> c_source_;
   std::vector<T> ap_source_;
-  std::vector<T> dot_source_;
+  std::vector<T> scalar_source_;
   
   // The routine-specific functions passed to the tester
   Routine run_routine_;
@@ -143,6 +143,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
   auto c_offsets = std::vector<size_t>{args.c_offset};
   auto ap_offsets = std::vector<size_t>{args.ap_offset};
   auto dot_offsets = std::vector<size_t>{args.dot_offset};
+  auto nrm2_offsets = std::vector<size_t>{args.nrm2_offset};
   auto alphas = std::vector<U>{args.alpha};
   auto betas = std::vector<U>{args.beta};
   auto x_sizes = std::vector<size_t>{args.x_size};
@@ -182,6 +183,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
     if (option == kArgCOffset) { c_offsets = tester.kOffsets; }
     if (option == kArgAPOffset) { ap_offsets = tester.kOffsets; }
     if (option == kArgDotOffset) { dot_offsets = tester.kOffsets; }
+    if (option == kArgNrm2Offset) { nrm2_offsets = tester.kOffsets; }
     if (option == kArgAlpha) { alphas = tester.kAlphaValues; }
     if (option == kArgBeta) { betas = tester.kBetaValues; }
 
@@ -221,10 +223,12 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
                                           for (auto &c_offset: c_offsets) { r_args.c_offset = c_offset;
                                             for (auto &ap_offset: ap_offsets) { r_args.ap_offset = ap_offset;
                                               for (auto &dot_offset: dot_offsets) { r_args.dot_offset = dot_offset;
-                                                for (auto &alpha: alphas) { r_args.alpha = alpha;
-                                                  for (auto &beta: betas) { r_args.beta = beta;
-                                                    C::SetSizes(r_args);
-                                                    regular_test_vector.push_back(r_args);
+                                                for (auto &nrm2_offset: nrm2_offsets) { r_args.nrm2_offset = nrm2_offset;
+                                                  for (auto &alpha: alphas) { r_args.alpha = alpha;
+                                                    for (auto &beta: betas) { r_args.beta = beta;
+                                                      C::SetSizes(r_args);
+                                                      regular_test_vector.push_back(r_args);
+                                                    }
                                                   }
                                                 }
                                               }