Added reference implementations for performance-testing against cuBLAS

48 files changed, 571 insertions, 4 deletions

diff --git a/test/correctness/tester.cpp b/test/correctness/tester.cpp
index b352c1aa..d1f3cbb2 100644
--- a/test/correctness/tester.cpp
+++ b/test/correctness/tester.cpp
@@ -117,9 +117,15 @@ Tester<T,U>::Tester(const std::vector<std::string> &arguments, const bool silent
   options_ = options;
 
   // Determines which reference is the default
-  auto default_clblas = 0;
-  auto default_cblas = 0;
-  auto default_cublas = 0;
+  #if defined(CLBLAST_REF_CBLAS)
+      auto default_cblas = 0;
+  #endif
+  #if defined(CLBLAST_REF_CLBLAS)
+      auto default_clblas = 0;
+  #endif
+  #if defined(CLBLAST_REF_CUBLAS)
+      auto default_cublas = 0;
+  #endif
   #if defined(CLBLAST_REF_CBLAS)
     default_cblas = 1;
   #elif defined(CLBLAST_REF_CLBLAS)
diff --git a/test/routines/common.hpp b/test/routines/common.hpp
index 1abf5528..9708288a 100644
--- a/test/routines/common.hpp
+++ b/test/routines/common.hpp
@@ -25,8 +25,9 @@
 #ifdef CLBLAST_REF_CBLAS
   #include "test/wrapper_cblas.hpp"
 #endif
+#include "test/wrapper_cuda.hpp"
 #ifdef CLBLAST_REF_CUBLAS
-  #include "test/wrapper_cuda.hpp"
+  #include "test/wrapper_cublas.hpp"
 #endif
 
 // =================================================================================================
diff --git a/test/routines/level1/xamax.hpp b/test/routines/level1/xamax.hpp
index fccefc73..dcd48a47 100644
--- a/test/routines/level1/xamax.hpp
+++ b/test/routines/level1/xamax.hpp
@@ -103,6 +103,16 @@ class TestXamax {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXamax(args.n,
+                                buffers.scalar, args.imax_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xasum.hpp b/test/routines/level1/xasum.hpp
index f0fca4d3..e7e41fe5 100644
--- a/test/routines/level1/xasum.hpp
+++ b/test/routines/level1/xasum.hpp
@@ -103,6 +103,16 @@ class TestXasum {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXasum(args.n,
+                                buffers.scalar, args.asum_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xaxpy.hpp b/test/routines/level1/xaxpy.hpp
index 8426d739..98f0e380 100644
--- a/test/routines/level1/xaxpy.hpp
+++ b/test/routines/level1/xaxpy.hpp
@@ -104,6 +104,16 @@ class TestXaxpy {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXaxpy(args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level1/xcopy.hpp b/test/routines/level1/xcopy.hpp
index d1e7f49e..65e498ee 100644
--- a/test/routines/level1/xcopy.hpp
+++ b/test/routines/level1/xcopy.hpp
@@ -103,6 +103,16 @@ class TestXcopy {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXcopy(args.n,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level1/xdot.hpp b/test/routines/level1/xdot.hpp
index cb3d7979..c95b16ef 100644
--- a/test/routines/level1/xdot.hpp
+++ b/test/routines/level1/xdot.hpp
@@ -110,6 +110,17 @@ class TestXdot {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXdot(args.n,
+                               buffers.scalar, args.dot_offset,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xdotc.hpp b/test/routines/level1/xdotc.hpp
index 10ecbda6..0c99be25 100644
--- a/test/routines/level1/xdotc.hpp
+++ b/test/routines/level1/xdotc.hpp
@@ -110,6 +110,17 @@ class TestXdotc {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXdotc(args.n,
+                                buffers.scalar, args.dot_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xdotu.hpp b/test/routines/level1/xdotu.hpp
index 6efd270e..bf6bcd80 100644
--- a/test/routines/level1/xdotu.hpp
+++ b/test/routines/level1/xdotu.hpp
@@ -110,6 +110,17 @@ class TestXdotu {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXdotu(args.n,
+                                buffers.scalar, args.dot_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xnrm2.hpp b/test/routines/level1/xnrm2.hpp
index 0ba24b13..096604d1 100644
--- a/test/routines/level1/xnrm2.hpp
+++ b/test/routines/level1/xnrm2.hpp
@@ -103,6 +103,16 @@ class TestXnrm2 {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXnrm2(args.n,
+                                buffers.scalar, args.nrm2_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.scalar_size, static_cast<T>(0));
diff --git a/test/routines/level1/xscal.hpp b/test/routines/level1/xscal.hpp
index e7db434e..09b53839 100644
--- a/test/routines/level1/xscal.hpp
+++ b/test/routines/level1/xscal.hpp
@@ -97,6 +97,15 @@ class TestXscal {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXscal(args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size, static_cast<T>(0));
diff --git a/test/routines/level1/xswap.hpp b/test/routines/level1/xswap.hpp
index 64feb744..0d6fe451 100644
--- a/test/routines/level1/xswap.hpp
+++ b/test/routines/level1/xswap.hpp
@@ -103,6 +103,16 @@ class TestXswap {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXswap(args.n,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size + args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xgbmv.hpp b/test/routines/level2/xgbmv.hpp
index fb36d7f2..77abcfff 100644
--- a/test/routines/level2/xgbmv.hpp
+++ b/test/routines/level2/xgbmv.hpp
@@ -123,6 +123,19 @@ class TestXgbmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXgbmv(args.layout,
+                                convertToCUBLAS(args.a_transpose),
+                                args.m, args.n, args.kl, args.ku, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xgemv.hpp b/test/routines/level2/xgemv.hpp
index 4654838e..c0c59152 100644
--- a/test/routines/level2/xgemv.hpp
+++ b/test/routines/level2/xgemv.hpp
@@ -123,6 +123,19 @@ class TestXgemv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXgemv(args.layout,
+                                convertToCUBLAS(args.a_transpose),
+                                args.m, args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xger.hpp b/test/routines/level2/xger.hpp
index 9d1dec13..7fe37e1a 100644
--- a/test/routines/level2/xger.hpp
+++ b/test/routines/level2/xger.hpp
@@ -117,6 +117,18 @@ class TestXger {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXger(args.layout,
+                               args.m, args.n, args.alpha,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.y_vec, args.y_offset, args.y_inc,
+                               buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xgerc.hpp b/test/routines/level2/xgerc.hpp
index efa72744..b50cf672 100644
--- a/test/routines/level2/xgerc.hpp
+++ b/test/routines/level2/xgerc.hpp
@@ -117,6 +117,18 @@ class TestXgerc {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXgerc(args.layout,
+                                args.m, args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xgeru.hpp b/test/routines/level2/xgeru.hpp
index cb14636e..1ba83107 100644
--- a/test/routines/level2/xgeru.hpp
+++ b/test/routines/level2/xgeru.hpp
@@ -117,6 +117,18 @@ class TestXgeru {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXgeru(args.layout,
+                                args.m, args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xhbmv.hpp b/test/routines/level2/xhbmv.hpp
index f41cc572..2faf86d9 100644
--- a/test/routines/level2/xhbmv.hpp
+++ b/test/routines/level2/xhbmv.hpp
@@ -117,6 +117,19 @@ class TestXhbmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhbmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.kl, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xhemv.hpp b/test/routines/level2/xhemv.hpp
index 9f5aca00..b2b6b337 100644
--- a/test/routines/level2/xhemv.hpp
+++ b/test/routines/level2/xhemv.hpp
@@ -117,6 +117,19 @@ class TestXhemv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhemv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xher.hpp b/test/routines/level2/xher.hpp
index ef0afd1c..980e8d8b 100644
--- a/test/routines/level2/xher.hpp
+++ b/test/routines/level2/xher.hpp
@@ -110,6 +110,18 @@ class TestXher {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXher(args.layout,
+                               convertToCUBLAS(args.triangle),
+                               args.n, args.alpha,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xher2.hpp b/test/routines/level2/xher2.hpp
index d4b06c49..e60486a8 100644
--- a/test/routines/level2/xher2.hpp
+++ b/test/routines/level2/xher2.hpp
@@ -117,6 +117,19 @@ class TestXher2 {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXher2(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xhpmv.hpp b/test/routines/level2/xhpmv.hpp
index 52f70dc9..40ec5475 100644
--- a/test/routines/level2/xhpmv.hpp
+++ b/test/routines/level2/xhpmv.hpp
@@ -117,6 +117,19 @@ class TestXhpmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhpmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.ap_mat, args.ap_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xhpr.hpp b/test/routines/level2/xhpr.hpp
index 39112e49..8148c253 100644
--- a/test/routines/level2/xhpr.hpp
+++ b/test/routines/level2/xhpr.hpp
@@ -110,6 +110,18 @@ class TestXhpr {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhpr(args.layout,
+                               convertToCUBLAS(args.triangle),
+                               args.n, args.alpha,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.ap_mat, args.ap_offset);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.ap_size, static_cast<T>(0));
diff --git a/test/routines/level2/xhpr2.hpp b/test/routines/level2/xhpr2.hpp
index 21f0970a..651989a4 100644
--- a/test/routines/level2/xhpr2.hpp
+++ b/test/routines/level2/xhpr2.hpp
@@ -117,6 +117,19 @@ class TestXhpr2 {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhpr2(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.ap_mat, args.ap_offset);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.ap_size, static_cast<T>(0));
diff --git a/test/routines/level2/xsbmv.hpp b/test/routines/level2/xsbmv.hpp
index 94e60dd2..efcdbe34 100644
--- a/test/routines/level2/xsbmv.hpp
+++ b/test/routines/level2/xsbmv.hpp
@@ -117,6 +117,19 @@ class TestXsbmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsbmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.kl, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xspmv.hpp b/test/routines/level2/xspmv.hpp
index 02bfd4e3..c7d3d348 100644
--- a/test/routines/level2/xspmv.hpp
+++ b/test/routines/level2/xspmv.hpp
@@ -117,6 +117,19 @@ class TestXspmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXspmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.ap_mat, args.ap_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xspr.hpp b/test/routines/level2/xspr.hpp
index 9d992eb2..8d50074c 100644
--- a/test/routines/level2/xspr.hpp
+++ b/test/routines/level2/xspr.hpp
@@ -110,6 +110,18 @@ class TestXspr {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXspr(args.layout,
+                               convertToCUBLAS(args.triangle),
+                               args.n, args.alpha,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.ap_mat, args.ap_offset);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.ap_size, static_cast<T>(0));
diff --git a/test/routines/level2/xspr2.hpp b/test/routines/level2/xspr2.hpp
index 520bf412..2ee9538a 100644
--- a/test/routines/level2/xspr2.hpp
+++ b/test/routines/level2/xspr2.hpp
@@ -117,6 +117,19 @@ class TestXspr2 {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXspr2(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.ap_mat, args.ap_offset);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.ap_size, static_cast<T>(0));
diff --git a/test/routines/level2/xsymv.hpp b/test/routines/level2/xsymv.hpp
index 130fee49..9411fa8d 100644
--- a/test/routines/level2/xsymv.hpp
+++ b/test/routines/level2/xsymv.hpp
@@ -117,6 +117,19 @@ class TestXsymv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsymv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc, args.beta,
+                                buffers.y_vec, args.y_offset, args.y_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/level2/xsyr.hpp b/test/routines/level2/xsyr.hpp
index 2eb07f9b..8c62f586 100644
--- a/test/routines/level2/xsyr.hpp
+++ b/test/routines/level2/xsyr.hpp
@@ -110,6 +110,18 @@ class TestXsyr {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsyr(args.layout,
+                               convertToCUBLAS(args.triangle),
+                               args.n, args.alpha,
+                               buffers.x_vec, args.x_offset, args.x_inc,
+                               buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xsyr2.hpp b/test/routines/level2/xsyr2.hpp
index 5c3598c5..80838174 100644
--- a/test/routines/level2/xsyr2.hpp
+++ b/test/routines/level2/xsyr2.hpp
@@ -117,6 +117,19 @@ class TestXsyr2 {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsyr2(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                args.n, args.alpha,
+                                buffers.x_vec, args.x_offset, args.x_inc,
+                                buffers.y_vec, args.y_offset, args.y_inc,
+                                buffers.a_mat, args.a_offset, args.a_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.a_size, static_cast<T>(0));
diff --git a/test/routines/level2/xtbmv.hpp b/test/routines/level2/xtbmv.hpp
index 7ef67424..9aff2cea 100644
--- a/test/routines/level2/xtbmv.hpp
+++ b/test/routines/level2/xtbmv.hpp
@@ -113,6 +113,20 @@ class TestXtbmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtbmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.n, args.kl,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size, static_cast<T>(0));
diff --git a/test/routines/level2/xtpmv.hpp b/test/routines/level2/xtpmv.hpp
index 6cea7061..e950b892 100644
--- a/test/routines/level2/xtpmv.hpp
+++ b/test/routines/level2/xtpmv.hpp
@@ -113,6 +113,20 @@ class TestXtpmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtpmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.n,
+                                buffers.ap_mat, args.ap_offset,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size, static_cast<T>(0));
diff --git a/test/routines/level2/xtrmv.hpp b/test/routines/level2/xtrmv.hpp
index 7c97c966..a773b1ca 100644
--- a/test/routines/level2/xtrmv.hpp
+++ b/test/routines/level2/xtrmv.hpp
@@ -113,6 +113,20 @@ class TestXtrmv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtrmv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.n,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size, static_cast<T>(0));
diff --git a/test/routines/level2/xtrsv.hpp b/test/routines/level2/xtrsv.hpp
index 18a3cef5..4428271a 100644
--- a/test/routines/level2/xtrsv.hpp
+++ b/test/routines/level2/xtrsv.hpp
@@ -128,6 +128,20 @@ class TestXtrsv {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtrsv(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.n,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.x_vec, args.x_offset, args.x_inc);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.x_size, static_cast<T>(0));
diff --git a/test/routines/level3/xgemm.hpp b/test/routines/level3/xgemm.hpp
index d6ad98f9..36fa2f43 100644
--- a/test/routines/level3/xgemm.hpp
+++ b/test/routines/level3/xgemm.hpp
@@ -127,6 +127,20 @@ class TestXgemm {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXgemm(args.layout,
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.b_transpose),
+                                args.m, args.n, args.k, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.b_mat, args.b_offset, args.b_ld, args.beta,
+                                buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xhemm.hpp b/test/routines/level3/xhemm.hpp
index beadf62d..9400a1fc 100644
--- a/test/routines/level3/xhemm.hpp
+++ b/test/routines/level3/xhemm.hpp
@@ -127,6 +127,20 @@ class TestXhemm {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXhemm(args.layout,
+                                convertToCUBLAS(args.side),
+                                convertToCUBLAS(args.triangle),
+                                args.m, args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.b_mat, args.b_offset, args.b_ld, args.beta,
+                                buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xher2k.hpp b/test/routines/level3/xher2k.hpp
index b5d22579..b341c4d7 100644
--- a/test/routines/level3/xher2k.hpp
+++ b/test/routines/level3/xher2k.hpp
@@ -128,6 +128,20 @@ class TestXher2k {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXher2k(args.layout,
+                                 convertToCUBLAS(args.triangle),
+                                 convertToCUBLAS(args.a_transpose),
+                                 args.n, args.k, alpha2,
+                                 buffers.a_mat, args.a_offset, args.a_ld,
+                                 buffers.b_mat, args.b_offset, args.b_ld, args.beta,
+                                 buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xherk.hpp b/test/routines/level3/xherk.hpp
index 558f4e76..676d5286 100644
--- a/test/routines/level3/xherk.hpp
+++ b/test/routines/level3/xherk.hpp
@@ -115,6 +115,19 @@ class TestXherk {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXherk(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                args.n, args.k, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld, args.beta,
+                                buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xsymm.hpp b/test/routines/level3/xsymm.hpp
index 704a8f9e..4888091b 100644
--- a/test/routines/level3/xsymm.hpp
+++ b/test/routines/level3/xsymm.hpp
@@ -127,6 +127,20 @@ class TestXsymm {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsymm(args.layout,
+                                convertToCUBLAS(args.side),
+                                convertToCUBLAS(args.triangle),
+                                args.m, args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.b_mat, args.b_offset, args.b_ld, args.beta,
+                                buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xsyr2k.hpp b/test/routines/level3/xsyr2k.hpp
index c321b9cf..2fc4090c 100644
--- a/test/routines/level3/xsyr2k.hpp
+++ b/test/routines/level3/xsyr2k.hpp
@@ -125,6 +125,20 @@ class TestXsyr2k {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsyr2k(args.layout,
+                                 convertToCUBLAS(args.triangle),
+                                 convertToCUBLAS(args.a_transpose),
+                                 args.n, args.k, args.alpha,
+                                 buffers.a_mat, args.a_offset, args.a_ld,
+                                 buffers.b_mat, args.b_offset, args.b_ld, args.beta,
+                                 buffers.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xsyrk.hpp b/test/routines/level3/xsyrk.hpp
index 00a3013d..2ee24a2e 100644
--- a/test/routines/level3/xsyrk.hpp
+++ b/test/routines/level3/xsyrk.hpp
@@ -115,6 +115,19 @@ class TestXsyrk {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXsyrk(args.layout,
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                args.n, args.k, args.alpha,
+                                buffer.a_mat, args.a_offset, args.a_ld, args.beta,
+                                buffer.c_mat, args.c_offset, args.c_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/level3/xtrmm.hpp b/test/routines/level3/xtrmm.hpp
index 660001df..abf77db9 100644
--- a/test/routines/level3/xtrmm.hpp
+++ b/test/routines/level3/xtrmm.hpp
@@ -119,6 +119,21 @@ class TestXtrmm {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtrmm(args.layout,
+                                convertToCUBLAS(args.side),
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.m, args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.b_mat, args.b_offset, args.b_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.b_size, static_cast<T>(0));
diff --git a/test/routines/level3/xtrsm.hpp b/test/routines/level3/xtrsm.hpp
index 9e8b9565..10b216cc 100644
--- a/test/routines/level3/xtrsm.hpp
+++ b/test/routines/level3/xtrsm.hpp
@@ -130,6 +130,21 @@ class TestXtrsm {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      auto status = cublasXtrsm(args.layout,
+                                convertToCUBLAS(args.side),
+                                convertToCUBLAS(args.triangle),
+                                convertToCUBLAS(args.a_transpose),
+                                convertToCUBLAS(args.diagonal),
+                                args.m, args.n, args.alpha,
+                                buffers.a_mat, args.a_offset, args.a_ld,
+                                buffers.b_mat, args.b_offset, args.b_ld);
+      if (status == CUBLAS_STATUS_SUCCESS) { return StatusCode::kSuccess; } else { return StatusCode::kUnknownError; }
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.b_size, static_cast<T>(0));
diff --git a/test/routines/levelx/xaxpybatched.hpp b/test/routines/levelx/xaxpybatched.hpp
index d8b3837c..add6c1e1 100644
--- a/test/routines/levelx/xaxpybatched.hpp
+++ b/test/routines/levelx/xaxpybatched.hpp
@@ -125,6 +125,19 @@ class TestXaxpyBatched {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      for (auto batch = size_t{0}; batch < args.batch_count; ++batch) {
+        auto status = cublasXaxpy(args.n, args.alphas[batch],
+                                  buffers.x_vec, args.x_offsets[batch], args.x_inc,
+                                  buffers.y_vec, args.y_offsets[batch], args.y_inc);
+        if (status != CUBLAS_STATUS_SUCCESS) { return StatusCode::kUnknownError; }
+      }
+      return StatusCode::kSuccess;
+    }
+  #endif
+
   // Describes how to download the results of the computation
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.y_size, static_cast<T>(0));
diff --git a/test/routines/levelx/xgemmbatched.hpp b/test/routines/levelx/xgemmbatched.hpp
index e13e9382..ae8630c0 100644
--- a/test/routines/levelx/xgemmbatched.hpp
+++ b/test/routines/levelx/xgemmbatched.hpp
@@ -160,6 +160,23 @@ class TestXgemmBatched {
     }
   #endif
 
+  // Describes how to run the cuBLAS routine (for correctness/performance comparison)
+  #ifdef CLBLAST_REF_CUBLAS
+    static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+      for (auto batch = size_t{0}; batch < args.batch_count; ++batch) {
+        auto status = cublasXgemm(args.layout,
+                                  convertToCUBLAS(args.a_transpose),
+                                  convertToCUBLAS(args.b_transpose),
+                                  args.m, args.n, args.k, args.alphas[batch],
+                                  buffers.a_mat, args.a_offsets[batch], args.a_ld,
+                                  buffers.b_mat, args.b_offsets[batch], args.b_ld, args.betas[batch],
+                                  buffers.c_mat, args.c_offsets[batch], args.c_ld);
+      if (status != CUBLAS_STATUS_SUCCESS) { return StatusCode::kUnknownError; }
+      }
+      return StatusCode::kSuccess;
+    }
+  #endif
+
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
     std::vector<T> result(args.c_size, static_cast<T>(0));
diff --git a/test/routines/levelx/xinvert.hpp b/test/routines/levelx/xinvert.hpp
index ffb484b0..ac9e9a2d 100644
--- a/test/routines/levelx/xinvert.hpp
+++ b/test/routines/levelx/xinvert.hpp
@@ -192,6 +192,9 @@ class TestXinvert {
   static StatusCode RunReference2(const Arguments<T> &args, BuffersHost<T> &buffers_host, Queue&) {
     return RunReference(args, buffers_host);
   }
+  static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+    return StatusCode::kUnknownError;
+  }
 
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
diff --git a/test/routines/levelx/xomatcopy.hpp b/test/routines/levelx/xomatcopy.hpp
index d5973b4c..2e77e6f7 100644
--- a/test/routines/levelx/xomatcopy.hpp
+++ b/test/routines/levelx/xomatcopy.hpp
@@ -151,6 +151,9 @@ class TestXomatcopy {
   static StatusCode RunReference2(const Arguments<T> &args, BuffersHost<T> &buffers_host, Queue&) {
     return RunReference(args, buffers_host);
   }
+  static StatusCode RunReference3(const Arguments<T> &args, BuffersCUDA<T> &buffers, Queue &) {
+    return StatusCode::kUnknownError;
+  }
 
   // Describes how to download the results of the computation (more importantly: which buffer)
   static std::vector<T> DownloadResult(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {