Added infrastructure for packed matrices

3 files changed, 30 insertions, 10 deletions

diff --git a/test/correctness/testblas.cc b/test/correctness/testblas.cc
index 839ac3b1..85e18381 100644
--- a/test/correctness/testblas.cc
+++ b/test/correctness/testblas.cc
@@ -57,12 +57,14 @@ TestBlas<T,U>::TestBlas(int argc, char *argv[], const bool silent,
   a_source_.resize(std::max(max_mat, max_matvec)*std::max(max_ld, max_matvec) + max_offset);
   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);
   PopulateVector(x_source_);
   PopulateVector(y_source_);
   PopulateVector(a_source_);
   PopulateVector(b_source_);
   PopulateVector(c_source_);
+  PopulateVector(ap_source_);
   PopulateVector(dot_source_);
 }
 
@@ -83,14 +85,16 @@ void TestBlas<T,U>::TestRegular(std::vector<Arguments<U>> &test_vector, const st
     auto a_mat1 = Buffer<T>(context_, args.a_size);
     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);
     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, dot1};
+    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, ap_mat1, dot1};
     auto status1 = run_reference_(args, buffers1, queue_);
 
     // Runs the CLBlast code
@@ -99,14 +103,16 @@ void TestBlas<T,U>::TestRegular(std::vector<Arguments<U>> &test_vector, const st
     auto a_mat2 = Buffer<T>(context_, args.a_size);
     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);
     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, dot2};
+    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, ap_mat2, dot2};
     auto status2 = run_routine_(args, buffers2, queue_);
 
     // Tests for equality of the two status codes
@@ -155,29 +161,33 @@ void TestBlas<T,U>::TestInvalid(std::vector<Arguments<U>> &test_vector, const st
     auto a1 = clCreateBuffer(context_(), CL_MEM_READ_WRITE, args.a_size*sizeof(T), nullptr,nullptr);
     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 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 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 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);
 
     // Runs the two routines
-    auto buffers1 = Buffers<T>{x_vec1, y_vec1, a_mat1, b_mat1, c_mat1, dot1};
-    auto buffers2 = Buffers<T>{x_vec2, y_vec2, a_mat2, b_mat2, c_mat2, dot2};
+    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 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 d4e6f24b..bfd1763c 100644
--- a/test/correctness/testblas.h
+++ b/test/correctness/testblas.h
@@ -91,6 +91,7 @@ class TestBlas: public Tester<T,U> {
   std::vector<T> a_source_;
   std::vector<T> b_source_;
   std::vector<T> c_source_;
+  std::vector<T> ap_source_;
   std::vector<T> dot_source_;
   
   // The routine-specific functions passed to the tester
@@ -140,6 +141,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
   auto a_offsets = std::vector<size_t>{args.a_offset};
   auto b_offsets = std::vector<size_t>{args.b_offset};
   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 alphas = std::vector<U>{args.alpha};
   auto betas = std::vector<U>{args.beta};
@@ -148,6 +150,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
   auto a_sizes = std::vector<size_t>{args.a_size};
   auto b_sizes = std::vector<size_t>{args.b_size};
   auto c_sizes = std::vector<size_t>{args.c_size};
+  auto ap_sizes = std::vector<size_t>{args.ap_size};
 
   // Sets the dimensions of the matrices or vectors depending on the BLAS level
   auto dimensions = (C::BLASLevel() == 3) ? tester.kMatrixDims :
@@ -177,6 +180,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
     if (option == kArgAOffset) { a_offsets = tester.kOffsets; }
     if (option == kArgBOffset) { b_offsets = tester.kOffsets; }
     if (option == kArgCOffset) { c_offsets = tester.kOffsets; }
+    if (option == kArgAPOffset) { ap_offsets = tester.kOffsets; }
     if (option == kArgDotOffset) { dot_offsets = tester.kOffsets; }
     if (option == kArgAlpha) { alphas = tester.kAlphaValues; }
     if (option == kArgBeta) { betas = tester.kBetaValues; }
@@ -186,6 +190,7 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
     if (option == kArgAOffset) { a_sizes = tester.kMatSizes; }
     if (option == kArgBOffset) { b_sizes = tester.kMatSizes; }
     if (option == kArgCOffset) { c_sizes = tester.kMatSizes; }
+    if (option == kArgAPOffset) { ap_sizes = tester.kMatSizes; }
   }
 
   // Loops over the test-cases from a data-layout point of view
@@ -214,11 +219,13 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
                                       for (auto &b_offset: b_offsets) { r_args.b_offset = b_offset;
                                         for (auto &c_ld: c_lds) { r_args.c_ld = c_ld;
                                           for (auto &c_offset: c_offsets) { r_args.c_offset = c_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 &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);
+                                                  }
                                                 }
                                               }
                                             }
@@ -248,7 +255,9 @@ void RunTests(int argc, char *argv[], const bool silent, const std::string &name
                   for (auto &a_size: a_sizes) { i_args.a_size = a_size;
                     for (auto &b_size: b_sizes) { i_args.b_size = b_size;
                       for (auto &c_size: c_sizes) { i_args.c_size = c_size;
-                        invalid_test_vector.push_back(i_args);
+                        for (auto &ap_size: ap_sizes) { i_args.ap_size = ap_size;
+                          invalid_test_vector.push_back(i_args);
+                        }
                       }
                     }
                   }
diff --git a/test/correctness/tester.cc b/test/correctness/tester.cc
index b1a58102..350865f0 100644
--- a/test/correctness/tester.cc
+++ b/test/correctness/tester.cc
@@ -150,6 +150,7 @@ void Tester<T,U>::TestEnd() {
       if (o == kArgAOffset)  { fprintf(stdout, "%s=%lu ", kArgAOffset, entry.args.a_offset);}
       if (o == kArgBOffset)  { fprintf(stdout, "%s=%lu ", kArgBOffset, entry.args.b_offset);}
       if (o == kArgCOffset)  { fprintf(stdout, "%s=%lu ", kArgCOffset, entry.args.c_offset);}
+      if (o == kArgAPOffset) { fprintf(stdout, "%s=%lu ", kArgAPOffset, entry.args.ap_offset);}
       if (o == kArgDotOffset){ fprintf(stdout, "%s=%lu ", kArgDotOffset, entry.args.dot_offset);}
     }
     fprintf(stdout, "\n");