diff options
author | CNugteren <web@cedricnugteren.nl> | 2015-06-29 20:38:34 +0200 |
---|---|---|
committer | CNugteren <web@cedricnugteren.nl> | 2015-06-29 20:38:34 +0200 |
commit | 2914a285d43cac7e3a9d4885684229fbf82babb0 (patch) | |
tree | 01c740740d81fe893e88f40d8385d5c6325fabc0 | |
parent | e5c0edbfd7dcfe96af6cca6c25ca8b346871b014 (diff) |
Re-organized the performance-client infrastructure to avoid code duplication
-rw-r--r-- | test/performance/client.cc | 458 | ||||
-rw-r--r-- | test/performance/client.h | 104 | ||||
-rw-r--r-- | test/performance/routines/xaxpy.cc | 89 | ||||
-rw-r--r-- | test/performance/routines/xgemm.cc | 107 | ||||
-rw-r--r-- | test/performance/routines/xgemv.cc | 99 | ||||
-rw-r--r-- | test/performance/routines/xsymm.cc | 107 | ||||
-rw-r--r-- | test/performance/routines/xsyr2k.cc | 107 | ||||
-rw-r--r-- | test/performance/routines/xsyrk.cc | 105 | ||||
-rw-r--r-- | test/routines/xaxpy.h | 25 | ||||
-rw-r--r-- | test/routines/xgemm.h | 22 | ||||
-rw-r--r-- | test/routines/xgemv.h | 26 | ||||
-rw-r--r-- | test/routines/xsymm.h | 22 | ||||
-rw-r--r-- | test/routines/xsyr2k.h | 24 | ||||
-rw-r--r-- | test/routines/xsyrk.h | 21 |
14 files changed, 414 insertions, 902 deletions
diff --git a/test/performance/client.cc b/test/performance/client.cc index b089f925..71471dde 100644 --- a/test/performance/client.cc +++ b/test/performance/client.cc @@ -21,323 +21,36 @@ namespace clblast { // ================================================================================================= -// This is the vector-vector variant of the set-up/tear-down client routine. +// Constructor template <typename T> -void ClientXY(int argc, char *argv[], Routine2<T> client_routine, - const std::vector<std::string> &options) { - - // Function to determine how to find the default value of the leading dimension of matrix A. - // Note: this is not relevant for this client but given anyway. - auto default_ld_a = [](const Arguments<T> args) { return args.n; }; - - // Simple command line argument parser with defaults - auto args = ParseArguments<T>(argc, argv, options, default_ld_a); - if (args.print_help) { return; } - - // Prints the header of the output table - PrintTableHeader(args.silent, options); - - // Initializes OpenCL and the libraries - auto platform = Platform(args.platform_id); - auto device = Device(platform, kDeviceType, args.device_id); - auto context = Context(device); - auto queue = CommandQueue(context, device); - if (args.compare_clblas) { clblasSetup(); } - - // Iterates over all "num_step" values jumping by "step" each time - auto s = size_t{0}; - while(true) { - - // Computes the data sizes - auto x_size = args.n*args.x_inc + args.x_offset; - auto y_size = args.n*args.y_inc + args.y_offset; - - // Populates input host vectors with random data - std::vector<T> x_source(x_size); - std::vector<T> y_source(y_size); - PopulateVector(x_source); - PopulateVector(y_source); - - // Creates the vectors on the device - auto x_buffer = Buffer(context, CL_MEM_READ_WRITE, x_size*sizeof(T)); - auto y_buffer = Buffer(context, CL_MEM_READ_WRITE, y_size*sizeof(T)); - x_buffer.WriteBuffer(queue, x_size*sizeof(T), x_source); - y_buffer.WriteBuffer(queue, y_size*sizeof(T), y_source); - - // Runs the routine-specific code - client_routine(args, x_buffer, y_buffer, queue); - - // Makes the jump to the next step - ++s; - if (s >= args.num_steps) { break; } - args.n += args.step; - } - - // Cleans-up and returns - if (args.compare_clblas) { clblasTeardown(); } -} - -// Compiles the above function -template void ClientXY<float>(int, char **, Routine2<float>, const std::vector<std::string>&); -template void ClientXY<double>(int, char **, Routine2<double>, const std::vector<std::string>&); -template void ClientXY<float2>(int, char **, Routine2<float2>, const std::vector<std::string>&); -template void ClientXY<double2>(int, char **, Routine2<double2>, const std::vector<std::string>&); - -// ================================================================================================= - -// This is the matrix-vector-vector variant of the set-up/tear-down client routine. -template <typename T> -void ClientAXY(int argc, char *argv[], Routine3<T> client_routine, - const std::vector<std::string> &options) { - - // Function to determine how to find the default value of the leading dimension of matrix A - auto default_ld_a = [](const Arguments<T> args) { return args.n; }; - - // Simple command line argument parser with defaults - auto args = ParseArguments<T>(argc, argv, options, default_ld_a); - if (args.print_help) { return; } - - // Prints the header of the output table - PrintTableHeader(args.silent, options); - - // Initializes OpenCL and the libraries - auto platform = Platform(args.platform_id); - auto device = Device(platform, kDeviceType, args.device_id); - auto context = Context(device); - auto queue = CommandQueue(context, device); - if (args.compare_clblas) { clblasSetup(); } - - // Iterates over all "num_step" values jumping by "step" each time - auto s = size_t{0}; - while(true) { - - // Computes the second dimension of the matrix taking the rotation into account - auto a_two = (args.layout == Layout::kRowMajor) ? args.m : args.n; - - // Computes the vector sizes in case the matrix is transposed - auto a_transposed = (args.a_transpose != Transpose::kNo); - auto m_real = (a_transposed) ? args.n : args.m; - auto n_real = (a_transposed) ? args.m : args.n; - - // Computes the data sizes - auto a_size = a_two * args.a_ld + args.a_offset; - auto x_size = n_real*args.x_inc + args.x_offset; - auto y_size = m_real*args.y_inc + args.y_offset; - - // Populates input host vectors with random data - std::vector<T> a_source(a_size); - std::vector<T> x_source(x_size); - std::vector<T> y_source(y_size); - PopulateVector(a_source); - PopulateVector(x_source); - PopulateVector(y_source); - - // Creates the vectors on the device - auto a_buffer = Buffer(context, CL_MEM_READ_WRITE, a_size*sizeof(T)); - auto x_buffer = Buffer(context, CL_MEM_READ_WRITE, x_size*sizeof(T)); - auto y_buffer = Buffer(context, CL_MEM_READ_WRITE, y_size*sizeof(T)); - a_buffer.WriteBuffer(queue, a_size*sizeof(T), a_source); - x_buffer.WriteBuffer(queue, x_size*sizeof(T), x_source); - y_buffer.WriteBuffer(queue, y_size*sizeof(T), y_source); - - // Runs the routine-specific code - client_routine(args, a_buffer, x_buffer, y_buffer, queue); - - // Makes the jump to the next step - ++s; - if (s >= args.num_steps) { break; } - args.m += args.step; - args.n += args.step; - args.a_ld += args.step; - } - - // Cleans-up and returns - if (args.compare_clblas) { clblasTeardown(); } -} - -// Compiles the above function -template void ClientAXY<float>(int, char **, Routine3<float>, const std::vector<std::string>&); -template void ClientAXY<double>(int, char **, Routine3<double>, const std::vector<std::string>&); -template void ClientAXY<float2>(int, char **, Routine3<float2>, const std::vector<std::string>&); -template void ClientAXY<double2>(int, char **, Routine3<double2>, const std::vector<std::string>&); - -// ================================================================================================= - -// This is the matrix-matrix variant of the set-up/tear-down client routine. -template <typename T> -void ClientAC(int argc, char *argv[], Routine2<T> client_routine, - const std::vector<std::string> &options) { - - // Function to determine how to find the default value of the leading dimension of matrix A - auto default_ld_a = [](const Arguments<T> args) { return args.k; }; - - // Simple command line argument parser with defaults - auto args = ParseArguments<T>(argc, argv, options, default_ld_a); - if (args.print_help) { return; } - - // Prints the header of the output table - PrintTableHeader(args.silent, options); - - // Initializes OpenCL and the libraries - auto platform = Platform(args.platform_id); - auto device = Device(platform, kDeviceType, args.device_id); - auto context = Context(device); - auto queue = CommandQueue(context, device); - if (args.compare_clblas) { clblasSetup(); } - - // Computes whether or not the matrices are transposed. Note that we assume a default of - // column-major and no-transpose. If one of them is different (but not both), then rotated - // is considered true. - auto a_rotated = (args.layout == Layout::kColMajor && args.a_transpose != Transpose::kNo) || - (args.layout == Layout::kRowMajor && args.a_transpose == Transpose::kNo); - - // Iterates over all "num_step" values jumping by "step" each time - auto s = size_t{0}; - while(true) { - - // Computes the data sizes - auto a_two = (a_rotated) ? args.n : args.k; - auto a_size = a_two * args.a_ld + args.a_offset; - auto c_size = args.n * args.c_ld + args.c_offset; - - // Populates input host matrices with random data - std::vector<T> a_source(a_size); - std::vector<T> c_source(c_size); - PopulateVector(a_source); - PopulateVector(c_source); - - // Creates the matrices on the device - auto a_buffer = Buffer(context, CL_MEM_READ_WRITE, a_size*sizeof(T)); - auto c_buffer = Buffer(context, CL_MEM_READ_WRITE, c_size*sizeof(T)); - a_buffer.WriteBuffer(queue, a_size*sizeof(T), a_source); - c_buffer.WriteBuffer(queue, c_size*sizeof(T), c_source); - - // Runs the routine-specific code - client_routine(args, a_buffer, c_buffer, queue); - - // Makes the jump to the next step - ++s; - if (s >= args.num_steps) { break; } - args.n += args.step; - args.k += args.step; - args.a_ld += args.step; - args.c_ld += args.step; - } - - // Cleans-up and returns - if (args.compare_clblas) { clblasTeardown(); } +Client<T>::Client(const Routine run_routine, const Routine run_reference, + const std::vector<std::string> &options, + const GetMetric get_flops, const GetMetric get_bytes): + run_routine_(run_routine), + run_reference_(run_reference), + options_(options), + get_flops_(get_flops), + get_bytes_(get_bytes) { } -// Compiles the above function -template void ClientAC<float>(int, char **, Routine2<float>, const std::vector<std::string>&); -template void ClientAC<double>(int, char **, Routine2<double>, const std::vector<std::string>&); -template void ClientAC<float2>(int, char **, Routine2<float2>, const std::vector<std::string>&); -template void ClientAC<double2>(int, char **, Routine2<double2>, const std::vector<std::string>&); - -// ================================================================================================= - -// This is the matrix-matrix-matrix variant of the set-up/tear-down client routine. -template <typename T> -void ClientABC(int argc, char *argv[], Routine3<T> client_routine, - const std::vector<std::string> &options, const bool symmetric) { - - // Function to determine how to find the default value of the leading dimension of matrix A - auto default_ld_a = [&symmetric](const Arguments<T> args) { return (symmetric) ? args.n : args.m; }; - - // Simple command line argument parser with defaults - auto args = ParseArguments<T>(argc, argv, options, default_ld_a); - if (args.print_help) { return; } - if (symmetric) { args.m = args.n; } - - // Prints the header of the output table - PrintTableHeader(args.silent, options); - - // Initializes OpenCL and the libraries - auto platform = Platform(args.platform_id); - auto device = Device(platform, kDeviceType, args.device_id); - auto context = Context(device); - auto queue = CommandQueue(context, device); - if (args.compare_clblas) { clblasSetup(); } - - // Computes whether or not the matrices are transposed. Note that we assume a default of - // column-major and no-transpose. If one of them is different (but not both), then rotated - // is considered true. - auto a_rotated = (args.layout == Layout::kColMajor && args.a_transpose != Transpose::kNo) || - (args.layout == Layout::kRowMajor && args.a_transpose == Transpose::kNo); - auto b_rotated = (args.layout == Layout::kColMajor && args.b_transpose != Transpose::kNo) || - (args.layout == Layout::kRowMajor && args.b_transpose == Transpose::kNo); - auto c_rotated = (args.layout == Layout::kRowMajor); - - // Iterates over all "num_step" values jumping by "step" each time - auto s = size_t{0}; - while(true) { - - // Computes the data sizes - auto a_two = (a_rotated) ? args.m : args.k; - auto b_two = (b_rotated) ? args.k : args.n; - auto c_two = (c_rotated) ? args.m : args.n; - auto a_size = a_two * args.a_ld + args.a_offset; - auto b_size = b_two * args.b_ld + args.b_offset; - auto c_size = c_two * args.c_ld + args.c_offset; - - // Populates input host matrices with random data - std::vector<T> a_source(a_size); - std::vector<T> b_source(b_size); - std::vector<T> c_source(c_size); - PopulateVector(a_source); - PopulateVector(b_source); - PopulateVector(c_source); - - // Creates the matrices on the device - auto a_buffer = Buffer(context, CL_MEM_READ_WRITE, a_size*sizeof(T)); - auto b_buffer = Buffer(context, CL_MEM_READ_WRITE, b_size*sizeof(T)); - auto c_buffer = Buffer(context, CL_MEM_READ_WRITE, c_size*sizeof(T)); - a_buffer.WriteBuffer(queue, a_size*sizeof(T), a_source); - b_buffer.WriteBuffer(queue, b_size*sizeof(T), b_source); - c_buffer.WriteBuffer(queue, c_size*sizeof(T), c_source); - - // Runs the routine-specific code - client_routine(args, a_buffer, b_buffer, c_buffer, queue); - - // Makes the jump to the next step - ++s; - if (s >= args.num_steps) { break; } - args.m += args.step; - args.n += args.step; - args.k += args.step; - args.a_ld += args.step; - args.b_ld += args.step; - args.c_ld += args.step; - } - - // Cleans-up and returns - if (args.compare_clblas) { clblasTeardown(); } -} - -// Compiles the above function -template void ClientABC<float>(int, char **, Routine3<float>, const std::vector<std::string>&, const bool); -template void ClientABC<double>(int, char **, Routine3<double>, const std::vector<std::string>&, const bool); -template void ClientABC<float2>(int, char **, Routine3<float2>, const std::vector<std::string>&, const bool); -template void ClientABC<double2>(int, char **, Routine3<double2>, const std::vector<std::string>&, const bool); - // ================================================================================================= // Parses all arguments available for the CLBlast client testers. Some arguments might not be // applicable, but are searched for anyway to be able to create one common argument parser. All // arguments have a default value in case they are not found. template <typename T> -Arguments<T> ParseArguments(int argc, char *argv[], const std::vector<std::string> &options, - const std::function<size_t(const Arguments<T>)> default_ld_a) { +Arguments<T> Client<T>::ParseArguments(int argc, char *argv[], const GetMetric default_a_ld, + const GetMetric default_b_ld, const GetMetric default_c_ld) { auto args = Arguments<T>{}; auto help = std::string{"Options given/available:\n"}; // These are the options which are not for every client: they are optional - for (auto &o: options) { + for (auto &o: options_) { // Data-sizes - if (o == kArgM) { args.m = args.k = GetArgument(argc, argv, help, kArgM, 512UL); } - if (o == kArgN) { args.n = GetArgument(argc, argv, help, kArgN, 512UL); } - if (o == kArgK) { args.k = GetArgument(argc, argv, help, kArgK, 512UL); } + if (o == kArgM) { args.m = GetArgument(argc, argv, help, kArgM, 512UL); } + if (o == kArgN) { args.n = GetArgument(argc, argv, help, kArgN, 512UL); } + if (o == kArgK) { args.k = GetArgument(argc, argv, help, kArgK, 512UL); } // Data-layouts if (o == kArgLayout) { args.layout = GetArgument(argc, argv, help, kArgLayout, Layout::kRowMajor); } @@ -353,9 +66,9 @@ Arguments<T> ParseArguments(int argc, char *argv[], const std::vector<std::strin if (o == kArgYOffset) { args.y_offset = GetArgument(argc, argv, help, kArgYOffset, size_t{0}); } // Matrix arguments - if (o == kArgALeadDim) { args.a_ld = GetArgument(argc, argv, help, kArgALeadDim, default_ld_a(args)); } - if (o == kArgBLeadDim) { args.b_ld = GetArgument(argc, argv, help, kArgBLeadDim, args.n); } - if (o == kArgCLeadDim) { args.c_ld = GetArgument(argc, argv, help, kArgCLeadDim, args.n); } + if (o == kArgALeadDim) { args.a_ld = GetArgument(argc, argv, help, kArgALeadDim, default_a_ld(args)); } + if (o == kArgBLeadDim) { args.b_ld = GetArgument(argc, argv, help, kArgBLeadDim, default_b_ld(args)); } + if (o == kArgCLeadDim) { args.c_ld = GetArgument(argc, argv, help, kArgCLeadDim, default_c_ld(args)); } if (o == kArgAOffset) { args.a_offset = GetArgument(argc, argv, help, kArgAOffset, size_t{0}); } if (o == kArgBOffset) { args.b_offset = GetArgument(argc, argv, help, kArgBOffset, size_t{0}); } if (o == kArgCOffset) { args.c_offset = GetArgument(argc, argv, help, kArgCOffset, size_t{0}); } @@ -387,16 +100,92 @@ Arguments<T> ParseArguments(int argc, char *argv[], const std::vector<std::strin // ================================================================================================= +// This is main performance tester +template <typename T> +void Client<T>::PerformanceTest(Arguments<T> &args, const SetMetric set_sizes) { + + // Prints the header of the output table + PrintTableHeader(args.silent, options_); + + // Initializes OpenCL and the libraries + auto platform = Platform(args.platform_id); + auto device = Device(platform, kDeviceType, args.device_id); + auto context = Context(device); + auto queue = CommandQueue(context, device); + if (args.compare_clblas) { clblasSetup(); } + + // Iterates over all "num_step" values jumping by "step" each time + auto s = size_t{0}; + while(true) { + + // Sets the buffer sizes (routine-specific) + set_sizes(args); + + // Populates input host matrices with random data + std::vector<T> x_source(args.x_size); + std::vector<T> y_source(args.y_size); + std::vector<T> a_source(args.a_size); + std::vector<T> b_source(args.b_size); + std::vector<T> c_source(args.c_size); + PopulateVector(x_source); + PopulateVector(y_source); + PopulateVector(a_source); + PopulateVector(b_source); + PopulateVector(c_source); + + // Creates the matrices on the device + auto x_vec = Buffer(context, CL_MEM_READ_WRITE, args.x_size*sizeof(T)); + auto y_vec = Buffer(context, CL_MEM_READ_WRITE, args.y_size*sizeof(T)); + auto a_mat = Buffer(context, CL_MEM_READ_WRITE, args.a_size*sizeof(T)); + auto b_mat = Buffer(context, CL_MEM_READ_WRITE, args.b_size*sizeof(T)); + auto c_mat = Buffer(context, CL_MEM_READ_WRITE, args.c_size*sizeof(T)); + x_vec.WriteBuffer(queue, args.x_size*sizeof(T), x_source); + y_vec.WriteBuffer(queue, args.y_size*sizeof(T), y_source); + a_mat.WriteBuffer(queue, args.a_size*sizeof(T), a_source); + b_mat.WriteBuffer(queue, args.b_size*sizeof(T), b_source); + c_mat.WriteBuffer(queue, args.c_size*sizeof(T), c_source); + auto buffers = Buffers{x_vec, y_vec, a_mat, b_mat, c_mat}; + + // Runs the routines and collects the timings + auto ms_clblast = TimedExecution(args.num_runs, args, buffers, queue, run_routine_, "CLBlast"); + auto ms_clblas = TimedExecution(args.num_runs, args, buffers, queue, run_reference_, "clBLAS"); + + // Prints the performance of both libraries + PrintTableRow(args, ms_clblast, ms_clblas); + + // Makes the jump to the next step + ++s; + if (s >= args.num_steps) { break; } + args.m += args.step; + args.n += args.step; + args.k += args.step; + args.a_ld += args.step; + args.b_ld += args.step; + args.c_ld += args.step; + } + + // Cleans-up and returns + if (args.compare_clblas) { clblasTeardown(); } +} + +// ================================================================================================= + // Creates a vector of timing results, filled with execution times of the 'main computation'. The // timing is performed using the milliseconds chrono functions. The function returns the minimum // value found in the vector of timing results. The return value is in milliseconds. -double TimedExecution(const size_t num_runs, std::function<void()> main_computation) { +template <typename T> +double Client<T>::TimedExecution(const size_t num_runs, const Arguments<T> &args, + const Buffers &buffers, CommandQueue &queue, + Routine run_blas, const std::string &library_name) { auto timings = std::vector<double>(num_runs); for (auto &timing: timings) { auto start_time = std::chrono::steady_clock::now(); // Executes the main computation - main_computation(); + auto status = run_blas(args, buffers, queue); + if (status != StatusCode::kSuccess) { + throw std::runtime_error(library_name+" error: "+ToString(static_cast<int>(status))); + } // Records and stores the end-time auto elapsed_time = std::chrono::steady_clock::now() - start_time; @@ -408,7 +197,8 @@ double TimedExecution(const size_t num_runs, std::function<void()> main_computat // ================================================================================================= // Prints the header of the performance table -void PrintTableHeader(const bool silent, const std::vector<std::string> &args) { +template <typename T> +void Client<T>::PrintTableHeader(const bool silent, const std::vector<std::string> &args) { if (!silent) { for (auto i=size_t{0}; i<args.size(); ++i) { fprintf(stdout, "%9s ", ""); } fprintf(stdout, " | <-- CLBlast --> | <-- clBLAS --> |\n"); @@ -419,29 +209,59 @@ void PrintTableHeader(const bool silent, const std::vector<std::string> &args) { } // Print a performance-result row -void PrintTableRow(const std::vector<size_t> &args_int, const std::vector<std::string> &args_string, - const bool no_abbrv, const double ms_clblast, const double ms_clblas, - const unsigned long long flops, const unsigned long long bytes) { +template <typename T> +void Client<T>::PrintTableRow(const Arguments<T>& args, const double ms_clblast, + const double ms_clblas) { + + // Creates a vector of relevant variables + auto integers = std::vector<size_t>{}; + for (auto &o: options_) { + if (o == kArgM) { integers.push_back(args.m); } + if (o == kArgN) { integers.push_back(args.n); } + else if (o == kArgK) { integers.push_back(args.k); } + else if (o == kArgLayout) { integers.push_back(static_cast<size_t>(args.layout)); } + else if (o == kArgSide) { integers.push_back(static_cast<size_t>(args.side)); } + else if (o == kArgTriangle) { integers.push_back(static_cast<size_t>(args.triangle)); } + else if (o == kArgATransp) { integers.push_back(static_cast<size_t>(args.a_transpose)); } + else if (o == kArgBTransp) { integers.push_back(static_cast<size_t>(args.b_transpose)); } + else if (o == kArgXInc) { integers.push_back(args.x_inc); } + else if (o == kArgYInc) { integers.push_back(args.y_inc); } + else if (o == kArgXOffset) { integers.push_back(args.x_offset); } + else if (o == kArgYOffset) { integers.push_back(args.y_offset); } + else if (o == kArgALeadDim) { integers.push_back(args.a_ld); } + else if (o == kArgBLeadDim) { integers.push_back(args.b_ld); } + else if (o == kArgCLeadDim) { integers.push_back(args.c_ld); } + else if (o == kArgAOffset) { integers.push_back(args.a_offset); } + else if (o == kArgBOffset) { integers.push_back(args.b_offset); } + else if (o == kArgCOffset) { integers.push_back(args.c_offset); } + } + auto strings = std::vector<std::string>{}; + for (auto &o: options_) { + if (o == kArgAlpha) { strings.push_back(ToString(args.alpha)); } + else if (o == kArgBeta) { strings.push_back(ToString(args.beta)); } + } // Computes the GFLOPS and GB/s metrics + auto flops = get_flops_(args); + auto bytes = get_bytes_(args); auto gflops_clblast = (ms_clblast != 0.0) ? (flops*1e-6)/ms_clblast : 0; auto gflops_clblas = (ms_clblas != 0.0) ? (flops*1e-6)/ms_clblas: 0; auto gbs_clblast = (ms_clblast != 0.0) ? (bytes*1e-6)/ms_clblast : 0; auto gbs_clblas = (ms_clblas != 0.0) ? (bytes*1e-6)/ms_clblas: 0; // Outputs the argument values - for (auto &argument: args_int) { - if (!no_abbrv && argument >= 1024*1024 && IsMultiple(argument, 1024*1024)) { + for (auto &argument: integers) { + if (!args.no_abbrv && argument >= 1024*1024 && IsMultiple(argument, 1024*1024)) { fprintf(stdout, "%8luM;", argument/(1024*1024)); } - else if (!no_abbrv && argument >= 1024 && IsMultiple(argument, 1024)) { + else if (!args.no_abbrv && argument >= 1024 && IsMultiple(argument, 1024)) { fprintf(stdout, "%8luK;", argument/1024); } else { fprintf(stdout, "%9lu;", argument); } } - for (auto &argument: args_string) { + for (auto &argument: strings) { fprintf(stdout, "%9s;", argument.c_str()); } @@ -452,4 +272,12 @@ void PrintTableRow(const std::vector<size_t> &args_int, const std::vector<std::s } // ================================================================================================= + +// Compiles the templated class +template class Client<float>; +template class Client<double>; +template class Client<float2>; +template class Client<double2>; + +// ================================================================================================= } // namespace clblast diff --git a/test/performance/client.h b/test/performance/client.h index 097ae048..f9f219d0 100644 --- a/test/performance/client.h +++ b/test/performance/client.h @@ -7,7 +7,12 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file provides common function declarations to be used with the test clients. +// This class implements the performance-test client. It is generic for all CLBlast routines by +// taking a number of routine-specific functions as arguments, such as how to compute buffer sizes +// or how to get the FLOPS count. +// +// This file also provides the common interface to the performance client (see the 'RunClient' +// function for details). // // ================================================================================================= @@ -26,64 +31,71 @@ namespace clblast { // ================================================================================================= -// Types of devices to consider -const cl_device_type kDeviceType = CL_DEVICE_TYPE_ALL; +// See comment at top of file for a description of the class +template <typename T> +class Client { + public: -// ================================================================================================= + // Types of devices to consider + const cl_device_type kDeviceType = CL_DEVICE_TYPE_ALL; -// Shorthand for a BLAS routine with 2 or 3 OpenCL buffers as argument -template <typename T> -using Routine2 = std::function<void(const Arguments<T>&, - const Buffer&, const Buffer&, - CommandQueue&)>; -template <typename T> -using Routine3 = std::function<void(const Arguments<T>&, - const Buffer&, const Buffer&, const Buffer&, - CommandQueue&)>; + // Shorthand for the routine-specific functions passed to the tester + using Routine = std::function<StatusCode(const Arguments<T>&, const Buffers&, CommandQueue&)>; + using SetMetric = std::function<void(Arguments<T>&)>; + using GetMetric = std::function<size_t(const Arguments<T>&)>; -// ================================================================================================= + // The constructor + Client(const Routine run_routine, const Routine run_reference, + const std::vector<std::string> &options, + const GetMetric get_flops, const GetMetric get_bytes); -// These are the main client functions, setting-up arguments, matrices, OpenCL buffers, etc. After -// set-up, they call the client routine, passed as argument to this function. -template <typename T> -void ClientXY(int argc, char *argv[], Routine2<T> client_routine, - const std::vector<std::string> &options); -template <typename T> -void ClientAXY(int argc, char *argv[], Routine3<T> client_routine, - const std::vector<std::string> &options); -template <typename T> -void ClientAC(int argc, char *argv[], Routine2<T> client_routine, - const std::vector<std::string> &options); -template <typename T> -void ClientABC(int argc, char *argv[], Routine3<T> client_routine, - const std::vector<std::string> &options, const bool symmetric); + // Parses all command-line arguments, filling in the arguments structure. If no command-line + // argument is given for a particular argument, it is filled in with a default value. + Arguments<T> ParseArguments(int argc, char *argv[], const GetMetric default_a_ld, + const GetMetric default_b_ld, const GetMetric default_c_ld); -// ================================================================================================= + // The main client function, setting-up arguments, matrices, OpenCL buffers, etc. After set-up, it + // calls the client routines. + void PerformanceTest(Arguments<T> &args, const SetMetric set_sizes); -// Parses all command-line arguments, filling in the arguments structure. If no command-line -// argument is given for a particular argument, it is filled in with a default value. -template <typename T> -Arguments<T> ParseArguments(int argc, char *argv[], const std::vector<std::string> &options, - const std::function<size_t(const Arguments<T>)> default_ld_a); + private: -// Retrieves only the precision command-line argument, since the above function is templated based -// on the precision -Precision GetPrecision(int argc, char *argv[]); + // Runs a function a given number of times and returns the execution time of the shortest instance + double TimedExecution(const size_t num_runs, const Arguments<T> &args, const Buffers &buffers, + CommandQueue &queue, Routine run_blas, const std::string &library_name); -// ================================================================================================= + // Prints the header of a performance-data table + void PrintTableHeader(const bool silent, const std::vector<std::string> &args); + + // Prints a row of performance data, including results of two libraries + void PrintTableRow(const Arguments<T>& args, const double ms_clblast, const double ms_clblas); -// Runs a function a given number of times and returns the execution time of the shortest instance -double TimedExecution(const size_t num_runs, std::function<void()> main_computation); + // The routine-specific functions passed to the tester + const Routine run_routine_; + const Routine run_reference_; + const std::vector<std::string> options_; + const GetMetric get_flops_; + const GetMetric get_bytes_; +}; // ================================================================================================= -// Prints the header of a performance-data table -void PrintTableHeader(const bool silent, const std::vector<std::string> &args); +// The interface to the performance client. This is a separate function in the header such that it +// is automatically compiled for each routine, templated by the parameter "C". +template <typename C, typename T> +void RunClient(int argc, char *argv[]) { + + // Creates a new client + auto client = Client<T>(C::RunRoutine, C::RunReference, C::GetOptions(), + C::GetFlops, C::GetBytes); + + // Simple command line argument parser with defaults + auto args = client.ParseArguments(argc, argv, C::DefaultLDA, C::DefaultLDB, C::DefaultLDC); + if (args.print_help) { return; } -// Prints a row of performance data, including results of two libraries -void PrintTableRow(const std::vector<size_t> &args_int, const std::vector<std::string> &args_string, - const bool abbreviations, const double ms_clblast, const double ms_clblas, - const unsigned long long flops, const unsigned long long bytes); + // Runs the client + client.PerformanceTest(args, C::SetSizes); +} // ================================================================================================= } // namespace clblast diff --git a/test/performance/routines/xaxpy.cc b/test/performance/routines/xaxpy.cc index 23d76099..3ced80ed 100644 --- a/test/performance/routines/xaxpy.cc +++ b/test/performance/routines/xaxpy.cc @@ -7,90 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xaxpy command-line interface tester. +// This file implements the Xaxpy command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xaxpy.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXaxpy(const Arguments<T> &args, - const Buffer &x_vec, const Buffer &y_vec, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &x_vec, &y_vec, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Axpy(args.n, args.alpha, - x_vec(), args.x_offset, args.x_inc, - y_vec(), args.y_offset, args.y_inc, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &x_vec, &y_vec, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXaxpy(args.n, args.alpha, - x_vec(), args.x_offset, args.x_inc, - y_vec(), args.y_offset, args.y_inc, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = 2 * args.n; - const auto bytes = (3 * args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.n, args.x_inc, args.y_inc, - args.x_offset, args.y_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXaxpy(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgN, kArgXInc, kArgYInc, - kArgXOffset, kArgYOffset, kArgAlpha}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientXY<float>(argc, argv, PerformanceXaxpy<float>, o); break; - case Precision::kDouble: ClientXY<double>(argc, argv, PerformanceXaxpy<double>, o); break; - case Precision::kComplexSingle: ClientXY<float2>(argc, argv, PerformanceXaxpy<float2>, o); break; - case Precision::kComplexDouble: ClientXY<double2>(argc, argv, PerformanceXaxpy<double2>, o); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXaxpy(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXaxpy<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXaxpy<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXaxpy<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXaxpy<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/performance/routines/xgemm.cc b/test/performance/routines/xgemm.cc index 76e398e0..36c74b9a 100644 --- a/test/performance/routines/xgemm.cc +++ b/test/performance/routines/xgemm.cc @@ -7,108 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xgemm command-line interface tester. +// This file implements the Xgemm command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xgemm.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXgemm(const Arguments<T> &args, - const Buffer &a_mat, const Buffer &b_mat, const Buffer &c_mat, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Gemm(args.layout, args.a_transpose, args.b_transpose, - args.m, args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXgemm(static_cast<clblasOrder>(args.layout), - static_cast<clblasTranspose>(args.a_transpose), - static_cast<clblasTranspose>(args.b_transpose), - args.m, args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = 2 * args.m * args.n * args.k; - const auto bytes = (args.m*args.k + args.k*args.n + 2*args.m*args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.m, args.n, args.k, - static_cast<size_t>(args.layout), - static_cast<size_t>(args.a_transpose), - static_cast<size_t>(args.b_transpose), - args.a_ld, args.b_ld, args.c_ld, - args.a_offset, args.b_offset, args.c_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha), - ToString(args.beta)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXgemm(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgM, kArgN, kArgK, kArgLayout, - kArgATransp, kArgBTransp, - kArgALeadDim, kArgBLeadDim, kArgCLeadDim, - kArgAOffset, kArgBOffset, kArgCOffset, - kArgAlpha, kArgBeta}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientABC<float>(argc, argv, PerformanceXgemm<float>, o, false); break; - case Precision::kDouble: ClientABC<double>(argc, argv, PerformanceXgemm<double>, o, false); break; - case Precision::kComplexSingle: ClientABC<float2>(argc, argv, PerformanceXgemm<float2>, o, false); break; - case Precision::kComplexDouble: ClientABC<double2>(argc, argv, PerformanceXgemm<double2>, o, false); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXgemm(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXgemm<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXgemm<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXgemm<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXgemm<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/performance/routines/xgemv.cc b/test/performance/routines/xgemv.cc index 43222396..183dd4a1 100644 --- a/test/performance/routines/xgemv.cc +++ b/test/performance/routines/xgemv.cc @@ -7,100 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xgemv command-line interface tester. +// This file implements the Xgemv command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xgemv.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXgemv(const Arguments<T> &args, - const Buffer &a_mat, const Buffer &x_vec, const Buffer &y_vec, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &a_mat, &x_vec, &y_vec, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Gemv(args.layout, args.a_transpose, args.m, args.n, args.alpha, - a_mat(), args.a_offset, args.a_ld, - x_vec(), args.x_offset, args.x_inc, args.beta, - y_vec(), args.y_offset, args.y_inc, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &a_mat, &x_vec, &y_vec, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXgemv(static_cast<clblasOrder>(args.layout), - static_cast<clblasTranspose>(args.a_transpose), - args.m, args.n, args.alpha, - a_mat(), args.a_offset, args.a_ld, - x_vec(), args.x_offset, args.x_inc, args.beta, - y_vec(), args.y_offset, args.y_inc, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = 2 * args.m * args.n; - const auto bytes = (args.m*args.n + 2*args.m + args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.m, args.n, - static_cast<size_t>(args.layout), - static_cast<size_t>(args.a_transpose), - args.a_ld, args.x_inc, args.y_inc, - args.a_offset, args.x_offset, args.y_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha), - ToString(args.beta)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXgemv(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgM, kArgN, kArgLayout, kArgATransp, - kArgALeadDim, kArgXInc, kArgYInc, - kArgAOffset, kArgXOffset, kArgYOffset, - kArgAlpha, kArgBeta}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientAXY<float>(argc, argv, PerformanceXgemv<float>, o); break; - case Precision::kDouble: ClientAXY<double>(argc, argv, PerformanceXgemv<double>, o); break; - case Precision::kComplexSingle: ClientAXY<float2>(argc, argv, PerformanceXgemv<float2>, o); break; - case Precision::kComplexDouble: ClientAXY<double2>(argc, argv, PerformanceXgemv<double2>, o); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXgemv(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXgemv<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXgemv<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXgemv<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXgemv<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/performance/routines/xsymm.cc b/test/performance/routines/xsymm.cc index d78d4eb8..0c7f5e1e 100644 --- a/test/performance/routines/xsymm.cc +++ b/test/performance/routines/xsymm.cc @@ -7,108 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xsymm command-line interface tester. +// This file implements the Xsymm command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xsymm.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXsymm(const Arguments<T> &args, - const Buffer &a_mat, const Buffer &b_mat, const Buffer &c_mat, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Symm(args.layout, args.side, args.triangle, - args.m, args.n, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXsymm(static_cast<clblasOrder>(args.layout), - static_cast<clblasSide>(args.side), - static_cast<clblasUplo>(args.triangle), - args.m, args.n, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = 2 * args.m * args.n * args.m; - const auto bytes = (args.m*args.m + args.m*args.n + 2*args.m*args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.m, args.n, - static_cast<size_t>(args.layout), - static_cast<size_t>(args.triangle), - static_cast<size_t>(args.side), - args.a_ld, args.b_ld, args.c_ld, - args.a_offset, args.b_offset, args.c_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha), - ToString(args.beta)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXsymm(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgM, kArgN, kArgLayout, - kArgTriangle, kArgSide, - kArgALeadDim, kArgBLeadDim, kArgCLeadDim, - kArgAOffset, kArgBOffset, kArgCOffset, - kArgAlpha, kArgBeta}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientABC<float>(argc, argv, PerformanceXsymm<float>, o, false); break; - case Precision::kDouble: ClientABC<double>(argc, argv, PerformanceXsymm<double>, o, false); break; - case Precision::kComplexSingle: ClientABC<float2>(argc, argv, PerformanceXsymm<float2>, o, false); break; - case Precision::kComplexDouble: ClientABC<double2>(argc, argv, PerformanceXsymm<double2>, o, false); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXsymm(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXsymm<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXsymm<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXsymm<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXsymm<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/performance/routines/xsyr2k.cc b/test/performance/routines/xsyr2k.cc index 8d9871d0..63b50df6 100644 --- a/test/performance/routines/xsyr2k.cc +++ b/test/performance/routines/xsyr2k.cc @@ -7,108 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xsyr2k command-line interface tester. +// This file implements the Xsyr2k command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xsyr2k.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXsyr2k(const Arguments<T> &args, - const Buffer &a_mat, const Buffer &b_mat, const Buffer &c_mat, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Syr2k(args.layout, args.triangle, args.a_transpose, - args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &a_mat, &b_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXsyr2k(static_cast<clblasOrder>(args.layout), - static_cast<clblasUplo>(args.triangle), - static_cast<clblasTranspose>(args.a_transpose), - args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - b_mat(), args.b_offset, args.b_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = 2 * args.n * args.n * args.k; - const auto bytes = (args.n*args.k + args.n*args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.n, args.k, - static_cast<size_t>(args.layout), - static_cast<size_t>(args.triangle), - static_cast<size_t>(args.a_transpose), - args.a_ld, args.b_ld, args.c_ld, - args.a_offset, args.b_offset, args.c_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha), - ToString(args.beta)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXsyr2k(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgN, kArgK, - kArgLayout, kArgTriangle, kArgATransp, - kArgALeadDim, kArgBLeadDim, kArgCLeadDim, - kArgAOffset, kArgBOffset, kArgCOffset, - kArgAlpha, kArgBeta}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientABC<float>(argc, argv, PerformanceXsyr2k<float>, o, true); break; - case Precision::kDouble: ClientABC<double>(argc, argv, PerformanceXsyr2k<double>, o, true); break; - case Precision::kComplexSingle: ClientABC<float2>(argc, argv, PerformanceXsyr2k<float2>, o, true); break; - case Precision::kComplexDouble: ClientABC<double2>(argc, argv, PerformanceXsyr2k<double2>, o, true); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXsyr2k(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXsyr2k<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXsyr2k<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXsyr2k<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXsyr2k<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/performance/routines/xsyrk.cc b/test/performance/routines/xsyrk.cc index f36d665a..9022d4f8 100644 --- a/test/performance/routines/xsyrk.cc +++ b/test/performance/routines/xsyrk.cc @@ -7,106 +7,29 @@ // Author(s): // Cedric Nugteren <www.cedricnugteren.nl> // -// This file implements the Xsyrk command-line interface tester. +// This file implements the Xsyrk command-line interface performance tester. // // ================================================================================================= -#include <string> -#include <vector> -#include <exception> - -#include "wrapper_clblas.h" #include "performance/client.h" +#include "routines/xsyrk.h" -namespace clblast { // ================================================================================================= -// The client, used for performance testing. It contains the function calls to CLBlast and to other -// libraries to compare against. -template <typename T> -void PerformanceXsyrk(const Arguments<T> &args, - const Buffer &a_mat, const Buffer &c_mat, - CommandQueue &queue) { - - // Creates the CLBlast lambda - auto clblast_lambda = [&args, &a_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = Syrk(args.layout, args.triangle, args.a_transpose, - args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - &queue_plain, &event); - clWaitForEvents(1, &event); - if (status != StatusCode::kSuccess) { - throw std::runtime_error("CLBlast error: "+ToString(static_cast<int>(status))); - } - }; - - // Creates the clBLAS lambda (for comparison) - auto clblas_lambda = [&args, &a_mat, &c_mat, &queue]() { - auto queue_plain = queue(); - auto event = cl_event{}; - auto status = clblasXsyrk(static_cast<clblasOrder>(args.layout), - static_cast<clblasUplo>(args.triangle), - static_cast<clblasTranspose>(args.a_transpose), - args.n, args.k, - args.alpha, - a_mat(), args.a_offset, args.a_ld, - args.beta, - c_mat(), args.c_offset, args.c_ld, - 1, &queue_plain, 0, nullptr, &event); - clWaitForEvents(1, &event); - if (status != CL_SUCCESS) { - throw std::runtime_error("clBLAS error: "+ToString(static_cast<int>(status))); - } - }; - - // Runs the routines and collect the timings - auto ms_clblast = TimedExecution(args.num_runs, clblast_lambda); - auto ms_clblas = TimedExecution(args.num_runs, clblas_lambda); - - // Prints the performance of both libraries - const auto flops = args.n * args.n * args.k; - const auto bytes = (args.n*args.k + args.n*args.n) * sizeof(T); - const auto output_ints = std::vector<size_t>{args.n, args.k, - static_cast<size_t>(args.layout), - static_cast<size_t>(args.triangle), - static_cast<size_t>(args.a_transpose), - args.a_ld, args.c_ld, - args.a_offset, args.c_offset}; - const auto output_strings = std::vector<std::string>{ToString(args.alpha), - ToString(args.beta)}; - PrintTableRow(output_ints, output_strings, args.no_abbrv, - ms_clblast, ms_clblas, flops, bytes); -} - -// ================================================================================================= - -// Main function which calls the common client code with the routine-specific function as argument. -void ClientXsyrk(int argc, char *argv[]) { - const auto o = std::vector<std::string>{kArgN, kArgK, - kArgLayout, kArgTriangle, kArgATransp, - kArgALeadDim, kArgCLeadDim, - kArgAOffset, kArgCOffset, - kArgAlpha, kArgBeta}; - switch(GetPrecision(argc, argv)) { - case Precision::kHalf: throw std::runtime_error("Unsupported precision mode"); - case Precision::kSingle: ClientAC<float>(argc, argv, PerformanceXsyrk<float>, o); break; - case Precision::kDouble: ClientAC<double>(argc, argv, PerformanceXsyrk<double>, o); break; - case Precision::kComplexSingle: ClientAC<float2>(argc, argv, PerformanceXsyrk<float2>, o); break; - case Precision::kComplexDouble: ClientAC<double2>(argc, argv, PerformanceXsyrk<double2>, o); break; - } -} - -// ================================================================================================= -} // namespace clblast - // Main function (not within the clblast namespace) int main(int argc, char *argv[]) { - clblast::ClientXsyrk(argc, argv); + switch(clblast::GetPrecision(argc, argv)) { + case clblast::Precision::kHalf: + throw std::runtime_error("Unsupported precision mode"); + case clblast::Precision::kSingle: + clblast::RunClient<clblast::TestXsyrk<float>, float>(argc, argv); break; + case clblast::Precision::kDouble: + clblast::RunClient<clblast::TestXsyrk<double>, double>(argc, argv); break; + case clblast::Precision::kComplexSingle: + clblast::RunClient<clblast::TestXsyrk<clblast::float2>, clblast::float2>(argc, argv); break; + case clblast::Precision::kComplexDouble: + clblast::RunClient<clblast::TestXsyrk<clblast::double2>, clblast::double2>(argc, argv); break; + } return 0; } diff --git a/test/routines/xaxpy.h b/test/routines/xaxpy.h index b61dd3b5..6ce5d7e2 100644 --- a/test/routines/xaxpy.h +++ b/test/routines/xaxpy.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -45,6 +45,17 @@ class TestXaxpy { return args.n * args.y_inc + args.y_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.x_size = GetSizeX(args); + args.y_size = GetSizeY(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t DefaultLDB(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t DefaultLDC(const Arguments<T> &) { return 1; } // N/A for this routine + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -81,10 +92,18 @@ class TestXaxpy { // Describes how to compute the indices of the result buffer static size_t ResultID1(const Arguments<T> &args) { return args.n; } - static size_t ResultID2(const Arguments<T> &args) { return 1; } // N/A for this routine - static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t id2) { + static size_t ResultID2(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t) { return id1*args.y_inc + args.y_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return 2 * args.n; + } + static size_t GetBytes(const Arguments<T> &args) { + return (3 * args.n) * sizeof(T); + } }; // ================================================================================================= diff --git a/test/routines/xgemm.h b/test/routines/xgemm.h index c93fa774..86a304d1 100644 --- a/test/routines/xgemm.h +++ b/test/routines/xgemm.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -57,6 +57,18 @@ class TestXgemm { return c_two * args.c_ld + args.c_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.a_size = GetSizeA(args); + args.b_size = GetSizeB(args); + args.c_size = GetSizeC(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &args) { return args.k; } + static size_t DefaultLDB(const Arguments<T> &args) { return args.n; } + static size_t DefaultLDC(const Arguments<T> &args) { return args.n; } + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -105,6 +117,14 @@ class TestXgemm { id1*args.c_ld + id2 + args.c_offset: id2*args.c_ld + id1 + args.c_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return 2 * args.m * args.n * args.m; + } + static size_t GetBytes(const Arguments<T> &args) { + return (args.m*args.m + args.m*args.n + 2*args.m*args.n) * sizeof(T); + } }; // ================================================================================================= diff --git a/test/routines/xgemv.h b/test/routines/xgemv.h index ada3d6f4..73f7d76e 100644 --- a/test/routines/xgemv.h +++ b/test/routines/xgemv.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -55,6 +55,18 @@ class TestXgemv { return m_real * args.y_inc + args.y_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.a_size = GetSizeA(args); + args.x_size = GetSizeX(args); + args.y_size = GetSizeY(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &args) { return args.n; } + static size_t DefaultLDB(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t DefaultLDC(const Arguments<T> &) { return 1; } // N/A for this routine + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -99,10 +111,18 @@ class TestXgemv { auto a_transposed = (args.a_transpose != Transpose::kNo); return (a_transposed) ? args.n : args.m; } - static size_t ResultID2(const Arguments<T> &args) { return 1; } // N/A for this routine - static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t id2) { + static size_t ResultID2(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t) { return id1*args.y_inc + args.y_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return 2 * args.m * args.n; + } + static size_t GetBytes(const Arguments<T> &args) { + return (args.m*args.n + 2*args.m + args.n) * sizeof(T); + } }; // ================================================================================================= diff --git a/test/routines/xsymm.h b/test/routines/xsymm.h index 93b4d30c..10476349 100644 --- a/test/routines/xsymm.h +++ b/test/routines/xsymm.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -57,6 +57,18 @@ class TestXsymm { return c_two * args.c_ld + args.c_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.a_size = GetSizeA(args); + args.b_size = GetSizeB(args); + args.c_size = GetSizeC(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &args) { return args.m; } + static size_t DefaultLDB(const Arguments<T> &args) { return args.n; } + static size_t DefaultLDC(const Arguments<T> &args) { return args.n; } + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -105,6 +117,14 @@ class TestXsymm { id1*args.c_ld + id2 + args.c_offset: id2*args.c_ld + id1 + args.c_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return 2 * args.m * args.n * args.m; + } + static size_t GetBytes(const Arguments<T> &args) { + return (args.m*args.m + args.m*args.n + 2*args.m*args.n) * sizeof(T); + } }; // ================================================================================================= diff --git a/test/routines/xsyr2k.h b/test/routines/xsyr2k.h index 4f2def74..f3b1b542 100644 --- a/test/routines/xsyr2k.h +++ b/test/routines/xsyr2k.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -48,13 +48,25 @@ class TestXsyr2k { static size_t GetSizeB(const Arguments<T> &args) { auto b_rotated = (args.layout == Layout::kColMajor && args.b_transpose != Transpose::kNo) || (args.layout == Layout::kRowMajor && args.b_transpose == Transpose::kNo); - auto b_two = (b_rotated) ? args.k : args.n; + auto b_two = (b_rotated) ? args.n : args.k; return b_two * args.b_ld + args.b_offset; } static size_t GetSizeC(const Arguments<T> &args) { return args.n * args.c_ld + args.c_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.a_size = GetSizeA(args); + args.b_size = GetSizeB(args); + args.c_size = GetSizeC(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &args) { return args.k; } + static size_t DefaultLDB(const Arguments<T> &args) { return args.k; } + static size_t DefaultLDC(const Arguments<T> &args) { return args.n; } + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -101,6 +113,14 @@ class TestXsyr2k { static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t id2) { return id1*args.c_ld + id2 + args.c_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return 2 * args.n * args.n * args.k; + } + static size_t GetBytes(const Arguments<T> &args) { + return (args.n*args.k + args.n*args.n) * sizeof(T); + } }; // ================================================================================================= diff --git a/test/routines/xsyrk.h b/test/routines/xsyrk.h index 19a77749..2ec9fb65 100644 --- a/test/routines/xsyrk.h +++ b/test/routines/xsyrk.h @@ -1,6 +1,6 @@ // ================================================================================================= -// This file is part of the CLBlast project. The project is licensed under the MIT license. This +// 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 tab-size of two spaces and a max- // width of 100 characters per line. // @@ -49,6 +49,17 @@ class TestXsyrk { return args.n * args.c_ld + args.c_offset; } + // Describes how to set the sizes of all the buffers + static void SetSizes(Arguments<T> &args) { + args.a_size = GetSizeA(args); + args.c_size = GetSizeC(args); + } + + // Describes what the default values of the leading dimensions of the matrices are + static size_t DefaultLDA(const Arguments<T> &args) { return args.k; } + static size_t DefaultLDB(const Arguments<T> &) { return 1; } // N/A for this routine + static size_t DefaultLDC(const Arguments<T> &args) { return args.n; } + // Describes how to run the CLBlast routine static StatusCode RunRoutine(const Arguments<T> &args, const Buffers &buffers, CommandQueue &queue) { @@ -93,6 +104,14 @@ class TestXsyrk { static size_t GetResultIndex(const Arguments<T> &args, const size_t id1, const size_t id2) { return id1*args.c_ld + id2 + args.c_offset; } + + // Describes how to compute performance metrics + static size_t GetFlops(const Arguments<T> &args) { + return args.n * args.n * args.k; + } + static size_t GetBytes(const Arguments<T> &args) { + return (args.n*args.k + args.n*args.n) * sizeof(T); + } }; // ================================================================================================= |