Merge pull request #70 from CNugteren/development

Update to version 0.8.0

59 files changed, 225 insertions, 1015 deletions

diff --git a/test/performance/client.cc b/test/performance/client.cpp
index 9aaf1e4e..d0068f8b 100644
--- a/test/performance/client.cc
+++ b/test/performance/client.cpp
@@ -11,7 +11,7 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
+#include "test/performance/client.hpp"
 
 #include <string>
 #include <vector>
@@ -42,8 +42,10 @@ Client<T,U>::Client(const Routine run_routine,
 // 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, typename U>
-Arguments<U> Client<T,U>::ParseArguments(int argc, char *argv[], const GetMetric default_a_ld,
-                                         const GetMetric default_b_ld, const GetMetric default_c_ld) {
+Arguments<U> Client<T,U>::ParseArguments(int argc, char *argv[], const size_t level,
+                                         const GetMetric default_a_ld,
+                                         const GetMetric default_b_ld,
+                                         const GetMetric default_c_ld) {
   auto args = Arguments<U>{};
   auto help = std::string{"\n* Options given/available:\n"};
 
@@ -116,6 +118,28 @@ Arguments<U> Client<T,U>::ParseArguments(int argc, char *argv[], const GetMetric
   // which is thus always displayed (unless silence is specified).
   if (!args.silent) { fprintf(stdout, "%s\n", help.c_str()); }
 
+  // Comparison against a non-BLAS routine is not supported
+  if (level == 4) { // level-4 == level-X
+    if (args.compare_clblas != 0 || args.compare_cblas != 0) {
+      if (!args.silent) {
+        fprintf(stdout, "* Disabling clBLAS and CPU BLAS comparisons for this non-BLAS routine\n\n");
+      }
+    }
+    args.compare_clblas = 0;
+    args.compare_cblas = 0;
+  }
+
+  // Comparison against clBLAS or a CPU BLAS library is not supported in case of half-precision
+  if (args.precision == Precision::kHalf) {
+    if (args.compare_clblas != 0 || args.compare_cblas != 0) {
+      if (!args.silent) {
+        fprintf(stdout, "* Disabling clBLAS and CPU BLAS comparisons for half-precision\n\n");
+      }
+    }
+    args.compare_clblas = 0;
+    args.compare_cblas = 0;
+  }
+
   // Returns the arguments
   return args;
 }
@@ -339,6 +363,7 @@ void Client<T,U>::PrintTableRow(const Arguments<U>& args,
 // =================================================================================================
 
 // Compiles the templated class
+template class Client<half,half>;
 template class Client<float,float>;
 template class Client<double,double>;
 template class Client<float2,float2>;
diff --git a/test/performance/client.h b/test/performance/client.hpp
index 8d0597d7..5ff2aec7 100644
--- a/test/performance/client.h
+++ b/test/performance/client.hpp
@@ -31,7 +31,7 @@
 #endif
 #include "clblast.h"
 
-#include "internal/utilities.h"
+#include "utilities.hpp"
 
 namespace clblast {
 // =================================================================================================
@@ -53,8 +53,10 @@ class Client {
 
   // 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<U> ParseArguments(int argc, char *argv[], const GetMetric default_a_ld,
-                              const GetMetric default_b_ld, const GetMetric default_c_ld);
+  Arguments<U> ParseArguments(int argc, char *argv[], const size_t level,
+                              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.
@@ -97,14 +99,14 @@ void RunClient(int argc, char *argv[]) {
 
   // Sets the reference to test against
   #ifdef CLBLAST_REF_CLBLAS
-    const auto reference1 = C::RunReference1; // clBLAS when available
+    auto reference1 = C::RunReference1; // clBLAS when available
   #else
-    const auto reference1 = ReferenceNotAvailable<T,U>;
+    auto reference1 = ReferenceNotAvailable<T,U>;
   #endif
   #ifdef CLBLAST_REF_CBLAS
-    const auto reference2 = C::RunReference2; // CBLAS when available
+    auto reference2 = C::RunReference2; // CBLAS when available
   #else
-    const auto reference2 = ReferenceNotAvailable<T,U>;
+    auto reference2 = ReferenceNotAvailable<T,U>;
   #endif
 
   // Creates a new client
@@ -112,7 +114,8 @@ void RunClient(int argc, char *argv[]) {
                             C::GetFlops, C::GetBytes);
 
   // Simple command line argument parser with defaults
-  auto args = client.ParseArguments(argc, argv, C::DefaultLDA, C::DefaultLDB, C::DefaultLDC);
+  auto args = client.ParseArguments(argc, argv, C::BLASLevel(),
+                                    C::DefaultLDA, C::DefaultLDB, C::DefaultLDC);
   if (args.print_help) { return; }
 
   // Runs the client
diff --git a/test/performance/graphs/common.r b/test/performance/graphs/common.r
deleted file mode 100644
index cd68cf26..00000000
--- a/test/performance/graphs/common.r
+++ /dev/null
@@ -1,199 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the common performance scripts, such as creating a graph.
-#
-# ==================================================================================================
-
-# Colours
-black     = "#000000"
-grey      = "#888888"
-purplish  = "#550077" # [ 85,  0,119] lumi=26
-blueish   = "#4765b1" # [ 71,101,177] lumi=100
-redish    = "#d67568" # [214,117,104] lumi=136
-greenish  = "#9bd4ca" # [155,212,202] lumi=199
-colourset = c(blueish, redish, greenish, purplish)
-
-# Sets the graph markers (circles, triangles, etc.)
-pchs = c(15, 18, 17, 12)
-
-# Other constants
-kilo = 1024
-mega = 1024*1024
-
-# R options
-options("width"=170)
-
-# ==================================================================================================
-
-# Constants
-num_runs <- 4
-devices <- c("-platform","-device")
-options_string <- "-q -no_abbrv -cblas 0"
-library_names <- c("CLBlast", "clBLAS")
-
-# Command-line arguments
-command_line <- commandArgs(trailingOnly=TRUE)
-if (length(command_line) != 2) {
-  print("Usage for device Z on platform Y: Rscript xxxxx.r Y Z")
-  quit()
-}
-platform_id <- command_line[1]
-device_id <- command_line[2]
-
-# Selects the device
-devices_values <- c(platform_id, device_id)
-devices_string <- paste(devices, devices_values, collapse=" ")
-
-# ==================================================================================================
-
-# The main function
-main <- function(routine_name, precision, test_names, test_values,
-                test_xlabels, test_xaxis, metric_gflops) {
-
-  # Names
-  display_name <- toupper(routine_name)
-  if (precision == 16) { display_name <- gsub("^X","H",display_name); }
-  if (precision == 32) { display_name <- gsub("^X","S",display_name); }
-  if (precision == 64) { display_name <- gsub("^X","D",display_name); }
-  if (precision == 3232) { display_name <- gsub("^X","C",display_name); }
-  if (precision == 6464) { display_name <- gsub("^X","Z",display_name); }
-  executable <- paste("./clblast_client_", routine_name, sep="")
-
-  # Configures the outputfile
-  pdf(paste(display_name, ".pdf", sep=""), height=8, width=13)
-  par(mfrow=c(2, 3))
-  par(oma=c(0, 0, 0, 0))
-  par(mar=c(4.6, 4.4, 1.5, 0)) # bottom, left, top, right [c(5.1, 4.1, 4.1, 2.1)]
-  par(mgp=c(2.8, 0.6, 0)) # location of xlab/ylab, tick-mark labels, tick marks [c(3, 1, 0)]
-
-  # Loops over the test-cases
-  for (test_id in 1:length(test_names)) {
-    params_values <- test_values[[test_id]]
-
-    # Loops over the commands within a single list (within a case)
-    for (command_id in 1:length(params_values)) {
-
-      # Runs the client and captures the result
-      params_string <- paste(parameters, params_values[[command_id]], collapse=" ")
-      arguments <- paste(devices_string, params_string, options_string, sep=" ")
-      print(paste("Running", executable, arguments, sep=" "))
-      raw_result_string <- system2(command=executable, args=arguments, stdout=TRUE)
-
-      # Filter the string: only lines containing a ";" can be valid lines
-      result_string <- c()
-      for (line in raw_result_string) {
-        if (grepl(";",line)) {
-          result_string <-
-           c(result_string, line)
-        }
-      }
-
-      # Reads the result into a dataframe
-      command_db <- read.csv(text=result_string, sep=";")
-
-      # Append the results to the final dataframe
-      if (command_id == 1) {
-        db <- command_db
-      } else {
-        db <- rbind(db, command_db)
-      }
-    }
-    print(db)
-
-    # Sets the values on the x-axis and their labels (test dependent)
-    if (is.character(test_xaxis[[test_id]][[1]])) {
-      xdata <- db[,test_xaxis[[test_id]][[1]]]
-      xtics <- xdata
-      log_scale <- test_xaxis[[test_id]][[2]]
-    }
-    else {
-      xdata <- test_xaxis[[test_id]][[1]]
-      xtics <- test_xaxis[[test_id]][[2]]
-      log_scale <- ""
-    }
-
-    # Plots the graph with GFLOPS on the Y-axis
-    if (metric_gflops) {
-      plot_graph(xdata=xdata, ydata=list(db$GFLOPS_1, db$GFLOPS_2), log_setting=log_scale,
-                 xmin=min(xdata), xmax=max(xdata),
-                 ymin=0, ymax=max(max(db$GFLOPS_1),max(db$GFLOPS_2)),
-                 xtics=xtics,
-                 xlabel=test_xlabels[[test_id]], ylabel="GFLOPS (higher is better)",
-                 graph_title=paste(display_name, test_names[[test_id]], sep=" "),
-                 multiple=50, experiment_names=library_names)
-    # Plots the graph with GB/s on the Y-axis
-    } else {
-      plot_graph(xdata=xdata, ydata=list(db$GBs_1, db$GBs_2), log_setting=log_scale,
-                 xmin=min(xdata), xmax=max(xdata),
-                 ymin=0, ymax=max(max(db$GBs_1),max(db$GBs_2)),
-                 xtics=xtics,
-                 xlabel=test_xlabels[[test_id]], ylabel="GB/s (higher is better)",
-                 graph_title=paste(display_name, test_names[[test_id]], sep=" "),
-                 multiple=10, experiment_names=library_names)
-    }
-  }
-}
-
-# ==================================================================================================
-
-# Plots data
-plot_graph <- function(xdata, ydata, log_setting,
-                       xmin, xmax, ymin, ymax,
-                       xtics, xlabel, ylabel,
-                       graph_title,
-                       multiple, experiment_names) {
-
-  # Update the ymax to the next multiple of something
-  ymax <- multiple*ceiling(ymax/multiple)
-
-  # Add kilo or mega to the x-labels
-  for (i in 1:length(xtics)) {
-    if (!is.na(as.numeric(xtics[i]))) {
-      if (as.numeric(xtics[i])%%mega == 0) {
-        xtics[i] <- paste(as.character(as.numeric(xtics[i])/mega), "M", sep="")
-      } else if (as.numeric(xtics[i])%%kilo == 0) {
-        xtics[i] <- paste(as.character(as.numeric(xtics[i])/kilo), "K", sep="")
-      }
-    }
-  }
-
-  # Creates an initial graph with axis but without data
-  par(new=F)
-  plot(x=xmin:xmax, y=rep(1, length(xmin:xmax)), log=log_setting,
-       main="", xlab="", ylab="",
-       ylim=c(ymin, ymax), xlim=c(xmin, xmax), axes=F, "n")
-  axis(side=2, las=2)
-  axis(side=1, at=xdata, labels=xtics, las=2)
-  title(xlab=xlabel, line=-1)
-  title(ylab=ylabel, line=2)
-  title(graph_title, line=-2)
-  par(new=T)
-
-  # Loops over all experiments
-  num_experiments <- length(ydata)
-  for (id in 1:num_experiments) {
-
-    # Plots the data for this experiment
-    plot(x=xdata, y=ydata[[id]], log=log_setting,
-         col=colourset[id], pch=pchs[id], lty=1, lwd=1, cex=1,
-         xlab="", ylab="", ylim=c(ymin, ymax), xlim=c(xmin, xmax),
-         axes=F, "b", xpd=T)
-    par(new=T)
-  }
-
-  # Add a legend
-  legend("bottomright", experiment_names,
-         lwd=1, ncol=1, col=colourset, pch=pchs, lty=1, cex=1,
-         bty="n", xpd=T)
-
-  # Done
-  par(new=F)
-}
-
-# ==================================================================================================
diff --git a/test/performance/graphs/xaxpy.r b/test/performance/graphs/xaxpy.r
deleted file mode 100644
index 187590aa..00000000
--- a/test/performance/graphs/xaxpy.r
+++ /dev/null
@@ -1,96 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xaxpy routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xaxpy"
-parameters <- c("-n","-incx","-incy",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 256K",
-  "multiples of 256K (+1)",
-  "around n=1M",
-  "around n=16M",
-  "strides (n=8M)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c(256*kilo, 1, 1, 16, 256*kilo, num_runs, precision)),
-  list(c(256*kilo+1, 1, 1, 16, 256*kilo, num_runs, precision)),
-  list(c(1*mega, 1, 1, 16, 1, num_runs, precision)),
-  list(c(16*mega, 1, 1, 16, 1, num_runs, precision)),
-  list(
-    c(8*mega, 1, 1, 1, 0, num_runs, precision),
-    c(8*mega, 2, 1, 1, 0, num_runs, precision),
-    c(8*mega, 4, 1, 1, 0, num_runs, precision),
-    c(8*mega, 8, 1, 1, 0, num_runs, precision),
-    c(8*mega, 1, 2, 1, 0, num_runs, precision),
-    c(8*mega, 1, 4, 1, 0, num_runs, precision),
-    c(8*mega, 1, 8, 1, 0, num_runs, precision),
-    c(8*mega, 2, 2, 1, 0, num_runs, precision),
-    c(8*mega, 4, 4, 1, 0, num_runs, precision),
-    c(8*mega, 8, 8, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(32*kilo, 1, 1, 1, 0, num_runs, precision),
-    c(64*kilo, 1, 1, 1, 0, num_runs, precision),
-    c(128*kilo, 1, 1, 1, 0, num_runs, precision),
-    c(256*kilo, 1, 1, 1, 0, num_runs, precision),
-    c(512*kilo, 1, 1, 1, 0, num_runs, precision),
-    c(1*mega, 1, 1, 1, 0, num_runs, precision),
-    c(2*mega, 1, 1, 1, 0, num_runs, precision),
-    c(4*mega, 1, 1, 1, 0, num_runs, precision),
-    c(8*mega, 1, 1, 1, 0, num_runs, precision),
-    c(16*mega, 1, 1, 1, 0, num_runs, precision),
-    c(32*mega, 1, 1, 1, 0, num_runs, precision),
-    c(64*mega, 1, 1, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "increments/strides for x and y",
-  "vector sizes (n)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  list(1:10, c("x1y1", "x2y1", "x4y1", "x8y1", "x1y2", "x1y4", "x1y8", "x2y2", "x4y4", "x8y8")),
-  c("n", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=FALSE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xgemm.r b/test/performance/graphs/xgemm.r
deleted file mode 100755
index e758f460..00000000
--- a/test/performance/graphs/xgemm.r
+++ /dev/null
@@ -1,94 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xgemm routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xgemm"
-parameters <- c("-m","-n","-k","-layout","-transA","-transB",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 128",
-  "multiples of 128 (+1)",
-  "around m=n=k=512",
-  "around m=n=k=2048",
-  "layouts and transposing (m=n=k=1024)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c( 128,  128,  128, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 129,  129,  129, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 512,  512,  512, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(c(2048, 2048, 2048, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(
-    c(1024, 1024, 1024, 101, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 101, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 101, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 101, 112, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 102, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 102, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 102, 112, 112, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(   8,    8,    8, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  16,   16,   16, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  32,   32,   32, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  64,   64,   64, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 128,  128,  128, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 256,  256,  256, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 512,  512,  512, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(2048, 2048, 2048, 102, 111, 111, 1, 0, num_runs, precision),
-    c(4096, 4096, 4096, 102, 111, 111, 1, 0, num_runs, precision),
-    c(8192, 8192, 8192, 102, 111, 111, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "matrix sizes (m=n=k)",
-  "matrix sizes (m=n=k)",
-  "matrix sizes (m=n=k)",
-  "matrix sizes (m=n=k)",
-  "layout (row/col), transA (n/y), transB (n/y)",
-  "matrix sizes (m=n=k)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  list(1:8, c("row,n,n", "row,n,y", "row,y,n", "row,y,y",
-              "col,n,n", "col,n,y", "col,y,n", "col,y,y")),
-  c("m", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=TRUE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xgemv.r b/test/performance/graphs/xgemv.r
deleted file mode 100644
index 9a8040f7..00000000
--- a/test/performance/graphs/xgemv.r
+++ /dev/null
@@ -1,83 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xgemv routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xgemv"
-parameters <- c("-n","-m","-incx","-incy","-layout",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 256",
-  "multiples of 256 (+1)",
-  "around n=m=2K",
-  "multiples of 256 [rotated]",
-  "multiples of 256 (+1) [rotated]",
-  "strides (n=2K)"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c(256, 256, 1, 1, 102, 16, 256, num_runs, precision)),
-  list(c(256+1, 256+1, 1, 1, 102, 16, 256, num_runs, precision)),
-  list(c(2*kilo, 2*kilo, 1, 1, 102, 16, 1, num_runs, precision)),
-  list(c(256, 256, 1, 1, 101, 16, 256, num_runs, precision)),
-  list(c(256+1, 256+1, 1, 1, 101, 16, 256, num_runs, precision)),
-  list(
-    c(2*kilo, 2*kilo, 1, 1, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 2, 1, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 4, 1, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 8, 1, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 1, 2, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 1, 4, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 1, 8, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 2, 2, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 4, 4, 102, 1, 0, num_runs, precision),
-    c(2*kilo, 2*kilo, 8, 8, 102, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "vector sizes (n)",
-  "increments/strides for x and y"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  list(1:10, c("x1y1", "x2y1", "x4y1", "x8y1", "x1y2", "x1y4", "x1y8", "x2y2", "x4y4", "x8y8"))
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=FALSE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xsymm.r b/test/performance/graphs/xsymm.r
deleted file mode 100644
index a65bb16f..00000000
--- a/test/performance/graphs/xsymm.r
+++ /dev/null
@@ -1,94 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xsymm routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xsymm"
-parameters <- c("-m","-n","-layout","-side","-triangle",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 128",
-  "multiples of 128 (+1)",
-  "around m=n=512",
-  "around m=n=2048",
-  "layouts and side/triangle (m=n=1024)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c( 128,  128, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 129,  129, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 512,  512, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(c(2048, 2048, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(
-    c(1024, 1024, 101, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 112, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(   8,    8, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  16,   16, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  32,   32, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  64,   64, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 128,  128, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 256,  256, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 512,  512, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(2048, 2048, 102, 111, 111, 1, 0, num_runs, precision),
-    c(4096, 4096, 102, 111, 111, 1, 0, num_runs, precision),
-    c(8192, 8192, 102, 111, 111, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "layout (row/col), side (l/r), triangle (up/lo)",
-  "matrix sizes (m=n)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  list(1:8, c("row,l,up", "row,r,up", "row,l,lo", "row,r,lo",
-              "col,l,up", "col,r,up", "col,l,lo", "col,r,lo")),
-  c("m", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=TRUE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xsyr2k.r b/test/performance/graphs/xsyr2k.r
deleted file mode 100644
index 4b2dd4a0..00000000
--- a/test/performance/graphs/xsyr2k.r
+++ /dev/null
@@ -1,94 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xsyr2k routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xsyr2k"
-parameters <- c("-n","-k","-layout","-triangle","-transA",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 128",
-  "multiples of 128 (+1)",
-  "around n=k=512",
-  "around n=k=1536",
-  "layouts and transposing (n=k=1024)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c( 128,  128, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 129,  129, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 512,  512, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(c(1536, 1536, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(
-    c(1024, 1024, 101, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 112, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(   8,    8, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  16,   16, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  32,   32, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  64,   64, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 128,  128, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 256,  256, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 512,  512, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(2048, 2048, 102, 111, 111, 1, 0, num_runs, precision),
-    c(4096, 4096, 102, 111, 111, 1, 0, num_runs, precision),
-    c(8192, 8192, 102, 111, 111, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "layout (row/col), triangle (u/l), transA (n/y)",
-  "matrix sizes (n=k)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  list(1:8, c("row,u,n", "row,u,y", "row,l,n", "row,l,y",
-              "col,u,n", "col,u,y", "col,l,n", "col,l,y")),
-  c("n", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=TRUE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xsyrk.r b/test/performance/graphs/xsyrk.r
deleted file mode 100644
index 4ab46c9f..00000000
--- a/test/performance/graphs/xsyrk.r
+++ /dev/null
@@ -1,94 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xsyrk routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xsyrk"
-parameters <- c("-n","-k","-layout","-triangle","-transA",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 128",
-  "multiples of 128 (+1)",
-  "around n=k=512",
-  "around n=k=2048",
-  "layouts and transposing (n=k=1024)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c( 128,  128, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 129,  129, 102, 111, 111, 16, 128, num_runs, precision)),
-  list(c( 512,  512, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(c(2048, 2048, 102, 111, 111, 16, 1, num_runs, precision)),
-  list(
-    c(1024, 1024, 101, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 112, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 112, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 112, 112, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(   8,    8, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  16,   16, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  32,   32, 102, 111, 111, 1, 0, num_runs, precision),
-    c(  64,   64, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 128,  128, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 256,  256, 102, 111, 111, 1, 0, num_runs, precision),
-    c( 512,  512, 102, 111, 111, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 111, 111, 1, 0, num_runs, precision),
-    c(2048, 2048, 102, 111, 111, 1, 0, num_runs, precision),
-    c(4096, 4096, 102, 111, 111, 1, 0, num_runs, precision),
-    c(8192, 8192, 102, 111, 111, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "matrix sizes (n=k)",
-  "layout (row/col), triangle (u/l), transA (n/y)",
-  "matrix sizes (n=k)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  c("n", ""),
-  list(1:8, c("row,u,n", "row,u,y", "row,l,n", "row,l,y",
-              "col,u,n", "col,u,y", "col,l,n", "col,l,y")),
-  c("n", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=TRUE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/graphs/xtrmm.r b/test/performance/graphs/xtrmm.r
deleted file mode 100644
index c2faaa8b..00000000
--- a/test/performance/graphs/xtrmm.r
+++ /dev/null
@@ -1,127 +0,0 @@
-
-# ==================================================================================================
-# This file is part of the CLBlast project. The project is licensed under Apache Version 2.0. This
-# project uses a tab-size of two spaces and a max-width of 100 characters per line.
-#
-# Author(s):
-#   Cedric Nugteren <www.cedricnugteren.nl>
-#
-# This file implements the performance script for the Xtrmm routine
-#
-# ==================================================================================================
-
-# Includes the common functions
-args <- commandArgs(trailingOnly = FALSE)
-thisfile <- (normalizePath(sub("--file=", "", args[grep("--file=", args)])))
-source(file.path(dirname(thisfile), "common.r"))
-
-# ==================================================================================================
-
-# Settings
-routine_name <- "xtrmm"
-parameters <- c("-m","-n","-layout","-side","-triangle","-transA","-diagonal",
-                "-num_steps","-step","-runs","-precision")
-precision <- 32
-
-# Sets the names of the test-cases
-test_names <- list(
-  "multiples of 128",
-  "multiples of 128 (+1)",
-  "around m=n=512",
-  "around m=n=2048",
-  "layouts and side/triangle (m=n=1024)",
-  "powers of 2"
-)
-
-# Defines the test-cases
-test_values <- list(
-  list(c( 128,  128, 102, 141, 121, 111, 131, 16, 128, num_runs, precision)),
-  list(c( 129,  129, 102, 141, 121, 111, 131, 16, 128, num_runs, precision)),
-  list(c( 512,  512, 102, 141, 121, 111, 131, 16, 1, num_runs, precision)),
-  list(c(2048, 2048, 102, 141, 121, 111, 131, 16, 1, num_runs, precision)),
-  list(
-    c(1024, 1024, 101, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 121, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 121, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 121, 112, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 122, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 122, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 122, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 141, 122, 112, 132, 1, 0, num_runs, precision),
-
-    c(1024, 1024, 101, 142, 121, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 121, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 121, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 121, 112, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 122, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 122, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 122, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 101, 142, 122, 112, 132, 1, 0, num_runs, precision),
-
-    c(1024, 1024, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 121, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 121, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 121, 112, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 122, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 122, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 122, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 122, 112, 132, 1, 0, num_runs, precision),
-
-    c(1024, 1024, 102, 142, 121, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 121, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 121, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 121, 112, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 122, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 122, 111, 132, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 122, 112, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 142, 122, 112, 132, 1, 0, num_runs, precision)
-  ),
-  list(
-    c(   8,    8, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(  16,   16, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(  32,   32, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(  64,   64, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c( 128,  128, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c( 256,  256, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c( 512,  512, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(1024, 1024, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(2048, 2048, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(4096, 4096, 102, 141, 121, 111, 131, 1, 0, num_runs, precision),
-    c(8192, 8192, 102, 141, 121, 111, 131, 1, 0, num_runs, precision)
-  )
-)
-
-# Defines the x-labels corresponding to the test-cases
-test_xlabels <- list(
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "matrix sizes (m=n)",
-  "layout (row/col), side (l/r), triangle (up/lo), transA (n/y), diag (u/nu)",
-  "matrix sizes (m=n)"
-)
-
-# Defines the x-axis of the test-cases
-test_xaxis <- list(
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  c("m", ""),
-  list(1:32, c("row,l,up,n,u", "row,l,up,n,nu", "row,l,up,y,u", "row,l,up,y,nu",
-               "row,r,up,n,u", "row,r,up,n,nu", "row,r,up,y,u", "row,r,up,y,nu",
-               "row,l,lo,n,u", "row,l,lo,n,nu", "row,l,lo,y,u", "row,l,lo,y,nu",
-               "row,r,lo,n,u", "row,r,lo,n,nu", "row,r,lo,y,u", "row,r,lo,y,nu",
-               "col,l,up,n,u", "col,l,up,n,nu", "col,l,up,y,u", "col,l,up,y,nu",
-               "col,r,up,n,u", "col,r,up,n,nu", "col,r,up,y,u", "col,r,up,y,nu",
-               "col,l,lo,n,u", "col,l,lo,n,nu", "col,l,lo,y,u", "col,l,lo,y,nu",
-               "col,r,lo,n,u", "col,r,lo,n,nu", "col,r,lo,y,u", "col,r,lo,y,nu")),
-  c("m", "x")
-)
-
-# ==================================================================================================
-
-# Start the script
-main(routine_name=routine_name, precision=precision, test_names=test_names, test_values=test_values,
-     test_xlabels=test_xlabels, test_xaxis=test_xaxis, metric_gflops=TRUE)
-
-# ==================================================================================================
\ No newline at end of file
diff --git a/test/performance/routines/level1/xamax.cc b/test/performance/routines/level1/xamax.cpp
index 85caa483..450678e0 100644
--- a/test/performance/routines/level1/xamax.cc
+++ b/test/performance/routines/level1/xamax.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xamax.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xamax.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXamax<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXamax<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xasum.cc b/test/performance/routines/level1/xasum.cpp
index 2680966e..c21102f5 100644
--- a/test/performance/routines/level1/xasum.cc
+++ b/test/performance/routines/level1/xasum.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xasum.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xasum.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXasum<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXasum<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xaxpy.cc b/test/performance/routines/level1/xaxpy.cpp
index b423bc3a..e1c4935e 100644
--- a/test/performance/routines/level1/xaxpy.cc
+++ b/test/performance/routines/level1/xaxpy.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xaxpy.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xaxpy.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXaxpy<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXaxpy<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xcopy.cc b/test/performance/routines/level1/xcopy.cpp
index c04c6c1c..ea3531a0 100644
--- a/test/performance/routines/level1/xcopy.cc
+++ b/test/performance/routines/level1/xcopy.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xcopy.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xcopy.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXcopy<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXcopy<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xdot.cc b/test/performance/routines/level1/xdot.cpp
index f4616464..09fe9258 100644
--- a/test/performance/routines/level1/xdot.cc
+++ b/test/performance/routines/level1/xdot.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xdot.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xdot.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXdot<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXdot<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xdotc.cc b/test/performance/routines/level1/xdotc.cpp
index 5f36b80e..6e716ebb 100644
--- a/test/performance/routines/level1/xdotc.cc
+++ b/test/performance/routines/level1/xdotc.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xdotc.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xdotc.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xdotu.cc b/test/performance/routines/level1/xdotu.cpp
index f19f751b..d011d558 100644
--- a/test/performance/routines/level1/xdotu.cc
+++ b/test/performance/routines/level1/xdotu.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xdotu.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xdotu.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xnrm2.cc b/test/performance/routines/level1/xnrm2.cpp
index db6ec9ad..1d6e177d 100644
--- a/test/performance/routines/level1/xnrm2.cc
+++ b/test/performance/routines/level1/xnrm2.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xnrm2.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xnrm2.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXnrm2<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXnrm2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xrot.cc b/test/performance/routines/level1/xrot.cpp
index 3ff59ace..4b543f1b 100644
--- a/test/performance/routines/level1/xrot.cc
+++ b/test/performance/routines/level1/xrot.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xrot.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xrot.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xrotg.cc b/test/performance/routines/level1/xrotg.cpp
index 0320c314..e52704b0 100644
--- a/test/performance/routines/level1/xrotg.cc
+++ b/test/performance/routines/level1/xrotg.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xrotg.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xrotg.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xrotm.cc b/test/performance/routines/level1/xrotm.cpp
index 7af94d0f..83ee1d9d 100644
--- a/test/performance/routines/level1/xrotm.cc
+++ b/test/performance/routines/level1/xrotm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xrotm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xrotm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xrotmg.cc b/test/performance/routines/level1/xrotmg.cpp
index a326347b..ee1539d9 100644
--- a/test/performance/routines/level1/xrotmg.cc
+++ b/test/performance/routines/level1/xrotmg.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xrotmg.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xrotmg.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level1/xscal.cc b/test/performance/routines/level1/xscal.cpp
index bd38f43e..adb83a90 100644
--- a/test/performance/routines/level1/xscal.cc
+++ b/test/performance/routines/level1/xscal.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xscal.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xscal.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXscal<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXscal<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level1/xswap.cc b/test/performance/routines/level1/xswap.cpp
index 112641d3..7f591d19 100644
--- a/test/performance/routines/level1/xswap.cc
+++ b/test/performance/routines/level1/xswap.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level1/xswap.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level1/xswap.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXswap<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXswap<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xgbmv.cc b/test/performance/routines/level2/xgbmv.cpp
index b050184d..6aa72ded 100644
--- a/test/performance/routines/level2/xgbmv.cc
+++ b/test/performance/routines/level2/xgbmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xgbmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xgbmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXgbmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xgemv.cc b/test/performance/routines/level2/xgemv.cpp
index 51ab9a10..fdcef95d 100644
--- a/test/performance/routines/level2/xgemv.cc
+++ b/test/performance/routines/level2/xgemv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xgemv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xgemv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXgemv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgemv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xger.cc b/test/performance/routines/level2/xger.cpp
index 2d956346..c4f3699d 100644
--- a/test/performance/routines/level2/xger.cc
+++ b/test/performance/routines/level2/xger.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xger.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xger.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXger<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXger<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xgerc.cc b/test/performance/routines/level2/xgerc.cpp
index acd0fab7..f855dc11 100644
--- a/test/performance/routines/level2/xgerc.cc
+++ b/test/performance/routines/level2/xgerc.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xgerc.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xgerc.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xgeru.cc b/test/performance/routines/level2/xgeru.cpp
index a5973777..2bf885e3 100644
--- a/test/performance/routines/level2/xgeru.cc
+++ b/test/performance/routines/level2/xgeru.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xgeru.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xgeru.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xhbmv.cc b/test/performance/routines/level2/xhbmv.cpp
index 28b71045..b7f3b9ad 100644
--- a/test/performance/routines/level2/xhbmv.cc
+++ b/test/performance/routines/level2/xhbmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xhbmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xhbmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xhemv.cc b/test/performance/routines/level2/xhemv.cpp
index 622854a7..e1168083 100644
--- a/test/performance/routines/level2/xhemv.cc
+++ b/test/performance/routines/level2/xhemv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xhemv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xhemv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xher.cc b/test/performance/routines/level2/xher.cpp
index 613d7766..0d1bc1dd 100644
--- a/test/performance/routines/level2/xher.cc
+++ b/test/performance/routines/level2/xher.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xher.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xher.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xher2.cc b/test/performance/routines/level2/xher2.cpp
index c335d3be..3d98c838 100644
--- a/test/performance/routines/level2/xher2.cc
+++ b/test/performance/routines/level2/xher2.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xher2.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xher2.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xhpmv.cc b/test/performance/routines/level2/xhpmv.cpp
index 1e726569..c3bc3d9c 100644
--- a/test/performance/routines/level2/xhpmv.cc
+++ b/test/performance/routines/level2/xhpmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xhpmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xhpmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xhpr.cc b/test/performance/routines/level2/xhpr.cpp
index 000b69af..afc65b25 100644
--- a/test/performance/routines/level2/xhpr.cc
+++ b/test/performance/routines/level2/xhpr.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xhpr.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xhpr.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xhpr2.cc b/test/performance/routines/level2/xhpr2.cpp
index 19bafc46..c543dc90 100644
--- a/test/performance/routines/level2/xhpr2.cc
+++ b/test/performance/routines/level2/xhpr2.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xhpr2.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xhpr2.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xsbmv.cc b/test/performance/routines/level2/xsbmv.cpp
index eabab3b7..32899a74 100644
--- a/test/performance/routines/level2/xsbmv.cc
+++ b/test/performance/routines/level2/xsbmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xsbmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xsbmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsbmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xspmv.cc b/test/performance/routines/level2/xspmv.cpp
index 2a9ef925..0b0d2409 100644
--- a/test/performance/routines/level2/xspmv.cc
+++ b/test/performance/routines/level2/xspmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xspmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xspmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXspmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xspr.cc b/test/performance/routines/level2/xspr.cpp
index 84331d74..9c1c80a0 100644
--- a/test/performance/routines/level2/xspr.cc
+++ b/test/performance/routines/level2/xspr.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xspr.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xspr.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXspr<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspr<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xspr2.cc b/test/performance/routines/level2/xspr2.cpp
index c42009a1..117e9c2f 100644
--- a/test/performance/routines/level2/xspr2.cc
+++ b/test/performance/routines/level2/xspr2.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xspr2.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xspr2.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXspr2<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXspr2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xsymv.cc b/test/performance/routines/level2/xsymv.cpp
index 3f72fe77..60db1ae9 100644
--- a/test/performance/routines/level2/xsymv.cc
+++ b/test/performance/routines/level2/xsymv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xsymv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xsymv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsymv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsymv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xsyr.cc b/test/performance/routines/level2/xsyr.cpp
index 6b31d3a9..d9ecd38a 100644
--- a/test/performance/routines/level2/xsyr.cc
+++ b/test/performance/routines/level2/xsyr.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xsyr.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xsyr.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsyr<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xsyr2.cc b/test/performance/routines/level2/xsyr2.cpp
index 0ad59d2d..24e0a517 100644
--- a/test/performance/routines/level2/xsyr2.cc
+++ b/test/performance/routines/level2/xsyr2.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xsyr2.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xsyr2.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsyr2<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr2<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xtbmv.cc b/test/performance/routines/level2/xtbmv.cpp
index a3297f34..ed9d26a8 100644
--- a/test/performance/routines/level2/xtbmv.cc
+++ b/test/performance/routines/level2/xtbmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtbmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtbmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXtbmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtbmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xtbsv.cc b/test/performance/routines/level2/xtbsv.cpp
index 4dcd9a06..f0b80330 100644
--- a/test/performance/routines/level2/xtbsv.cc
+++ b/test/performance/routines/level2/xtbsv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtbsv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtbsv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xtpmv.cc b/test/performance/routines/level2/xtpmv.cpp
index 72477f2d..c5801205 100644
--- a/test/performance/routines/level2/xtpmv.cc
+++ b/test/performance/routines/level2/xtpmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtpmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtpmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXtpmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtpmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xtpsv.cc b/test/performance/routines/level2/xtpsv.cpp
index a3e3f7f1..db956c9d 100644
--- a/test/performance/routines/level2/xtpsv.cc
+++ b/test/performance/routines/level2/xtpsv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtpsv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtpsv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level2/xtrmv.cc b/test/performance/routines/level2/xtrmv.cpp
index 894a7952..629c773c 100644
--- a/test/performance/routines/level2/xtrmv.cc
+++ b/test/performance/routines/level2/xtrmv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtrmv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtrmv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXtrmv<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtrmv<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level2/xtrsv.cc b/test/performance/routines/level2/xtrsv.cpp
index e8c65b0f..d6c2968c 100644
--- a/test/performance/routines/level2/xtrsv.cc
+++ b/test/performance/routines/level2/xtrsv.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level2/xtrsv.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level2/xtrsv.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level3/xgemm.cc b/test/performance/routines/level3/xgemm.cpp
index 91897ee1..3f68096e 100644
--- a/test/performance/routines/level3/xgemm.cc
+++ b/test/performance/routines/level3/xgemm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xgemm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xgemm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXgemm<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXgemm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level3/xhemm.cc b/test/performance/routines/level3/xhemm.cpp
index 87650b9e..ff6d0f71 100644
--- a/test/performance/routines/level3/xhemm.cc
+++ b/test/performance/routines/level3/xhemm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xhemm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xhemm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level3/xher2k.cc b/test/performance/routines/level3/xher2k.cpp
index 06894816..9636959e 100644
--- a/test/performance/routines/level3/xher2k.cc
+++ b/test/performance/routines/level3/xher2k.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xher2k.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xher2k.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level3/xherk.cc b/test/performance/routines/level3/xherk.cpp
index d6f38fb2..d51400f0 100644
--- a/test/performance/routines/level3/xherk.cc
+++ b/test/performance/routines/level3/xherk.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xherk.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xherk.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
diff --git a/test/performance/routines/level3/xsymm.cc b/test/performance/routines/level3/xsymm.cpp
index e0feadd1..38c3dc9b 100644
--- a/test/performance/routines/level3/xsymm.cc
+++ b/test/performance/routines/level3/xsymm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xsymm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xsymm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsymm<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsymm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level3/xsyr2k.cc b/test/performance/routines/level3/xsyr2k.cpp
index 4a82ddc4..5360e297 100644
--- a/test/performance/routines/level3/xsyr2k.cc
+++ b/test/performance/routines/level3/xsyr2k.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xsyr2k.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xsyr2k.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsyr2k<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyr2k<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level3/xsyrk.cc b/test/performance/routines/level3/xsyrk.cpp
index 70f61322..30612f99 100644
--- a/test/performance/routines/level3/xsyrk.cc
+++ b/test/performance/routines/level3/xsyrk.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xsyrk.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xsyrk.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXsyrk<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXsyrk<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level3/xtrmm.cc b/test/performance/routines/level3/xtrmm.cpp
index 6f6041e4..264a34e7 100644
--- a/test/performance/routines/level3/xtrmm.cc
+++ b/test/performance/routines/level3/xtrmm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xtrmm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xtrmm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXtrmm<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtrmm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/level3/xtrsm.cc b/test/performance/routines/level3/xtrsm.cpp
index 76ef255a..80c46d91 100644
--- a/test/performance/routines/level3/xtrsm.cc
+++ b/test/performance/routines/level3/xtrsm.cpp
@@ -9,8 +9,8 @@
 //
 // =================================================================================================
 
-#include "performance/client.h"
-#include "routines/level3/xtrsm.h"
+#include "test/performance/client.hpp"
+#include "test/routines/level3/xtrsm.hpp"
 
 // Shortcuts to the clblast namespace
 using float2 = clblast::float2;
@@ -19,7 +19,8 @@ using double2 = clblast::double2;
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
   switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
-    case clblast::Precision::kHalf: throw std::runtime_error("Unsupported precision mode");
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXtrsm<half>, half, half>(argc, argv); break;
     case clblast::Precision::kSingle:
       clblast::RunClient<clblast::TestXtrsm<float>, float, float>(argc, argv); break;
     case clblast::Precision::kDouble:
diff --git a/test/performance/routines/levelx/xomatcopy.cpp b/test/performance/routines/levelx/xomatcopy.cpp
new file mode 100644
index 00000000..0bd5773e
--- /dev/null
+++ b/test/performance/routines/levelx/xomatcopy.cpp
@@ -0,0 +1,36 @@
+
+// =================================================================================================
+// 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.
+//
+// Author(s):
+//   Cedric Nugteren <www.cedricnugteren.nl>
+//
+// =================================================================================================
+
+#include "test/performance/client.hpp"
+#include "test/routines/levelx/xomatcopy.hpp"
+
+// Shortcuts to the clblast namespace
+using float2 = clblast::float2;
+using double2 = clblast::double2;
+
+// Main function (not within the clblast namespace)
+int main(int argc, char *argv[]) {
+  switch(clblast::GetPrecision(argc, argv, clblast::Precision::kSingle)) {
+    case clblast::Precision::kHalf:
+      clblast::RunClient<clblast::TestXomatcopy<half>, half, half>(argc, argv); break;
+    case clblast::Precision::kSingle:
+      clblast::RunClient<clblast::TestXomatcopy<float>, float, float>(argc, argv); break;
+    case clblast::Precision::kDouble:
+      clblast::RunClient<clblast::TestXomatcopy<double>, double, double>(argc, argv); break;
+    case clblast::Precision::kComplexSingle:
+      clblast::RunClient<clblast::TestXomatcopy<float2>, float2, float2>(argc, argv); break;
+    case clblast::Precision::kComplexDouble:
+      clblast::RunClient<clblast::TestXomatcopy<double2>, double2, double2>(argc, argv); break;
+  }
+  return 0;
+}
+
+// =================================================================================================