summaryrefslogtreecommitdiff
path: root/test/routines/level2
diff options
context:
space:
mode:
Diffstat (limited to 'test/routines/level2')
-rw-r--r--test/routines/level2/xgbmv.hpp26
-rw-r--r--test/routines/level2/xgemv.hpp26
-rw-r--r--test/routines/level2/xger.hpp26
-rw-r--r--test/routines/level2/xgerc.hpp26
-rw-r--r--test/routines/level2/xgeru.hpp26
-rw-r--r--test/routines/level2/xhbmv.hpp26
-rw-r--r--test/routines/level2/xhemv.hpp26
-rw-r--r--test/routines/level2/xher.hpp20
-rw-r--r--test/routines/level2/xher2.hpp26
-rw-r--r--test/routines/level2/xhpmv.hpp26
-rw-r--r--test/routines/level2/xhpr.hpp20
-rw-r--r--test/routines/level2/xhpr2.hpp26
-rw-r--r--test/routines/level2/xsbmv.hpp26
-rw-r--r--test/routines/level2/xspmv.hpp26
-rw-r--r--test/routines/level2/xspr.hpp20
-rw-r--r--test/routines/level2/xspr2.hpp26
-rw-r--r--test/routines/level2/xsymv.hpp26
-rw-r--r--test/routines/level2/xsyr.hpp20
-rw-r--r--test/routines/level2/xsyr2.hpp26
-rw-r--r--test/routines/level2/xtbmv.hpp20
-rw-r--r--test/routines/level2/xtpmv.hpp20
-rw-r--r--test/routines/level2/xtrmv.hpp20
-rw-r--r--test/routines/level2/xtrsv.hpp20
23 files changed, 275 insertions, 275 deletions
diff --git a/test/routines/level2/xgbmv.hpp b/test/routines/level2/xgbmv.hpp
index 57c16104..f371b9a7 100644
--- a/test/routines/level2/xgbmv.hpp
+++ b/test/routines/level2/xgbmv.hpp
@@ -86,14 +86,14 @@ class TestXgbmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Gbmv(args.layout, args.a_transpose,
args.m, args.n, args.kl, args.ku, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -101,15 +101,15 @@ class TestXgbmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXgbmv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.a_transpose),
args.m, args.n, args.kl, args.ku, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -118,20 +118,20 @@ class TestXgbmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXgbmv(convertToCBLAS(args.layout),
convertToCBLAS(args.a_transpose),
args.m, args.n, args.kl, args.ku, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xgemv.hpp b/test/routines/level2/xgemv.hpp
index 3c56c405..2442be4c 100644
--- a/test/routines/level2/xgemv.hpp
+++ b/test/routines/level2/xgemv.hpp
@@ -86,14 +86,14 @@ class TestXgemv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Gemv(args.layout, args.a_transpose,
args.m, args.n, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -101,15 +101,15 @@ class TestXgemv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXgemv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.a_transpose),
args.m, args.n, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -118,20 +118,20 @@ class TestXgemv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXgemv(convertToCBLAS(args.layout),
convertToCBLAS(args.a_transpose),
args.m, args.n, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xger.hpp b/test/routines/level2/xger.hpp
index f9a6fefd..3e7ccbc3 100644
--- a/test/routines/level2/xger.hpp
+++ b/test/routines/level2/xger.hpp
@@ -82,14 +82,14 @@ class TestXger {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Ger(args.layout,
args.m, args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -97,14 +97,14 @@ class TestXger {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXger(convertToCLBLAS(args.layout),
args.m, args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -113,19 +113,19 @@ class TestXger {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXger(convertToCBLAS(args.layout),
args.m, args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xgerc.hpp b/test/routines/level2/xgerc.hpp
index ddc9030a..d880ae1f 100644
--- a/test/routines/level2/xgerc.hpp
+++ b/test/routines/level2/xgerc.hpp
@@ -82,14 +82,14 @@ class TestXgerc {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Gerc(args.layout,
args.m, args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -97,14 +97,14 @@ class TestXgerc {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXgerc(convertToCLBLAS(args.layout),
args.m, args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -113,19 +113,19 @@ class TestXgerc {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXgerc(convertToCBLAS(args.layout),
args.m, args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xgeru.hpp b/test/routines/level2/xgeru.hpp
index 8d5b8589..1735e42a 100644
--- a/test/routines/level2/xgeru.hpp
+++ b/test/routines/level2/xgeru.hpp
@@ -82,14 +82,14 @@ class TestXgeru {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Geru(args.layout,
args.m, args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -97,14 +97,14 @@ class TestXgeru {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXgeru(convertToCLBLAS(args.layout),
args.m, args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -113,19 +113,19 @@ class TestXgeru {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXgeru(convertToCBLAS(args.layout),
args.m, args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xhbmv.hpp b/test/routines/level2/xhbmv.hpp
index 50130359..99538bf1 100644
--- a/test/routines/level2/xhbmv.hpp
+++ b/test/routines/level2/xhbmv.hpp
@@ -80,14 +80,14 @@ class TestXhbmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Hbmv(args.layout, args.triangle,
args.n, args.kl, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXhbmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXhbmv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.kl, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXhbmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXhbmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.kl, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xhemv.hpp b/test/routines/level2/xhemv.hpp
index f69b031c..3792cb66 100644
--- a/test/routines/level2/xhemv.hpp
+++ b/test/routines/level2/xhemv.hpp
@@ -80,14 +80,14 @@ class TestXhemv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Hemv(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXhemv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXhemv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXhemv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXhemv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xher.hpp b/test/routines/level2/xher.hpp
index c3d809bf..c58eb189 100644
--- a/test/routines/level2/xher.hpp
+++ b/test/routines/level2/xher.hpp
@@ -76,13 +76,13 @@ class TestXher {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Her(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.a_mat(), args.a_offset, args.a_ld,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -90,14 +90,14 @@ class TestXher {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXher(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.a_mat, args.a_offset, args.a_ld,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -106,17 +106,17 @@ class TestXher {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXher(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xher2.hpp b/test/routines/level2/xher2.hpp
index 7ddf9ed1..8a7eb0b6 100644
--- a/test/routines/level2/xher2.hpp
+++ b/test/routines/level2/xher2.hpp
@@ -80,14 +80,14 @@ class TestXher2 {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Her2(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXher2 {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXher2(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXher2 {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXher2(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xhpmv.hpp b/test/routines/level2/xhpmv.hpp
index 7fae80b8..0862b619 100644
--- a/test/routines/level2/xhpmv.hpp
+++ b/test/routines/level2/xhpmv.hpp
@@ -80,14 +80,14 @@ class TestXhpmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Hpmv(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].ap_mat(), args.ap_offset,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXhpmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXhpmv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].ap_mat, args.ap_offset,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXhpmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXhpmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
ap_mat_cpu, args.ap_offset,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xhpr.hpp b/test/routines/level2/xhpr.hpp
index a46cb8e6..5b454174 100644
--- a/test/routines/level2/xhpr.hpp
+++ b/test/routines/level2/xhpr.hpp
@@ -76,13 +76,13 @@ class TestXhpr {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Hpr(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].ap_mat(), args.ap_offset,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.ap_mat(), args.ap_offset,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -90,14 +90,14 @@ class TestXhpr {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXhpr(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].ap_mat, args.ap_offset,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.ap_mat, args.ap_offset,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -106,17 +106,17 @@ class TestXhpr {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<U> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<U> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXhpr(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
ap_mat_cpu, args.ap_offset);
- buffers[0].ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
+ buffers.ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xhpr2.hpp b/test/routines/level2/xhpr2.hpp
index 08f12768..b770da2e 100644
--- a/test/routines/level2/xhpr2.hpp
+++ b/test/routines/level2/xhpr2.hpp
@@ -80,14 +80,14 @@ class TestXhpr2 {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Hpr2(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].ap_mat(), args.ap_offset,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.y_vec(), args.y_offset, args.y_inc,
+ buffers.ap_mat(), args.ap_offset,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXhpr2 {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXhpr2(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].ap_mat, args.ap_offset,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.y_vec, args.y_offset, args.y_inc,
+ buffers.ap_mat, args.ap_offset,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXhpr2 {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXhpr2(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
ap_mat_cpu, args.ap_offset);
- buffers[0].ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
+ buffers.ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xsbmv.hpp b/test/routines/level2/xsbmv.hpp
index a45dbe8f..7a836170 100644
--- a/test/routines/level2/xsbmv.hpp
+++ b/test/routines/level2/xsbmv.hpp
@@ -80,14 +80,14 @@ class TestXsbmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Sbmv(args.layout, args.triangle,
args.n, args.kl, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXsbmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXsbmv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.kl, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXsbmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXsbmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.kl, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xspmv.hpp b/test/routines/level2/xspmv.hpp
index a455f652..352c8cfd 100644
--- a/test/routines/level2/xspmv.hpp
+++ b/test/routines/level2/xspmv.hpp
@@ -80,14 +80,14 @@ class TestXspmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Spmv(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].ap_mat(), args.ap_offset,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXspmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXspmv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].ap_mat, args.ap_offset,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXspmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXspmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
ap_mat_cpu, args.ap_offset,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xspr.hpp b/test/routines/level2/xspr.hpp
index ab9ab85f..988bcdc2 100644
--- a/test/routines/level2/xspr.hpp
+++ b/test/routines/level2/xspr.hpp
@@ -76,13 +76,13 @@ class TestXspr {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Spr(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].ap_mat(), args.ap_offset,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.ap_mat(), args.ap_offset,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -90,14 +90,14 @@ class TestXspr {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXspr(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].ap_mat, args.ap_offset,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.ap_mat, args.ap_offset,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -106,17 +106,17 @@ class TestXspr {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXspr(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
ap_mat_cpu, args.ap_offset);
- buffers[0].ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
+ buffers.ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xspr2.hpp b/test/routines/level2/xspr2.hpp
index a73975a5..ee517bc1 100644
--- a/test/routines/level2/xspr2.hpp
+++ b/test/routines/level2/xspr2.hpp
@@ -80,14 +80,14 @@ class TestXspr2 {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Spr2(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].ap_mat(), args.ap_offset,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.y_vec(), args.y_offset, args.y_inc,
+ buffers.ap_mat(), args.ap_offset,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXspr2 {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXspr2(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].ap_mat, args.ap_offset,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.y_vec, args.y_offset, args.y_inc,
+ buffers.ap_mat, args.ap_offset,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXspr2 {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXspr2(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
ap_mat_cpu, args.ap_offset);
- buffers[0].ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
+ buffers.ap_mat.Write(queue, args.ap_size, ap_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xsymv.hpp b/test/routines/level2/xsymv.hpp
index c93492ed..5eecfb74 100644
--- a/test/routines/level2/xsymv.hpp
+++ b/test/routines/level2/xsymv.hpp
@@ -80,14 +80,14 @@ class TestXsymv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Symv(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXsymv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXsymv(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc, args.beta,
- buffers[0].y_vec, args.y_offset, args.y_inc,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXsymv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXsymv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc, args.beta,
y_vec_cpu, args.y_offset, args.y_inc);
- buffers[0].y_vec.Write(queue, args.y_size, y_vec_cpu);
+ buffers.y_vec.Write(queue, args.y_size, y_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xsyr.hpp b/test/routines/level2/xsyr.hpp
index ac2c5e98..ac4ee1ff 100644
--- a/test/routines/level2/xsyr.hpp
+++ b/test/routines/level2/xsyr.hpp
@@ -76,13 +76,13 @@ class TestXsyr {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Syr(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ buffers.x_vec(), args.x_offset, args.x_inc,
+ buffers.a_mat(), args.a_offset, args.a_ld,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -90,14 +90,14 @@ class TestXsyr {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXsyr(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ buffers.x_vec, args.x_offset, args.x_inc,
+ buffers.a_mat, args.a_offset, args.a_ld,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -106,17 +106,17 @@ class TestXsyr {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXsyr(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xsyr2.hpp b/test/routines/level2/xsyr2.hpp
index 9f8d315b..43644883 100644
--- a/test/routines/level2/xsyr2.hpp
+++ b/test/routines/level2/xsyr2.hpp
@@ -80,14 +80,14 @@ class TestXsyr2 {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Syr2(args.layout, args.triangle,
args.n, args.alpha,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
- buffers[0].y_vec(), args.y_offset, args.y_inc,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
+ 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,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -95,15 +95,15 @@ class TestXsyr2 {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXsyr2(convertToCLBLAS(args.layout),
convertToCLBLAS(args.triangle),
args.n, args.alpha,
- buffers[0].x_vec, args.x_offset, args.x_inc,
- buffers[0].y_vec, args.y_offset, args.y_inc,
- buffers[0].a_mat, args.a_offset, args.a_ld,
+ 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,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -112,20 +112,20 @@ class TestXsyr2 {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
std::vector<T> y_vec_cpu(args.y_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
- buffers[0].y_vec.Read(queue, args.y_size, y_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.y_vec.Read(queue, args.y_size, y_vec_cpu);
cblasXsyr2(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
args.n, args.alpha,
x_vec_cpu, args.x_offset, args.x_inc,
y_vec_cpu, args.y_offset, args.y_inc,
a_mat_cpu, args.a_offset, args.a_ld);
- buffers[0].a_mat.Write(queue, args.a_size, a_mat_cpu);
+ buffers.a_mat.Write(queue, args.a_size, a_mat_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xtbmv.hpp b/test/routines/level2/xtbmv.hpp
index 2d964fda..ab9244af 100644
--- a/test/routines/level2/xtbmv.hpp
+++ b/test/routines/level2/xtbmv.hpp
@@ -75,13 +75,13 @@ class TestXtbmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Tbmv<T>(args.layout, args.triangle, args.a_transpose, args.diagonal,
args.n, args.kl,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
+ buffers.a_mat(), args.a_offset, args.a_ld,
+ buffers.x_vec(), args.x_offset, args.x_inc,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -89,7 +89,7 @@ class TestXtbmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXtbmv<T>(convertToCLBLAS(args.layout),
@@ -97,8 +97,8 @@ class TestXtbmv {
convertToCLBLAS(args.a_transpose),
convertToCLBLAS(args.diagonal),
args.n, args.kl,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc,
+ buffers.a_mat, args.a_offset, args.a_ld,
+ buffers.x_vec, args.x_offset, args.x_inc,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -107,11 +107,11 @@ class TestXtbmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXtbmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
convertToCBLAS(args.a_transpose),
@@ -119,7 +119,7 @@ class TestXtbmv {
args.n, args.kl,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc);
- buffers[0].x_vec.Write(queue, args.x_size, x_vec_cpu);
+ buffers.x_vec.Write(queue, args.x_size, x_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xtpmv.hpp b/test/routines/level2/xtpmv.hpp
index fcfd86bf..3821e1a4 100644
--- a/test/routines/level2/xtpmv.hpp
+++ b/test/routines/level2/xtpmv.hpp
@@ -75,13 +75,13 @@ class TestXtpmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Tpmv<T>(args.layout, args.triangle, args.a_transpose, args.diagonal,
args.n,
- buffers[0].ap_mat(), args.ap_offset,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
+ buffers.ap_mat(), args.ap_offset,
+ buffers.x_vec(), args.x_offset, args.x_inc,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -89,7 +89,7 @@ class TestXtpmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXtpmv<T>(convertToCLBLAS(args.layout),
@@ -97,8 +97,8 @@ class TestXtpmv {
convertToCLBLAS(args.a_transpose),
convertToCLBLAS(args.diagonal),
args.n,
- buffers[0].ap_mat, args.ap_offset,
- buffers[0].x_vec, args.x_offset, args.x_inc,
+ buffers.ap_mat, args.ap_offset,
+ buffers.x_vec, args.x_offset, args.x_inc,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -107,11 +107,11 @@ class TestXtpmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> ap_mat_cpu(args.ap_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.ap_mat.Read(queue, args.ap_size, ap_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXtpmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
convertToCBLAS(args.a_transpose),
@@ -119,7 +119,7 @@ class TestXtpmv {
args.n,
ap_mat_cpu, args.ap_offset,
x_vec_cpu, args.x_offset, args.x_inc);
- buffers[0].x_vec.Write(queue, args.x_size, x_vec_cpu);
+ buffers.x_vec.Write(queue, args.x_size, x_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xtrmv.hpp b/test/routines/level2/xtrmv.hpp
index 4e209584..7211c757 100644
--- a/test/routines/level2/xtrmv.hpp
+++ b/test/routines/level2/xtrmv.hpp
@@ -75,13 +75,13 @@ class TestXtrmv {
std::vector<T>&, std::vector<T>&) {} // N/A for this routine
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Trmv<T>(args.layout, args.triangle, args.a_transpose, args.diagonal,
args.n,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
+ buffers.a_mat(), args.a_offset, args.a_ld,
+ buffers.x_vec(), args.x_offset, args.x_inc,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -89,7 +89,7 @@ class TestXtrmv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXtrmv<T>(convertToCLBLAS(args.layout),
@@ -97,8 +97,8 @@ class TestXtrmv {
convertToCLBLAS(args.a_transpose),
convertToCLBLAS(args.diagonal),
args.n,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc,
+ buffers.a_mat, args.a_offset, args.a_ld,
+ buffers.x_vec, args.x_offset, args.x_inc,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -107,11 +107,11 @@ class TestXtrmv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXtrmv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
convertToCBLAS(args.a_transpose),
@@ -119,7 +119,7 @@ class TestXtrmv {
args.n,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc);
- buffers[0].x_vec.Write(queue, args.x_size, x_vec_cpu);
+ buffers.x_vec.Write(queue, args.x_size, x_vec_cpu);
return StatusCode::kSuccess;
}
#endif
diff --git a/test/routines/level2/xtrsv.hpp b/test/routines/level2/xtrsv.hpp
index 090684b1..78b9672f 100644
--- a/test/routines/level2/xtrsv.hpp
+++ b/test/routines/level2/xtrsv.hpp
@@ -90,13 +90,13 @@ class TestXtrsv {
}
// Describes how to run the CLBlast routine
- static StatusCode RunRoutine(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunRoutine(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = Trsv<T>(args.layout, args.triangle, args.a_transpose, args.diagonal,
args.n,
- buffers[0].a_mat(), args.a_offset, args.a_ld,
- buffers[0].x_vec(), args.x_offset, args.x_inc,
+ buffers.a_mat(), args.a_offset, args.a_ld,
+ buffers.x_vec(), args.x_offset, args.x_inc,
&queue_plain, &event);
if (status == StatusCode::kSuccess) { clWaitForEvents(1, &event); clReleaseEvent(event); }
return status;
@@ -104,7 +104,7 @@ class TestXtrsv {
// Describes how to run the clBLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CLBLAS
- static StatusCode RunReference1(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference1(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
auto queue_plain = queue();
auto event = cl_event{};
auto status = clblasXtrsv<T>(convertToCLBLAS(args.layout),
@@ -112,8 +112,8 @@ class TestXtrsv {
convertToCLBLAS(args.a_transpose),
convertToCLBLAS(args.diagonal),
args.n,
- buffers[0].a_mat, args.a_offset, args.a_ld,
- buffers[0].x_vec, args.x_offset, args.x_inc,
+ buffers.a_mat, args.a_offset, args.a_ld,
+ buffers.x_vec, args.x_offset, args.x_inc,
1, &queue_plain, 0, nullptr, &event);
clWaitForEvents(1, &event);
return static_cast<StatusCode>(status);
@@ -122,11 +122,11 @@ class TestXtrsv {
// Describes how to run the CPU BLAS routine (for correctness/performance comparison)
#ifdef CLBLAST_REF_CBLAS
- static StatusCode RunReference2(const Arguments<T> &args, std::vector<Buffers<T>> &buffers, Queue &queue) {
+ static StatusCode RunReference2(const Arguments<T> &args, Buffers<T> &buffers, Queue &queue) {
std::vector<T> a_mat_cpu(args.a_size, static_cast<T>(0));
std::vector<T> x_vec_cpu(args.x_size, static_cast<T>(0));
- buffers[0].a_mat.Read(queue, args.a_size, a_mat_cpu);
- buffers[0].x_vec.Read(queue, args.x_size, x_vec_cpu);
+ buffers.a_mat.Read(queue, args.a_size, a_mat_cpu);
+ buffers.x_vec.Read(queue, args.x_size, x_vec_cpu);
cblasXtrsv(convertToCBLAS(args.layout),
convertToCBLAS(args.triangle),
convertToCBLAS(args.a_transpose),
@@ -134,7 +134,7 @@ class TestXtrsv {
args.n,
a_mat_cpu, args.a_offset, args.a_ld,
x_vec_cpu, args.x_offset, args.x_inc);
- buffers[0].x_vec.Write(queue, args.x_size, x_vec_cpu);
+ buffers.x_vec.Write(queue, args.x_size, x_vec_cpu);
return StatusCode::kSuccess;
}
#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-08 04:20:52 +0000