summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCNugteren <web@cedricnugteren.nl>2015-09-17 10:14:33 +0200
committerCNugteren <web@cedricnugteren.nl>2015-09-17 10:14:33 +0200
commit6307d2e5db1347112d992b2ef7a6cde9b3441389 (patch)
tree9c77189cf09b09a7bd59af2299047b890f737386
parent1c242100266e46cf97227c5506a1c32e51afbd00 (diff)
Added script to generate API interface and implementation automatically
Diffstat
-rw-r--r--include/clblast.h39
-rw-r--r--include/clblast_c.h8
-rw-r--r--scripts/generator/datatype.py54
-rw-r--r--scripts/generator/generator.py234
-rw-r--r--scripts/generator/routine.py320
-rw-r--r--src/clblast.cc537
-rw-r--r--test/wrapper_clblas.h1654
7 files changed, 1730 insertions, 1116 deletions
diff --git a/include/clblast.h b/include/clblast.h
index 72825e0b..953e6953 100644
--- a/include/clblast.h
+++ b/include/clblast.h
@@ -90,7 +90,7 @@ enum class Precision { kHalf = 16, kSingle = 32, kDouble = 64,
// Swap two vectors: SSWAP/DSWAP/CSWAP/ZSWAP
template <typename T>
StatusCode Swap(const size_t n,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
@@ -144,7 +144,7 @@ StatusCode Dotc(const size_t n,
// BLAS level-2 (matrix-vector) routines
// =================================================================================================
-// Templated-precision generalized matrix-vector multiplication: SGEMV/DGEMV/CGEMV/ZGEMV
+// Generalized matrix-vector multiplication: SGEMV/DGEMV/CGEMV/ZGEMV
template <typename T>
StatusCode Gemv(const Layout layout, const Transpose a_transpose,
const size_t m, const size_t n,
@@ -155,7 +155,7 @@ StatusCode Gemv(const Layout layout, const Transpose a_transpose,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
-// Templated-precision hermitian matrix-vector multiplication: SHEMV/DHEMV
+// Hermitian matrix-vector multiplication: CHEMV/ZHEMV
template <typename T>
StatusCode Hemv(const Layout layout, const Triangle triangle,
const size_t n,
@@ -166,7 +166,7 @@ StatusCode Hemv(const Layout layout, const Triangle triangle,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
-// Templated-precision symmetric matrix-vector multiplication: SSYMV/DSYMV
+// Symmetric matrix-vector multiplication: SSYMV/DSYMV
template <typename T>
StatusCode Symv(const Layout layout, const Triangle triangle,
const size_t n,
@@ -181,7 +181,7 @@ StatusCode Symv(const Layout layout, const Triangle triangle,
// BLAS level-3 (matrix-matrix) routines
// =================================================================================================
-// Templated-precision generalized matrix-matrix multiplication: SGEMM/DGEMM/CGEMM/ZGEMM
+// Generalized matrix-matrix multiplication: SGEMM/DGEMM/CGEMM/ZGEMM
template <typename T>
StatusCode Gemm(const Layout layout, const Transpose a_transpose, const Transpose b_transpose,
const size_t m, const size_t n, const size_t k,
@@ -192,7 +192,7 @@ StatusCode Gemm(const Layout layout, const Transpose a_transpose, const Transpos
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision symmetric matrix-matrix multiplication: SSYMM/DSYMM/CSYMM/ZSYMM
+// Symmetric matrix-matrix multiplication: SSYMM/DSYMM/CSYMM/ZSYMM
template <typename T>
StatusCode Symm(const Layout layout, const Side side, const Triangle triangle,
const size_t m, const size_t n,
@@ -203,7 +203,7 @@ StatusCode Symm(const Layout layout, const Side side, const Triangle triangle,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision hermitian matrix-matrix multiplication: CHEMM/ZHEMM
+// Hermitian matrix-matrix multiplication: CHEMM/ZHEMM
template <typename T>
StatusCode Hemm(const Layout layout, const Side side, const Triangle triangle,
const size_t m, const size_t n,
@@ -214,7 +214,7 @@ StatusCode Hemm(const Layout layout, const Side side, const Triangle triangle,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision rank-K update of a symmetric matrix: SSYRK/DSYRK/CSYRK/ZSYRK
+// Rank-K update of a symmetric matrix: SSYRK/DSYRK/CSYRK/ZSYRK
template <typename T>
StatusCode Syrk(const Layout layout, const Triangle triangle, const Transpose a_transpose,
const size_t n, const size_t k,
@@ -224,7 +224,7 @@ StatusCode Syrk(const Layout layout, const Triangle triangle, const Transpose a_
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision rank-K update of a hermitian matrix: CHERK/ZHERK
+// Rank-K update of a hermitian matrix: CHERK/ZHERK
template <typename T>
StatusCode Herk(const Layout layout, const Triangle triangle, const Transpose a_transpose,
const size_t n, const size_t k,
@@ -234,7 +234,7 @@ StatusCode Herk(const Layout layout, const Triangle triangle, const Transpose a_
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision rank-2K update of a symmetric matrix: SSYR2K/DSYR2K/CSYR2K/ZSYR2K
+// Rank-2K update of a symmetric matrix: SSYR2K/DSYR2K/CSYR2K/ZSYR2K
template <typename T>
StatusCode Syr2k(const Layout layout, const Triangle triangle, const Transpose ab_transpose,
const size_t n, const size_t k,
@@ -245,7 +245,7 @@ StatusCode Syr2k(const Layout layout, const Triangle triangle, const Transpose a
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision rank-2K update of a hermitian matrix: CHER2K/ZHER2K
+// Rank-2K update of a hermitian matrix: CHER2K/ZHER2K
template <typename T, typename U>
StatusCode Her2k(const Layout layout, const Triangle triangle, const Transpose ab_transpose,
const size_t n, const size_t k,
@@ -256,27 +256,14 @@ StatusCode Her2k(const Layout layout, const Triangle triangle, const Transpose a
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event);
-// Templated-precision triangular matrix-matrix multiplication: STRMM/DTRMM/CTRMM/ZTRMM
-template <typename T>
-StatusCode Trmm(const Layout layout, const Side side, const Triangle triangle,
- const Transpose a_transpose, const Diagonal diagonal,
- const size_t m, const size_t n,
- const T alpha,
- const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
- cl_command_queue* queue, cl_event* event);
-
-// Templated-precision matrix equation solver: STRSM/DTRSM/CTRSM/ZTRSM
-/*
+// Triangular matrix-matrix multiplication: STRMM/DTRMM/CTRMM/ZTRMM
template <typename T>
-StatusCode Trsm(const Layout layout, const Side side, const Triangle triangle,
- const Transpose a_transpose, const Diagonal diagonal,
+StatusCode Trmm(const Layout layout, const Side side, const Triangle triangle, const Transpose a_transpose, const Diagonal diagonal,
const size_t m, const size_t n,
const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
cl_command_queue* queue, cl_event* event);
-*/
// =================================================================================================
} // namespace clblast
diff --git a/include/clblast_c.h b/include/clblast_c.h
index 88754990..56507625 100644
--- a/include/clblast_c.h
+++ b/include/clblast_c.h
@@ -85,19 +85,19 @@ typedef enum Precision_ { kHalf = 16, kSingle = 32, kDouble = 64,
// Swap two vectors: SSWAP/DSWAP/CSWAP/ZSWAP
StatusCode CLBlastSswap(const size_t n,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
StatusCode CLBlastDswap(const size_t n,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
StatusCode CLBlastCswap(const size_t n,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
StatusCode CLBlastZswap(const size_t n,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event);
diff --git a/scripts/generator/datatype.py b/scripts/generator/datatype.py
new file mode 100644
index 00000000..cca3534d
--- /dev/null
+++ b/scripts/generator/datatype.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+# ==================================================================================================
+# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
+# project loosely follows the Google C++ styleguide and uses a max-width of 100 characters per line.
+#
+# Author(s):
+# Cedric Nugteren <www.cedricnugteren.nl>
+#
+# This file contains the 'DataType' class, used in the generator script to generate the CLBlast API
+# interface and implementation.
+#
+# ==================================================================================================
+
+# Short-hands for data-types
+FLT = "float"
+DBL = "double"
+FLT2 = "float2"
+DBL2 = "double2"
+F2CL = "cl_float2"
+D2CL = "cl_double2"
+
+# Structure holding data-type and precision information
+class DataType():
+ def __init__(self, name, template, scalars, buffertype):
+ self.name = name
+ self.template = template
+ self.alpha_cpp = scalars[0]
+ self.beta_cpp = scalars[1]
+ self.alpha_cl = scalars[2]
+ self.beta_cl = scalars[3]
+ self.buffertype = buffertype # Only used for template types
+
+ # Outputs the name of the data-type (alpha/beta), possibly transforming into the right type
+ def UseAlpha(self):
+ if self.alpha_cpp in [FLT2, DBL2]:
+ return self.alpha_cpp+"{alpha.s[0], alpha.s[1]}"
+ return "alpha"
+ def UseBeta(self):
+ if self.beta_cpp in [FLT2, DBL2]:
+ return self.beta_cpp+"{beta.s[0], beta.s[1]}"
+ return "beta"
+
+ # As above, but the transformation is in the opposite direction
+ def UseAlphaCL(self):
+ if self.alpha_cpp in [FLT2, DBL2]:
+ return self.alpha_cl+"{{alpha.real(), alpha.imag()}}"
+ return "alpha"
+ def UseBetaCL(self):
+ if self.beta_cpp in [FLT2, DBL2]:
+ return self.beta_cl+"{{beta.real(), beta.imag()}}"
+ return "beta"
+
+# ==================================================================================================
diff --git a/scripts/generator/generator.py b/scripts/generator/generator.py
new file mode 100644
index 00000000..699cd9cf
--- /dev/null
+++ b/scripts/generator/generator.py
@@ -0,0 +1,234 @@
+#!/usr/bin/env python
+
+# ==================================================================================================
+# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
+# project loosely follows the Google C++ styleguide and uses a max-width of 100 characters per line.
+#
+# Author(s):
+# Cedric Nugteren <www.cedricnugteren.nl>
+#
+# This script automatically generates the bodies of the following files, creating the full CLBlast
+# API interface and implementation (C, C++, and clBLAS wrapper):
+# clblast.h
+# clblast.cc
+# clblast_c.h
+# clblast_c.cc
+# wrapper_clblas.h
+#
+# ==================================================================================================
+
+# System modules
+import sys
+import os.path
+
+# Local files
+from routine import Routine
+from datatype import DataType, FLT, DBL, FLT2, DBL2, F2CL, D2CL
+
+# ==================================================================================================
+
+# Regular data-types
+S = DataType("S", FLT, [FLT, FLT, FLT, FLT], FLT ) # single (32)
+D = DataType("D", DBL, [DBL, DBL, DBL, DBL], DBL ) # double (64)
+C = DataType("C", FLT2, [FLT2, FLT2, F2CL, F2CL], F2CL) # single-complex (3232)
+Z = DataType("Z", DBL2, [DBL2, DBL2, D2CL, D2CL], D2CL) # double-complex (6464)
+
+# Special cases
+Css = DataType("C", FLT, [FLT, FLT, FLT, FLT], FLT ) # As C, but with constants from S
+Zdd = DataType("Z", DBL, [DBL, DBL, DBL, DBL], DBL ) # As Z, but with constants from D
+Ccs = DataType("C", FLT2+","+FLT, [FLT2, FLT, F2CL, FLT], FLT2) # As C, but with one constant from S
+Zzd = DataType("Z", DBL2+","+DBL, [DBL2, DBL, D2CL, DBL], DBL2) # As Z, but with one constant from D
+
+# C++ template data-types
+T = DataType("typename T", "T", ["T", "T", "T", "T"], "T") # regular routine
+Tc = DataType("typename T", "std::complex<T>,T", ["T", "T", "T", "T"], "std::complex<T>") # for herk
+TU = DataType("typename T, typename U", "T,U", ["T", "U", "T", "U"], "T") # for her2k
+
+# ==================================================================================================
+
+# Populates a list of routines
+routines = [
+[ # Level 1
+ Routine(True, 1, "swap", T, [S,D,C,Z], ["n"], [], [], ["x","y"], [], False, "Swap two vectors"),
+ Routine(True, 1, "scal", T, [S,D,C,Z], ["n"], [], [], ["x"], ["alpha"], False, "Vector scaling"),
+ Routine(True, 1, "copy", T, [S,D,C,Z], ["n"], [], ["x"], ["y"], [], False, "Vector copy"),
+ Routine(True, 1, "axpy", T, [S,D,C,Z], ["n"], [], ["x"], ["y"], ["alpha"], False, "Vector-times-constant plus vector"),
+ Routine(True, 1, "dot", T, [S,D], ["n"], [], ["x","y"], ["dot"], [], True, "Dot product of two vectors"),
+ Routine(True, 1, "dotu", T, [C,Z], ["n"], [], ["x","y"], ["dot"], [], True, "Dot product of two complex vectors"),
+ Routine(True, 1, "dotc", T, [C,Z], ["n"], [], ["x","y"], ["dot"], [], True, "Dot product of two complex vectors, one conjugated"),
+],
+[ # Level 2
+ Routine(True, 2, "gemv", T, [S,D,C,Z], ["m","n"], ["layout","a_transpose"], ["a","x"], ["y"], ["alpha","beta"], False, "Generalized matrix-vector multiplication"),
+ Routine(True, 2, "hemv", T, [C,Z], ["n"], ["layout","triangle"], ["a","x"], ["y"], ["alpha","beta"], False, "Hermitian matrix-vector multiplication"),
+ Routine(True, 2, "symv", T, [S,D], ["n"], ["layout","triangle"], ["a","x"], ["y"], ["alpha","beta"], False, "Symmetric matrix-vector multiplication"),
+],
+[ # Level 3
+ Routine(True, 3, "gemm", T, [S,D,C,Z], ["m","n","k"], ["layout","a_transpose","b_transpose"], ["a","b"], ["c"], ["alpha","beta"], False, "Generalized matrix-matrix multiplication"),
+ Routine(True, 3, "symm", T, [S,D,C,Z], ["m","n"], ["layout","side","triangle"], ["a","b"], ["c"], ["alpha","beta"], False, "Symmetric matrix-matrix multiplication"),
+ Routine(True, 3, "hemm", T, [C,Z], ["m","n"], ["layout","side","triangle"], ["a","b"], ["c"], ["alpha","beta"], False, "Hermitian matrix-matrix multiplication"),
+ Routine(True, 3, "syrk", T, [S,D,C,Z], ["n","k"], ["layout","triangle","a_transpose"], ["a"], ["c"], ["alpha","beta"], False, "Rank-K update of a symmetric matrix"),
+ Routine(True, 3, "herk", Tc, [Css,Zdd], ["n","k"], ["layout","triangle","a_transpose"], ["a"], ["c"], ["alpha","beta"], False, "Rank-K update of a hermitian matrix"),
+ Routine(True, 3, "syr2k", T, [S,D,C,Z], ["n","k"], ["layout","triangle","ab_transpose"], ["a","b"], ["c"], ["alpha","beta"], False, "Rank-2K update of a symmetric matrix"),
+ Routine(True, 3, "her2k", TU, [Ccs,Zzd], ["n","k"], ["layout","triangle","ab_transpose"], ["a","b"], ["c"], ["alpha","beta"], False, "Rank-2K update of a hermitian matrix"),
+ Routine(True, 3, "trmm", T, [S,D,C,Z], ["m","n"], ["layout","side","triangle","a_transpose","diagonal"], ["a"], ["b"], ["alpha"], False, "Triangular matrix-matrix multiplication"),
+]]
+
+# ==================================================================================================
+
+# Separators for the BLAS levels
+separators = ["""
+// =================================================================================================
+// BLAS level-1 (vector-vector) routines
+// =================================================================================================""",
+"""
+// =================================================================================================
+// BLAS level-2 (matrix-vector) routines
+// =================================================================================================""",
+"""
+// =================================================================================================
+// BLAS level-3 (matrix-matrix) routines
+// ================================================================================================="""]
+
+# ==================================================================================================
+
+# The C++ API header (.h)
+def clblast_h(routines):
+ result = ""
+ for routine in routines:
+ result += "\n// "+routine.description+": "+routine.ShortNames()+"\n"
+ result += routine.RoutineHeaderCPP(12)+";\n"
+ return result
+
+# The C++ API implementation (.cc)
+def clblast_cc(routines):
+ result = ""
+ for routine in routines:
+ indent1 = " "*(20 + routine.Length())
+ result += "\n// "+routine.description+": "+routine.ShortNames()+"\n"
+ if routine.implemented:
+ result += routine.RoutineHeaderCPP(12)+" {\n"
+ result += " auto queue_cpp = Queue(*queue);\n"
+ result += " auto event_cpp = Event(*event);\n"
+ result += " auto routine = X"+routine.name+"<"+routine.template.template+">(queue_cpp, event_cpp);\n"
+ result += " auto status = routine.SetUp();\n"
+ result += " if (status != StatusCode::kSuccess) { return status; }\n"
+ result += " return routine.Do"+routine.name.capitalize()+"("
+ result += (",\n"+indent1).join([a for a in routine.ArgumentsCladuc(routine.template, indent1)])
+ result += ");\n"
+ else:
+ result += routine.RoutineHeaderTypeCPP(12)+" {\n"
+ result += " return StatusCode::kNotImplemented;\n"
+ result += "}\n"
+ for flavour in routine.flavours:
+ indent2 = " "*(23 + routine.Length() + len(flavour.template))
+ result += "template StatusCode "+routine.name.capitalize()+"<"+flavour.template+">("
+ result += (",\n"+indent2).join([a for a in routine.ArgumentsType(flavour)])
+ result += ",\n"+indent2+"cl_command_queue*, cl_event*);\n"
+ return result
+
+# ==================================================================================================
+
+# The C API header (.h)
+def clblast_c_h(routines):
+ result = ""
+ for routine in routines:
+ result += "\n// "+routine.description+": "+routine.ShortNames()+"\n"
+ for flavour in routine.flavours:
+ result += routine.RoutineHeaderC(flavour, 20)+";\n"
+ return result
+
+# The C API implementation (.cc)
+def clblast_c_cc(routines):
+ result = ""
+ for routine in routines:
+ result += "\n// "+routine.name.upper()+"\n"
+ for flavour in routine.flavours:
+ template = "<"+flavour.template+">" if routine.NoScalars() else ""
+ indent = " "*(26 + routine.Length() + len(template))
+ result += routine.RoutineHeaderC(flavour, 20)+" {\n"
+ result += " auto status = clblast::"+routine.name.capitalize()+template+"("
+ result += (",\n"+indent).join([a for a in routine.ArgumentsCast(flavour, indent)])
+ result += ",\n"+indent+"queue, event);"
+ result += "\n return static_cast<StatusCode>(status);\n}\n"
+ return result
+
+# ==================================================================================================
+
+# The wrapper to the reference clBLAS routines (for performance/correctness testing)
+def wrapper_clblas(routines):
+ result = ""
+ for routine in routines:
+ result += "\n// Forwards the clBLAS calls for %s\n" % (routine.ShortNames())
+ if routine.NoScalars():
+ result += routine.RoutineHeaderWrapper(routine.template, True, 21)+";\n"
+ for flavour in routine.flavours:
+ indent = " "*(17 + routine.Length())
+ result += routine.RoutineHeaderWrapper(flavour, False, 21)+" {\n"
+ arguments = routine.ArgumentsWrapper(flavour)
+ if routine.scratch:
+ result += " auto queue = Queue(queues[0]);\n"
+ result += " auto context = queue.GetContext();\n"
+ result += " auto scratch_buffer = Buffer<"+flavour.template+">(context, n);\n"
+ arguments += ["scratch_buffer()"]
+ result += " return clblas"+flavour.name+routine.name+"("
+ result += (",\n"+indent).join([a for a in arguments])
+ result += ",\n"+indent+"num_queues, queues, num_wait_events, wait_events, events);"
+ result += "\n}\n"
+ return result
+
+# ==================================================================================================
+
+# Checks for the number of command-line arguments
+if len(sys.argv) != 2:
+ print "[ERROR] Usage: generator.py <root_of_clblast>"
+ sys.exit()
+
+# Parses the command-line arguments
+path_clblast = sys.argv[1]
+files = [
+ path_clblast+"/include/clblast.h",
+ path_clblast+"/src/clblast.cc",
+ path_clblast+"/include/clblast_c.h",
+ path_clblast+"/src/clblast_c.cc",
+ path_clblast+"/test/wrapper_clblas.h",
+]
+header_lines = [84, 44, 80, 24, 22]
+footer_lines = [6, 3, 5, 2, 6]
+
+# Checks whether the command-line arguments are valid; exists otherwise
+for f in files:
+ if not os.path.isfile(f):
+ print "[ERROR] The path '"+path_clblast+"' does not point to the root of the CLBlast library"
+ sys.exit()
+
+# ==================================================================================================
+
+# Iterates over all files to output
+for i in xrange(0,len(files)):
+
+ # Stores the header and the footer of the original file
+ with open(files[i]) as f:
+ original = f.readlines()
+ header = original[:header_lines[i]]
+ footer = original[-footer_lines[i]:]
+
+ # Re-writes the body of the file
+ with open(files[i], "w") as f:
+ body = ""
+ for level in [1,2,3]:
+ body += separators[level-1]+"\n"
+ if i == 0:
+ body += clblast_h(routines[level-1])
+ if i == 1:
+ body += clblast_cc(routines[level-1])
+ if i == 2:
+ body += clblast_c_h(routines[level-1])
+ if i == 3:
+ body += clblast_c_cc(routines[level-1])
+ if i == 4:
+ body += wrapper_clblas(routines[level-1])
+ f.write("".join(header))
+ f.write(body)
+ f.write("".join(footer))
+
+# ==================================================================================================
diff --git a/scripts/generator/routine.py b/scripts/generator/routine.py
new file mode 100644
index 00000000..b2c50e3d
--- /dev/null
+++ b/scripts/generator/routine.py
@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+
+# ==================================================================================================
+# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
+# project loosely follows the Google C++ styleguide and uses a max-width of 100 characters per line.
+#
+# Author(s):
+# Cedric Nugteren <www.cedricnugteren.nl>
+#
+# This file contains the 'Routine' class, used in the generator script to generate the CLBlast API
+# interface and implementation.
+#
+# ==================================================================================================
+
+# Translates an option name to a CLBlast data-type
+def OptionToCLBlast(x):
+ return {
+ 'layout': "Layout",
+ 'a_transpose': "Transpose",
+ 'b_transpose': "Transpose",
+ 'ab_transpose': "Transpose",
+ 'side': "Side",
+ 'triangle': "Triangle",
+ 'diagonal': "Diagonal",
+ }[x]
+
+# As above, but for clBLAS data-types
+def OptionToWrapper(x):
+ return {
+ 'layout': "clblasOrder",
+ 'a_transpose': "clblasTranspose",
+ 'b_transpose': "clblasTranspose",
+ 'ab_transpose': "clblasTranspose",
+ 'side': "clblasSide",
+ 'triangle': "clblasUplo",
+ 'diagonal': "clblasDiag",
+ }[x]
+
+# ==================================================================================================
+
+# Class holding routine-specific information (e.g. name, which arguments, which precisions)
+class Routine():
+ def __init__(self, implemented, level, name, template, flavours, sizes, options,
+ inputs, outputs, scalars, scratch, description):
+ self.implemented = implemented
+ self.level = level
+ self.name = name
+ self.template = template
+ self.flavours = flavours
+ self.sizes = sizes
+ self.options = options
+ self.inputs = inputs
+ self.outputs = outputs
+ self.scalars = scalars
+ self.scratch = scratch # Scratch buffer (e.g. for xDOT)
+ self.description = description
+
+ # Retrieves the number of characters in the routine's name
+ def Length(self):
+ return len(self.name)
+
+ # Retrieves the postfix for a buffer
+ def Postfix(self, name):
+ return "inc" if (name in ["x","y"]) else "ld"
+
+ # Determines whether or not this routine has scalar arguments (alpha/beta)
+ def NoScalars(self):
+ return self.scalars == []
+
+ # Returns the upper-case names of these routines (all flavours)
+ def ShortNames(self):
+ return "/".join([f.name+self.name.upper() for f in self.flavours])
+
+ # ==============================================================================================
+
+ # Retrieves a variable name for a specific input/output vector/matrix (e.g. 'x')
+ def Buffer(self, name):
+ if (name in self.inputs) or (name in self.outputs):
+ a = [name+"_buffer"]
+ b = [name+"_offset"]
+ c = [name+"_"+self.Postfix(name)] if (name not in ["dot"]) else []
+ return [", ".join(a+b+c)]
+ return []
+
+ # As above but with data-types
+ def BufferDef(self, name):
+ prefix = "const " if (name in self.inputs) else ""
+ if (name in self.inputs) or (name in self.outputs):
+ a = [prefix+"cl_mem "+name+"_buffer"]
+ b = ["const size_t "+name+"_offset"]
+ c = ["const size_t "+name+"_"+self.Postfix(name)] if (name not in ["dot"]) else []
+ return [", ".join(a+b+c)]
+ return []
+
+ # As above but with Claduc buffers
+ def BufferCladuc(self, name):
+ if (name in self.inputs) or (name in self.outputs):
+ a = ["Buffer<"+self.template.buffertype+">("+name+"_buffer)"]
+ b = [name+"_offset"]
+ c = [name+"_"+self.Postfix(name)] if (name not in ["dot"]) else []
+ return [", ".join(a+b+c)]
+ return []
+
+ # As above but with a static cast for clBLAS wrapper
+ def BufferWrapper(self, name):
+ if (name in self.inputs) or (name in self.outputs):
+ a = [name+"_buffer"]
+ b = [name+"_offset"]
+ c = []
+ if (name in ["x","y"]):
+ c = ["static_cast<int>("+name+"_"+self.Postfix(name)+")"]
+ elif (name in ["a","b","c"]):
+ c = [name+"_"+self.Postfix(name)]
+ return [", ".join(a+b+c)]
+ return []
+
+ # As above, but only data-types
+ def BufferType(self, name):
+ prefix = "const " if (name in self.inputs) else ""
+ if (name in self.inputs) or (name in self.outputs):
+ a = [prefix+"cl_mem"]
+ b = ["const size_t"]
+ c = ["const size_t"] if (name not in ["dot"]) else []
+ return [", ".join(a+b+c)]
+ return []
+
+ # ==============================================================================================
+
+ # Retrieves the name of a scalar (alpha/beta)
+ def Scalar(self, name):
+ if (name in self.scalars):
+ return [name]
+ return []
+
+ # Retrieves the use of a scalar (alpha/beta)
+ def ScalarUse(self, name, flavour):
+ if ((name == "alpha") and (name in self.scalars)):
+ return [flavour.UseAlpha()]
+ elif ((name == "beta") and (name in self.scalars)):
+ return [flavour.UseBeta()]
+ return []
+
+ # Retrieves the use of a scalar (alpha/beta)
+ def ScalarUseWrapper(self, name, flavour):
+ if ((name == "alpha") and (name in self.scalars)):
+ return [flavour.UseAlphaCL()]
+ elif ((name == "beta") and (name in self.scalars)):
+ return [flavour.UseBetaCL()]
+ return []
+
+ # Retrieves the definition of a scalar (alpha/beta)
+ def ScalarDef(self, name, flavour):
+ if ((name == "alpha") and (name in self.scalars)):
+ return ["const "+flavour.alpha_cl+" "+name]
+ elif ((name == "beta") and (name in self.scalars)):
+ return ["const "+flavour.beta_cl+" "+name]
+ return []
+
+ # As above, but without 'cl_' prefix
+ def ScalarDefPlain(self, name, flavour):
+ if ((name == "alpha") and (name in self.scalars)):
+ return ["const "+flavour.alpha_cpp+" "+name]
+ elif ((name == "beta") and (name in self.scalars)):
+ return ["const "+flavour.beta_cpp+" "+name]
+ return []
+
+ # Retrieves the type of a scalar (alpha/beta)
+ def ScalarType(self, name, flavour):
+ if ((name == "alpha") and (name in self.scalars)):
+ return ["const "+flavour.alpha_cpp]
+ elif ((name == "beta") and (name in self.scalars)):
+ return ["const "+flavour.beta_cpp]
+ return []
+
+ # ==============================================================================================
+
+ # Retrieves a list of comma-separated sizes (m, n, k)
+ def Sizes(self):
+ if self.sizes:
+ return [", ".join([s for s in self.sizes])]
+ return []
+
+ # Retrieves the definition of the sizes (m,n,k)
+ def SizesDef(self):
+ if self.sizes:
+ return [", ".join(["const size_t "+s for s in self.sizes])]
+ return []
+
+ # Retrieves the types of the sizes (m,n,k)
+ def SizesType(self):
+ if self.sizes:
+ return [", ".join(["const size_t" for s in self.sizes])]
+ return []
+
+ # ==============================================================================================
+
+ # Retrieves a list of options
+ def Options(self):
+ if self.options:
+ return [", ".join(self.options)]
+ return []
+
+ # As above, but now casted to CLBlast data-types
+ def OptionsCast(self, indent):
+ if self.options:
+ options = ["static_cast<clblast::"+OptionToCLBlast(o)+">("+o+")" for o in self.options]
+ return [(",\n"+indent).join(options)]
+ return []
+
+ # Retrieves the definitions of the options (layout, transpose, side, etc.)
+ def OptionsDef(self):
+ if self.options:
+ definitions = ["const "+OptionToCLBlast(o)+" "+o for o in self.options]
+ return [", ".join(definitions)]
+ return []
+
+ # As above, but now using clBLAS data-types
+ def OptionsDefWrapper(self):
+ if self.options:
+ definitions = ["const "+OptionToWrapper(o)+" "+o for o in self.options]
+ return [", ".join(definitions)]
+ return []
+
+ # Retrieves the types of the options (layout, transpose, side, etc.)
+ def OptionsType(self):
+ if self.options:
+ definitions = ["const "+OptionToCLBlast(o) for o in self.options]
+ return [", ".join(definitions)]
+ return []
+
+ # ==============================================================================================
+
+ # Retrieves a combination of all the argument names, with Claduc casts
+ def ArgumentsCladuc(self, flavour, indent):
+ return (self.Options() + self.Sizes() + self.BufferCladuc("dot") +
+ self.Scalar("alpha") +
+ self.BufferCladuc("a") + self.BufferCladuc("b") + self.BufferCladuc("x") +
+ self.Scalar("beta") + self.BufferCladuc("y") + self.BufferCladuc("c"))
+
+ # Retrieves a combination of all the argument names, with CLBlast casts
+ def ArgumentsCast(self, flavour, indent):
+ return (self.OptionsCast(indent) + self.Sizes() + self.Buffer("dot") +
+ self.ScalarUse("alpha", flavour) +
+ self.Buffer("a") + self.Buffer("b") + self.Buffer("x") +
+ self.ScalarUse("beta", flavour) + self.Buffer("y") + self.Buffer("c"))
+
+ # As above, but for the clBLAS wrapper
+ def ArgumentsWrapper(self, flavour):
+ return (self.Options() + self.Sizes() + self.BufferWrapper("dot") +
+ self.ScalarUseWrapper("alpha", flavour) +
+ self.BufferWrapper("a") + self.BufferWrapper("b") + self.BufferWrapper("x") +
+ self.ScalarUseWrapper("beta", flavour) + self.BufferWrapper("y") + self.BufferWrapper("c"))
+
+ # Retrieves a combination of all the argument definitions
+ def ArgumentsDef(self, flavour):
+ return (self.OptionsDef() + self.SizesDef() + self.BufferDef("dot") +
+ self.ScalarDef("alpha", flavour) +
+ self.BufferDef("a") + self.BufferDef("b") + self.BufferDef("x") +
+ self.ScalarDef("beta", flavour) + self.BufferDef("y") + self.BufferDef("c"))
+
+ # As above, but clBLAS wrapper plain datatypes
+ def ArgumentsDefWrapper(self, flavour):
+ return (self.OptionsDefWrapper() + self.SizesDef() + self.BufferDef("dot") +
+ self.ScalarDefPlain("alpha", flavour) +
+ self.BufferDef("a") + self.BufferDef("b") + self.BufferDef("x") +
+ self.ScalarDefPlain("beta", flavour) + self.BufferDef("y") + self.BufferDef("c"))
+
+ # Retrieves a combination of all the argument types
+ def ArgumentsType(self, flavour):
+ return (self.OptionsType() + self.SizesType() + self.BufferType("dot") +
+ self.ScalarType("alpha", flavour) +
+ self.BufferType("a") + self.BufferType("b") + self.BufferType("x") +
+ self.ScalarType("beta", flavour) + self.BufferType("y") + self.BufferType("c"))
+
+
+ # ==============================================================================================
+
+ # Retrieves the C++ templated definition for a routine
+ def RoutineHeaderCPP(self, spaces):
+ indent = " "*(spaces + self.Length())
+ result = "template <"+self.template.name+">\n"
+ result += "StatusCode "+self.name.capitalize()+"("
+ result += (",\n"+indent).join([a for a in self.ArgumentsDef(self.template)])
+ result += ",\n"+indent+"cl_command_queue* queue, cl_event* event)"
+ return result
+
+ # As above, but now without variable names
+ def RoutineHeaderTypeCPP(self, spaces):
+ indent = " "*(spaces + self.Length())
+ result = "template <"+self.template.name+">\n"
+ result += "StatusCode "+self.name.capitalize()+"("
+ result += (",\n"+indent).join([a for a in self.ArgumentsType(self.template)])
+ result += ",\n"+indent+"cl_command_queue* queue, cl_event* event)"
+ return result
+
+ # As above, but now for C
+ def RoutineHeaderC(self, flavour, spaces):
+ indent = " "*(spaces + self.Length())
+ result = "StatusCode CLBlast"+flavour.name+self.name+"("
+ result += (",\n"+indent).join([a for a in self.ArgumentsDef(flavour)])
+ result += ",\n"+indent+"cl_command_queue* queue, cl_event* event)"
+ return result
+
+ # As above, but now for the clBLAS wrapper
+ def RoutineHeaderWrapper(self, flavour, def_only, spaces):
+ template = "<"+flavour.template+">" if self.NoScalars() and not def_only else ""
+ indent = " "*(spaces + self.Length() + len(template))
+ result = ""
+ if self.NoScalars():
+ result += "template <"
+ if def_only:
+ result += flavour.name
+ result += ">\n"
+ result += "clblasStatus clblasX"+self.name+template+"("
+ result += (",\n"+indent).join([a for a in self.ArgumentsDefWrapper(flavour)])
+ result += ",\n"+indent+"cl_uint num_queues, cl_command_queue *queues"
+ result += ",\n"+indent+"cl_uint num_wait_events, const cl_event *wait_events, cl_event *events)"
+ return result
+
+# ==================================================================================================
diff --git a/src/clblast.cc b/src/clblast.cc
index 3303085e..0ced9ff7 100644
--- a/src/clblast.cc
+++ b/src/clblast.cc
@@ -42,11 +42,12 @@
#include "internal/routines/level3/xtrmm.h"
namespace clblast {
+
// =================================================================================================
// BLAS level-1 (vector-vector) routines
// =================================================================================================
-// SWAP
+// Swap two vectors: SSWAP/DSWAP/CSWAP/ZSWAP
template <typename T>
StatusCode Swap(const size_t n,
cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
@@ -64,21 +65,21 @@ StatusCode Swap(const size_t n,
template StatusCode Swap<float>(const size_t,
cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Swap<double>(const size_t,
cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Swap<float2>(const size_t,
cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Swap<double2>(const size_t,
cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// SCAL
+// Vector scaling: SSCAL/DSCAL/CSCAL/ZSCAL
template <typename T>
StatusCode Scal(const size_t n,
const T alpha,
@@ -96,21 +97,21 @@ StatusCode Scal(const size_t n,
template StatusCode Scal<float>(const size_t,
const float,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Scal<double>(const size_t,
const double,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Scal<float2>(const size_t,
const float2,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Scal<double2>(const size_t,
const double2,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// COPY
+// Vector copy: SCOPY/DCOPY/CCOPY/ZCOPY
template <typename T>
StatusCode Copy(const size_t n,
const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
@@ -128,21 +129,21 @@ StatusCode Copy(const size_t n,
template StatusCode Copy<float>(const size_t,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Copy<double>(const size_t,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Copy<float2>(const size_t,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Copy<double2>(const size_t,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// AXPY
+// Vector-times-constant plus vector: SAXPY/DAXPY/CAXPY/ZAXPY
template <typename T>
StatusCode Axpy(const size_t n,
const T alpha,
@@ -163,24 +164,24 @@ template StatusCode Axpy<float>(const size_t,
const float,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Axpy<double>(const size_t,
const double,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Axpy<float2>(const size_t,
const float2,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Axpy<double2>(const size_t,
const double2,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// DOT
+// Dot product of two vectors: SDOT/DDOT
template <typename T>
StatusCode Dot(const size_t n,
cl_mem dot_buffer, const size_t dot_offset,
@@ -201,14 +202,14 @@ template StatusCode Dot<float>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Dot<double>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// DOTU
+// Dot product of two complex vectors: CDOTU/ZDOTU
template <typename T>
StatusCode Dotu(const size_t n,
cl_mem dot_buffer, const size_t dot_offset,
@@ -229,14 +230,14 @@ template StatusCode Dotu<float2>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Dotu<double2>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
-// DOTC
+// Dot product of two complex vectors, one conjugated: CDOTC/ZDOTC
template <typename T>
StatusCode Dotc(const size_t n,
cl_mem dot_buffer, const size_t dot_offset,
@@ -257,138 +258,150 @@ template StatusCode Dotc<float2>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
template StatusCode Dotc<double2>(const size_t,
cl_mem, const size_t,
const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- cl_command_queue* queue, cl_event* event);
+ cl_command_queue*, cl_event*);
// =================================================================================================
// BLAS level-2 (matrix-vector) routines
// =================================================================================================
-// GEMV
+// Generalized matrix-vector multiplication: SGEMV/DGEMV/CGEMV/ZGEMV
template <typename T>
StatusCode Gemv(const Layout layout, const Transpose a_transpose,
- const size_t m, const size_t n, const T alpha,
+ const size_t m, const size_t n,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const T beta,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const T beta,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event) {
-
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xgemv<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoGemv(layout, a_transpose, m, n, alpha,
+ return routine.DoGemv(layout, a_transpose,
+ m, n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(x_buffer), x_offset, x_inc, beta,
+ Buffer<T>(x_buffer), x_offset, x_inc,
+ beta,
Buffer<T>(y_buffer), y_offset, y_inc);
}
template StatusCode Gemv<float>(const Layout, const Transpose,
- const size_t, const size_t, const float,
+ const size_t, const size_t,
+ const float,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const cl_mem, const size_t, const size_t,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemv<double>(const Layout, const Transpose,
- const size_t, const size_t, const double,
+ const size_t, const size_t,
+ const double,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const cl_mem, const size_t, const size_t,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemv<float2>(const Layout, const Transpose,
- const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const cl_mem, const size_t, const size_t,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemv<double2>(const Layout, const Transpose,
- const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const cl_mem, const size_t, const size_t,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// HEMV
+// Hermitian matrix-vector multiplication: CHEMV/ZHEMV
template <typename T>
StatusCode Hemv(const Layout layout, const Triangle triangle,
- const size_t n, const T alpha,
+ const size_t n,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const T beta,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const T beta,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event) {
-
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xhemv<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoHemv(layout, triangle, n, alpha,
+ return routine.DoHemv(layout, triangle,
+ n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(x_buffer), x_offset, x_inc, beta,
+ Buffer<T>(x_buffer), x_offset, x_inc,
+ beta,
Buffer<T>(y_buffer), y_offset, y_inc);
}
template StatusCode Hemv<float2>(const Layout, const Triangle,
- const size_t, const float2,
+ const size_t,
+ const float2,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const cl_mem, const size_t, const size_t,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Hemv<double2>(const Layout, const Triangle,
- const size_t, const double2,
+ const size_t,
+ const double2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// SYMV
+// Symmetric matrix-vector multiplication: SSYMV/DSYMV
template <typename T>
StatusCode Symv(const Layout layout, const Triangle triangle,
- const size_t n, const T alpha,
+ const size_t n,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const T beta,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const T beta,
cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
cl_command_queue* queue, cl_event* event) {
-
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xsymv<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoSymv(layout, triangle, n, alpha,
+ return routine.DoSymv(layout, triangle,
+ n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(x_buffer), x_offset, x_inc, beta,
+ Buffer<T>(x_buffer), x_offset, x_inc,
+ beta,
Buffer<T>(y_buffer), y_offset, y_inc);
}
template StatusCode Symv<float>(const Layout, const Triangle,
- const size_t, const float,
+ const size_t,
+ const float,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const cl_mem, const size_t, const size_t,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Symv<double>(const Layout, const Triangle,
- const size_t, const double,
+ const size_t,
+ const double,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
@@ -396,307 +409,343 @@ template StatusCode Symv<double>(const Layout, const Triangle,
// BLAS level-3 (matrix-matrix) routines
// =================================================================================================
-// GEMM
+// Generalized matrix-matrix multiplication: SGEMM/DGEMM/CGEMM/ZGEMM
template <typename T>
StatusCode Gemm(const Layout layout, const Transpose a_transpose, const Transpose b_transpose,
- const size_t m, const size_t n, const size_t k, const T alpha,
+ const size_t m, const size_t n, const size_t k,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const T beta,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xgemm<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoGemm(layout, a_transpose, b_transpose, m, n, k, alpha,
+ return routine.DoGemm(layout, a_transpose, b_transpose,
+ m, n, k,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld, beta,
+ Buffer<T>(b_buffer), b_offset, b_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Gemm<float>(const Layout, const Transpose, const Transpose,
- const size_t, const size_t, const size_t, const float,
+ const size_t, const size_t, const size_t,
+ const float,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemm<double>(const Layout, const Transpose, const Transpose,
- const size_t, const size_t, const size_t, const double,
+ const size_t, const size_t, const size_t,
+ const double,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const cl_mem, const size_t, const size_t,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemm<float2>(const Layout, const Transpose, const Transpose,
- const size_t, const size_t, const size_t, const float2,
+ const size_t, const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Gemm<double2>(const Layout, const Transpose, const Transpose,
- const size_t, const size_t, const size_t, const double2,
+ const size_t, const size_t, const size_t,
+ const double2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// SYMM
+// Symmetric matrix-matrix multiplication: SSYMM/DSYMM/CSYMM/ZSYMM
template <typename T>
StatusCode Symm(const Layout layout, const Side side, const Triangle triangle,
- const size_t m, const size_t n, const T alpha,
+ const size_t m, const size_t n,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const T beta,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xsymm<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoSymm(layout, side, triangle, m, n, alpha,
+ return routine.DoSymm(layout, side, triangle,
+ m, n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld, beta,
+ Buffer<T>(b_buffer), b_offset, b_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Symm<float>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const float,
+ const size_t, const size_t,
+ const float,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Symm<double>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const double,
+ const size_t, const size_t,
+ const double,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Symm<float2>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Symm<double2>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const cl_mem, const size_t, const size_t,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// HEMM
+// Hermitian matrix-matrix multiplication: CHEMM/ZHEMM
template <typename T>
StatusCode Hemm(const Layout layout, const Side side, const Triangle triangle,
- const size_t m, const size_t n, const T alpha,
+ const size_t m, const size_t n,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const T beta,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xhemm<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoHemm(layout, side, triangle, m, n, alpha,
+ return routine.DoHemm(layout, side, triangle,
+ m, n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld, beta,
+ Buffer<T>(b_buffer), b_offset, b_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Hemm<float2>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Hemm<double2>(const Layout, const Side, const Triangle,
- const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const cl_mem, const size_t, const size_t,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// SYRK
+// Rank-K update of a symmetric matrix: SSYRK/DSYRK/CSYRK/ZSYRK
template <typename T>
StatusCode Syrk(const Layout layout, const Triangle triangle, const Transpose a_transpose,
- const size_t n, const size_t k, const T alpha,
- const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const T beta,
+ const size_t n, const size_t k,
+ const T alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xsyrk<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoSyrk(layout, triangle, a_transpose, n, k, alpha,
- Buffer<T>(a_buffer), a_offset, a_ld, beta,
+ return routine.DoSyrk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ Buffer<T>(a_buffer), a_offset, a_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Syrk<float>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float,
- const cl_mem, const size_t, const size_t, const float,
+ const size_t, const size_t,
+ const float,
+ const cl_mem, const size_t, const size_t,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syrk<double>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double,
- const cl_mem, const size_t, const size_t, const double,
+ const size_t, const size_t,
+ const double,
+ const cl_mem, const size_t, const size_t,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syrk<float2>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float2,
- const cl_mem, const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syrk<double2>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double2,
- const cl_mem, const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
+ const cl_mem, const size_t, const size_t,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// HERK
+// Rank-K update of a hermitian matrix: CHERK/ZHERK
template <typename T>
StatusCode Herk(const Layout layout, const Triangle triangle, const Transpose a_transpose,
- const size_t n, const size_t k, const T alpha,
- const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const T beta,
+ const size_t n, const size_t k,
+ const T alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xherk<std::complex<T>,T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoHerk(layout, triangle, a_transpose, n, k, alpha,
- Buffer<std::complex<T>>(a_buffer), a_offset, a_ld, beta,
+ return routine.DoHerk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ Buffer<std::complex<T>>(a_buffer), a_offset, a_ld,
+ beta,
Buffer<std::complex<T>>(c_buffer), c_offset, c_ld);
}
template StatusCode Herk<float>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float,
- const cl_mem, const size_t, const size_t, const float,
+ const size_t, const size_t,
+ const float,
+ const cl_mem, const size_t, const size_t,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Herk<double>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double,
- const cl_mem, const size_t, const size_t, const double,
+ const size_t, const size_t,
+ const double,
+ const cl_mem, const size_t, const size_t,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// SYR2K
+// Rank-2K update of a symmetric matrix: SSYR2K/DSYR2K/CSYR2K/ZSYR2K
template <typename T>
StatusCode Syr2k(const Layout layout, const Triangle triangle, const Transpose ab_transpose,
- const size_t n, const size_t k, const T alpha,
+ const size_t n, const size_t k,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const T beta,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const T beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xsyr2k<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoSyr2k(layout, triangle, ab_transpose, n, k, alpha,
+ return routine.DoSyr2k(layout, triangle, ab_transpose,
+ n, k,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld, beta,
+ Buffer<T>(b_buffer), b_offset, b_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Syr2k<float>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float,
+ const size_t, const size_t,
+ const float,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syr2k<double>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double,
+ const size_t, const size_t,
+ const double,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const cl_mem, const size_t, const size_t,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syr2k<float2>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float2,
+ const float2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Syr2k<double2>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double2,
+ const double2,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// SYR2K
+// Rank-2K update of a hermitian matrix: CHER2K/ZHER2K
template <typename T, typename U>
StatusCode Her2k(const Layout layout, const Triangle triangle, const Transpose ab_transpose,
- const size_t n, const size_t k, const T alpha,
+ const size_t n, const size_t k,
+ const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const U beta,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const U beta,
cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
cl_command_queue* queue, cl_event* event) {
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xher2k<T,U>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoHer2k(layout, triangle, ab_transpose, n, k, alpha,
+ return routine.DoHer2k(layout, triangle, ab_transpose,
+ n, k,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld, beta,
+ Buffer<T>(b_buffer), b_offset, b_ld,
+ beta,
Buffer<T>(c_buffer), c_offset, c_ld);
}
template StatusCode Her2k<float2,float>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const float2,
+ const size_t, const size_t,
+ const float2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const float,
+ const float,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
template StatusCode Her2k<double2,double>(const Layout, const Triangle, const Transpose,
- const size_t, const size_t, const double2,
+ const size_t, const size_t,
+ const double2,
+ const cl_mem, const size_t, const size_t,
const cl_mem, const size_t, const size_t,
- const cl_mem, const size_t, const size_t, const double,
+ const double,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-// =================================================================================================
-
-// TRMM
+// Triangular matrix-matrix multiplication: STRMM/DTRMM/CTRMM/ZTRMM
template <typename T>
-StatusCode Trmm(const Layout layout, const Side side, const Triangle triangle,
- const Transpose a_transpose, const Diagonal diagonal,
+StatusCode Trmm(const Layout layout, const Side side, const Triangle triangle, const Transpose a_transpose, const Diagonal diagonal,
const size_t m, const size_t n,
const T alpha,
const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
@@ -705,90 +754,38 @@ StatusCode Trmm(const Layout layout, const Side side, const Triangle triangle,
auto queue_cpp = Queue(*queue);
auto event_cpp = Event(*event);
auto routine = Xtrmm<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
auto status = routine.SetUp();
if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoTrmm(layout, side, triangle, a_transpose, diagonal, m, n, alpha,
+ return routine.DoTrmm(layout, side, triangle, a_transpose, diagonal,
+ m, n,
+ alpha,
Buffer<T>(a_buffer), a_offset, a_ld,
Buffer<T>(b_buffer), b_offset, b_ld);
}
-template StatusCode Trmm<float>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const float,
+template StatusCode Trmm<float>(const Layout, const Side, const Triangle, const Transpose, const Diagonal,
+ const size_t, const size_t,
+ const float,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-template StatusCode Trmm<double>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const double,
+template StatusCode Trmm<double>(const Layout, const Side, const Triangle, const Transpose, const Diagonal,
+ const size_t, const size_t,
+ const double,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-template StatusCode Trmm<float2>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const float2,
+template StatusCode Trmm<float2>(const Layout, const Side, const Triangle, const Transpose, const Diagonal,
+ const size_t, const size_t,
+ const float2,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
-template StatusCode Trmm<double2>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const double2,
+template StatusCode Trmm<double2>(const Layout, const Side, const Triangle, const Transpose, const Diagonal,
+ const size_t, const size_t,
+ const double2,
const cl_mem, const size_t, const size_t,
cl_mem, const size_t, const size_t,
cl_command_queue*, cl_event*);
// =================================================================================================
-
-// TRSM
-/*
-template <typename T>
-StatusCode Trsm(const Layout layout, const Side side, const Triangle triangle,
- const Transpose a_transpose, const Diagonal diagonal,
- const size_t m, const size_t n,
- const T alpha,
- const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
- cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
- cl_command_queue* queue, cl_event* event) {
- auto queue_cpp = Queue(*queue);
- auto event_cpp = Event(*event);
- auto routine = Xtrsm<T>(queue_cpp, event_cpp);
-
- // Compiles the routine's device kernels
- auto status = routine.SetUp();
- if (status != StatusCode::kSuccess) { return status; }
-
- // Runs the routine
- return routine.DoTrsm(layout, side, triangle, a_transpose, diagonal, m, n, alpha,
- Buffer<T>(a_buffer), a_offset, a_ld,
- Buffer<T>(b_buffer), b_offset, b_ld);
-}
-template StatusCode Trsm<float>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const float,
- const cl_mem, const size_t, const size_t,
- cl_mem, const size_t, const size_t,
- cl_command_queue*, cl_event*);
-template StatusCode Trsm<double>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const double,
- const cl_mem, const size_t, const size_t,
- cl_mem, const size_t, const size_t,
- cl_command_queue*, cl_event*);
-template StatusCode Trsm<float2>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const float2,
- const cl_mem, const size_t, const size_t,
- cl_mem, const size_t, const size_t,
- cl_command_queue*, cl_event*);
-template StatusCode Trsm<double2>(const Layout, const Side, const Triangle,
- const Transpose, const Diagonal,
- const size_t, const size_t, const double2,
- const cl_mem, const size_t, const size_t,
- cl_mem, const size_t, const size_t,
- cl_command_queue*, cl_event*);
-*/
-// =================================================================================================
} // namespace clblast
diff --git a/test/wrapper_clblas.h b/test/wrapper_clblas.h
index fcf1a918..85729470 100644
--- a/test/wrapper_clblas.h
+++ b/test/wrapper_clblas.h
@@ -20,216 +20,222 @@
#include "internal/utilities.h"
namespace clblast {
+
// =================================================================================================
// BLAS level-1 (vector-vector) routines
+// =================================================================================================
-// Calls {clblasSswap, clblasDswap, clblasCswap, clblasZswap} with the arguments forwarded.
-template <typename T> clblasStatus clblasXswap(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
-template <> clblasStatus clblasXswap<float>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSswap(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXswap<double>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDswap(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXswap<float2>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasCswap(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXswap<double2>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasZswap(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSWAP/DSWAP/CSWAP/ZSWAP
+template <typename T>
+clblasStatus clblasXswap(const size_t n,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
+template <>
+clblasStatus clblasXswap<float>(const size_t n,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSswap(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXswap<double>(const size_t n,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDswap(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXswap<float2>(const size_t n,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCswap(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXswap<double2>(const size_t n,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZswap(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// Calls {clblasSscal, clblasDscal, clblasCscal, clblasZscal} with the arguments forwarded.
-clblasStatus clblasXscal(
- size_t n, float alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSscal(n, alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXscal(
- size_t n, double alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDscal(n, alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXscal(
- size_t n, float2 alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- return clblasCscal(n, cl_alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXscal(
- size_t n, double2 alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- return clblasZscal(n, cl_alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSCAL/DSCAL/CSCAL/ZSCAL
+clblasStatus clblasXscal(const size_t n,
+ const float alpha,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSscal(n,
+ alpha,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXscal(const size_t n,
+ const double alpha,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDscal(n,
+ alpha,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXscal(const size_t n,
+ const float2 alpha,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCscal(n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXscal(const size_t n,
+ const double2 alpha,
+ cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZscal(n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// Calls {clblasScopy, clblasDcopy, clblasCcopy, clblasZcopy} with the arguments forwarded.
-template <typename T> clblasStatus clblasXcopy(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
-template <> clblasStatus clblasXcopy<float>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasScopy(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXcopy<double>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDcopy(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXcopy<float2>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasCcopy(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-template <> clblasStatus clblasXcopy<double2>(
- size_t n,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasZcopy(n,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SCOPY/DCOPY/CCOPY/ZCOPY
+template <typename T>
+clblasStatus clblasXcopy(const size_t n,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
+template <>
+clblasStatus clblasXcopy<float>(const size_t n,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasScopy(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXcopy<double>(const size_t n,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDcopy(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXcopy<float2>(const size_t n,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCcopy(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+template <>
+clblasStatus clblasXcopy<double2>(const size_t n,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZcopy(n,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// Calls {clblasSaxpy, clblasDaxpy, clblasCaxpy, clblasZaxpy} with the arguments forwarded.
-clblasStatus clblasXaxpy(
- size_t n, float alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSaxpy(n, alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXaxpy(
- size_t n, double alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDaxpy(n, alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXaxpy(
- size_t n, float2 alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- return clblasCaxpy(n, cl_alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXaxpy(
- size_t n, double2 alpha,
- const cl_mem x_vec, size_t x_offset, size_t x_inc,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- return clblasZaxpy(n, cl_alpha,
- x_vec, x_offset, static_cast<int>(x_inc),
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SAXPY/DAXPY/CAXPY/ZAXPY
+clblasStatus clblasXaxpy(const size_t n,
+ const float alpha,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSaxpy(n,
+ alpha,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXaxpy(const size_t n,
+ const double alpha,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDaxpy(n,
+ alpha,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXaxpy(const size_t n,
+ const float2 alpha,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCaxpy(n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXaxpy(const size_t n,
+ const double2 alpha,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZaxpy(n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
// Forwards the clBLAS calls for SDOT/DDOT
-template <typename T> clblasStatus clblasXdot(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
-template <> clblasStatus clblasXdot<float>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <typename T>
+clblasStatus clblasXdot(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
+template <>
+clblasStatus clblasXdot<float>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<float>(context, n);
@@ -240,13 +246,13 @@ template <> clblasStatus clblasXdot<float>(
scratch_buffer(),
num_queues, queues, num_wait_events, wait_events, events);
}
-template <> clblasStatus clblasXdot<double>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <>
+clblasStatus clblasXdot<double>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<double>(context, n);
@@ -259,20 +265,20 @@ template <> clblasStatus clblasXdot<double>(
}
// Forwards the clBLAS calls for CDOTU/ZDOTU
-template <typename T> clblasStatus clblasXdotu(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
-template <> clblasStatus clblasXdotu<float2>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <typename T>
+clblasStatus clblasXdotu(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
+template <>
+clblasStatus clblasXdotu<float2>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<float2>(context, n);
@@ -283,13 +289,13 @@ template <> clblasStatus clblasXdotu<float2>(
scratch_buffer(),
num_queues, queues, num_wait_events, wait_events, events);
}
-template <> clblasStatus clblasXdotu<double2>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <>
+clblasStatus clblasXdotu<double2>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<double2>(context, n);
@@ -302,20 +308,20 @@ template <> clblasStatus clblasXdotu<double2>(
}
// Forwards the clBLAS calls for CDOTC/ZDOTC
-template <typename T> clblasStatus clblasXdotc(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
-template <> clblasStatus clblasXdotc<float2>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <typename T>
+clblasStatus clblasXdotc(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events);
+template <>
+clblasStatus clblasXdotc<float2>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<float2>(context, n);
@@ -326,13 +332,13 @@ template <> clblasStatus clblasXdotc<float2>(
scratch_buffer(),
num_queues, queues, num_wait_events, wait_events, events);
}
-template <> clblasStatus clblasXdotc<double2>(
- const size_t n,
- cl_mem dot_buffer, const size_t dot_offset,
- const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
- const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+template <>
+clblasStatus clblasXdotc<double2>(const size_t n,
+ cl_mem dot_buffer, const size_t dot_offset,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
auto queue = Queue(queues[0]);
auto context = queue.GetContext();
auto scratch_buffer = Buffer<double2>(context, n);
@@ -346,600 +352,616 @@ template <> clblasStatus clblasXdotc<double2>(
// =================================================================================================
// BLAS level-2 (matrix-vector) routines
+// =================================================================================================
-// Calls {clblasSgemv, clblasDgemv, clblasCgemv, clblasZgemv} with the arguments forwarded.
-clblasStatus clblasXgemv(
- clblasOrder layout, clblasTranspose a_transpose, size_t m, size_t n, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, float beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSgemv(layout, a_transpose, m, n, alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemv(
- clblasOrder layout, clblasTranspose a_transpose, size_t m, size_t n, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, double beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDgemv(layout, a_transpose, m, n, alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemv(
- clblasOrder layout, clblasTranspose a_transpose, size_t m, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, float2 beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasCgemv(layout, a_transpose, m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), cl_beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemv(
- clblasOrder layout, clblasTranspose a_transpose, size_t m, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, double2 beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZgemv(layout, a_transpose, m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), cl_beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SGEMV/DGEMV/CGEMV/ZGEMV
+clblasStatus clblasXgemv(const clblasOrder layout, const clblasTranspose a_transpose,
+ const size_t m, const size_t n,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const float beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSgemv(layout, a_transpose,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ beta,
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXgemv(const clblasOrder layout, const clblasTranspose a_transpose,
+ const size_t m, const size_t n,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const double beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDgemv(layout, a_transpose,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ beta,
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXgemv(const clblasOrder layout, const clblasTranspose a_transpose,
+ const size_t m, const size_t n,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const float2 beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCgemv(layout, a_transpose,
+ m, n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ cl_float2{{beta.real(), beta.imag()}},
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXgemv(const clblasOrder layout, const clblasTranspose a_transpose,
+ const size_t m, const size_t n,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const double2 beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZgemv(layout, a_transpose,
+ m, n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ cl_double2{{beta.real(), beta.imag()}},
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// Calls {clblasChemv, clblasZhemv} with the arguments forwarded.
-clblasStatus clblasXhemv(
- clblasOrder layout, clblasUplo triangle, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, float2 beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasChemv(layout, triangle, n, cl_alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), cl_beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXhemv(
- clblasOrder layout, clblasUplo triangle, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, double2 beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZhemv(layout, triangle, n, cl_alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), cl_beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for CHEMV/ZHEMV
+clblasStatus clblasXhemv(const clblasOrder layout, const clblasUplo triangle,
+ const size_t n,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const float2 beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasChemv(layout, triangle,
+ n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ cl_float2{{beta.real(), beta.imag()}},
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXhemv(const clblasOrder layout, const clblasUplo triangle,
+ const size_t n,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const double2 beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZhemv(layout, triangle,
+ n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ cl_double2{{beta.real(), beta.imag()}},
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// Calls {clblasSsymv, clblasDsymv} with the arguments forwarded.
-clblasStatus clblasXsymv(
- clblasOrder layout, clblasUplo triangle, size_t n, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, float beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSsymv(layout, triangle, n, alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsymv(
- clblasOrder layout, clblasUplo triangle, size_t n, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem x_vec, size_t x_offset, size_t x_inc, double beta,
- const cl_mem y_vec, size_t y_offset, size_t y_inc,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDsymv(layout, triangle, n, alpha,
- a_mat, a_offset, a_ld,
- x_vec, x_offset, static_cast<int>(x_inc), beta,
- y_vec, y_offset, static_cast<int>(y_inc),
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSYMV/DSYMV
+clblasStatus clblasXsymv(const clblasOrder layout, const clblasUplo triangle,
+ const size_t n,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const float beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSsymv(layout, triangle,
+ n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ beta,
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsymv(const clblasOrder layout, const clblasUplo triangle,
+ const size_t n,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
+ const double beta,
+ cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDsymv(layout, triangle,
+ n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ x_buffer, x_offset, static_cast<int>(x_inc),
+ beta,
+ y_buffer, y_offset, static_cast<int>(y_inc),
+ num_queues, queues, num_wait_events, wait_events, events);
}
// =================================================================================================
// BLAS level-3 (matrix-matrix) routines
+// =================================================================================================
-// This calls {clblasSgemm, clblasDgemm, clblasCgemm, clblasZgemm} with the arguments forwarded.
-clblasStatus clblasXgemm(
- clblasOrder layout, clblasTranspose a_transpose, clblasTranspose b_transpose,
- size_t m, size_t n, size_t k, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSgemm(layout, a_transpose, b_transpose,
- m, n, k, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemm(
- clblasOrder layout, clblasTranspose a_transpose, clblasTranspose b_transpose,
- size_t m, size_t n, size_t k, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDgemm(layout, a_transpose, b_transpose,
- m, n, k, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemm(
- clblasOrder layout, clblasTranspose a_transpose, clblasTranspose b_transpose,
- size_t m, size_t n, size_t k, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasCgemm(layout, a_transpose, b_transpose,
- m, n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXgemm(
- clblasOrder layout, clblasTranspose a_transpose, clblasTranspose b_transpose,
- size_t m, size_t n, size_t k, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZgemm(layout, a_transpose, b_transpose,
- m, n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SGEMM/DGEMM/CGEMM/ZGEMM
+clblasStatus clblasXgemm(const clblasOrder layout, const clblasTranspose a_transpose, const clblasTranspose b_transpose,
+ const size_t m, const size_t n, const size_t k,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSgemm(layout, a_transpose, b_transpose,
+ m, n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-
-// This calls {clblasSsymm, clblasDsymm, clblasCsymm, clblasZsymm} with the arguments forwarded.
-clblasStatus clblasXsymm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSsymm(layout, side, triangle,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsymm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDsymm(layout, side, triangle,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsymm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasCsymm(layout, side, triangle,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsymm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZsymm(layout, side, triangle,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+clblasStatus clblasXgemm(const clblasOrder layout, const clblasTranspose a_transpose, const clblasTranspose b_transpose,
+ const size_t m, const size_t n, const size_t k,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDgemm(layout, a_transpose, b_transpose,
+ m, n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXgemm(const clblasOrder layout, const clblasTranspose a_transpose, const clblasTranspose b_transpose,
+ const size_t m, const size_t n, const size_t k,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCgemm(layout, a_transpose, b_transpose,
+ m, n, k,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_float2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXgemm(const clblasOrder layout, const clblasTranspose a_transpose, const clblasTranspose b_transpose,
+ const size_t m, const size_t n, const size_t k,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZgemm(layout, a_transpose, b_transpose,
+ m, n, k,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_double2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasChemm, clblasZhemm} with the arguments forwarded.
-clblasStatus clblasXhemm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasChemm(layout, side, triangle,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXhemm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- size_t m, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZhemm(layout, side, triangle,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSYMM/DSYMM/CSYMM/ZSYMM
+clblasStatus clblasXsymm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSsymm(layout, side, triangle,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsymm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDsymm(layout, side, triangle,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsymm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCsymm(layout, side, triangle,
+ m, n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_float2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsymm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZsymm(layout, side, triangle,
+ m, n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_double2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasSsyrk, clblasDsyrk, clblasCsyrk, clblasZsyrk} with the arguments forwarded.
-clblasStatus clblasXsyrk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSsyrk(layout, triangle, a_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyrk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDsyrk(layout, triangle, a_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyrk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, float2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasCsyrk(layout, triangle, a_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyrk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, double2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZsyrk(layout, triangle, a_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for CHEMM/ZHEMM
+clblasStatus clblasXhemm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasChemm(layout, side, triangle,
+ m, n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_float2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXhemm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle,
+ const size_t m, const size_t n,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZhemm(layout, side, triangle,
+ m, n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_double2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasCherk, clblasZherk} with the arguments forwarded.
-clblasStatus clblasXherk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasCherk(layout, triangle, a_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXherk(
- clblasOrder layout, clblasUplo triangle, clblasTranspose a_transpose,
- size_t n, size_t k, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasZherk(layout, triangle, a_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSYRK/DSYRK/CSYRK/ZSYRK
+clblasStatus clblasXsyrk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSsyrk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyrk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDsyrk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyrk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const float2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCsyrk(layout, triangle, a_transpose,
+ n, k,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ cl_float2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyrk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const double2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZsyrk(layout, triangle, a_transpose,
+ n, k,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ cl_double2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasSsyr2k, clblasDsyr2k, clblasCsyr2k, clblasZsyr2k} with the arguments forwarded.
-clblasStatus clblasXsyr2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasSsyr2k(layout, triangle, ab_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyr2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDsyr2k(layout, triangle, ab_transpose,
- n, k, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyr2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_float2{{beta.real(), beta.imag()}};
- return clblasCsyr2k(layout, triangle, ab_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXsyr2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double2 beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- auto cl_beta = cl_double2{{beta.real(), beta.imag()}};
- return clblasZsyr2k(layout, triangle, ab_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, cl_beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for CHERK/ZHERK
+clblasStatus clblasXherk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCherk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXherk(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose a_transpose,
+ const size_t n, const size_t k,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZherk(layout, triangle, a_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasCher2k, clblasZher2k} with the arguments forwarded.
-clblasStatus clblasXher2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, float beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- return clblasCher2k(layout, triangle, ab_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXher2k(
- clblasOrder layout, clblasUplo triangle, clblasTranspose ab_transpose,
- size_t n, size_t k, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld, double beta,
- const cl_mem c_mat, size_t c_offset, size_t c_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- return clblasZher2k(layout, triangle, ab_transpose,
- n, k, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld, beta,
- c_mat, c_offset, c_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for SSYR2K/DSYR2K/CSYR2K/ZSYR2K
+clblasStatus clblasXsyr2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasSsyr2k(layout, triangle, ab_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyr2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDsyr2k(layout, triangle, ab_transpose,
+ n, k,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyr2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCsyr2k(layout, triangle, ab_transpose,
+ n, k,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_float2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXsyr2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double2 beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZsyr2k(layout, triangle, ab_transpose,
+ n, k,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ cl_double2{{beta.real(), beta.imag()}},
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasStrmm, clblasDtrmm, clblasCtrmm, clblasZtrmm} with the arguments forwarded.
-clblasStatus clblasXtrmm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasStrmm(layout, side, triangle, a_transpose, diagonal,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrmm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDtrmm(layout, side, triangle, a_transpose, diagonal,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrmm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- return clblasCtrmm(layout, side, triangle, a_transpose, diagonal,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrmm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- return clblasZtrmm(layout, side, triangle, a_transpose, diagonal,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for CHER2K/ZHER2K
+clblasStatus clblasXher2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const float beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCher2k(layout, triangle, ab_transpose,
+ n, k,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXher2k(const clblasOrder layout, const clblasUplo triangle, const clblasTranspose ab_transpose,
+ const size_t n, const size_t k,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ const double beta,
+ cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZher2k(layout, triangle, ab_transpose,
+ n, k,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ beta,
+ c_buffer, c_offset, c_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
-// This calls {clblasStrsm, clblasDtrsm, clblasCtrsm, clblasZtrsm} with the arguments forwarded.
-clblasStatus clblasXtrsm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, float alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasStrsm(layout, side, triangle, a_transpose, diagonal,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrsm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, double alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- return clblasDtrsm(layout, side, triangle, a_transpose, diagonal,
- m, n, alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrsm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, float2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_float2{{alpha.real(), alpha.imag()}};
- return clblasCtrsm(layout, side, triangle, a_transpose, diagonal,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
-}
-clblasStatus clblasXtrsm(
- clblasOrder layout, clblasSide side, clblasUplo triangle,
- clblasTranspose a_transpose, clblasDiag diagonal,
- size_t m, size_t n, double2 alpha,
- const cl_mem a_mat, size_t a_offset, size_t a_ld,
- const cl_mem b_mat, size_t b_offset, size_t b_ld,
- cl_uint num_queues, cl_command_queue *queues,
- cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
- auto cl_alpha = cl_double2{{alpha.real(), alpha.imag()}};
- return clblasZtrsm(layout, side, triangle, a_transpose, diagonal,
- m, n, cl_alpha,
- a_mat, a_offset, a_ld,
- b_mat, b_offset, b_ld,
- num_queues, queues, num_wait_events, wait_events, events);
+// Forwards the clBLAS calls for STRMM/DTRMM/CTRMM/ZTRMM
+clblasStatus clblasXtrmm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle, const clblasTranspose a_transpose, const clblasDiag diagonal,
+ const size_t m, const size_t n,
+ const float alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasStrmm(layout, side, triangle, a_transpose, diagonal,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXtrmm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle, const clblasTranspose a_transpose, const clblasDiag diagonal,
+ const size_t m, const size_t n,
+ const double alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasDtrmm(layout, side, triangle, a_transpose, diagonal,
+ m, n,
+ alpha,
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXtrmm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle, const clblasTranspose a_transpose, const clblasDiag diagonal,
+ const size_t m, const size_t n,
+ const float2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasCtrmm(layout, side, triangle, a_transpose, diagonal,
+ m, n,
+ cl_float2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
+}
+clblasStatus clblasXtrmm(const clblasOrder layout, const clblasSide side, const clblasUplo triangle, const clblasTranspose a_transpose, const clblasDiag diagonal,
+ const size_t m, const size_t n,
+ const double2 alpha,
+ const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
+ cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
+ cl_uint num_queues, cl_command_queue *queues,
+ cl_uint num_wait_events, const cl_event *wait_events, cl_event *events) {
+ return clblasZtrmm(layout, side, triangle, a_transpose, diagonal,
+ m, n,
+ cl_double2{{alpha.real(), alpha.imag()}},
+ a_buffer, a_offset, a_ld,
+ b_buffer, b_offset, b_ld,
+ num_queues, queues, num_wait_events, wait_events, events);
}
// =================================================================================================
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-04 23:40:40 +0000