Made it possible to use the command-line environmental variables for each executable and without re-running CMake

13 files changed, 84 insertions, 45 deletions

diff --git a/src/tuning/kernels/copy_fast.cpp b/src/tuning/kernels/copy_fast.cpp
index 1651d299..7a434513 100644
--- a/src/tuning/kernels/copy_fast.cpp
+++ b/src/tuning/kernels/copy_fast.cpp
@@ -109,7 +109,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneCopy<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneCopy<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneCopy<double>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/copy_pad.cpp b/src/tuning/kernels/copy_pad.cpp
index 5be58369..94d9c303 100644
--- a/src/tuning/kernels/copy_pad.cpp
+++ b/src/tuning/kernels/copy_pad.cpp
@@ -117,7 +117,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TunePad<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TunePad<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TunePad<double>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/transpose_fast.cpp b/src/tuning/kernels/transpose_fast.cpp
index 01d9b46a..e16ab235 100644
--- a/src/tuning/kernels/transpose_fast.cpp
+++ b/src/tuning/kernels/transpose_fast.cpp
@@ -114,7 +114,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneTranspose<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneTranspose<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneTranspose<double>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/transpose_pad.cpp b/src/tuning/kernels/transpose_pad.cpp
index 4e830faa..c01298bf 100644
--- a/src/tuning/kernels/transpose_pad.cpp
+++ b/src/tuning/kernels/transpose_pad.cpp
@@ -121,7 +121,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TunePadTranspose<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TunePadTranspose<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TunePadTranspose<double>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xaxpy.cpp b/src/tuning/kernels/xaxpy.cpp
index 44538b4b..824ab29e 100644
--- a/src/tuning/kernels/xaxpy.cpp
+++ b/src/tuning/kernels/xaxpy.cpp
@@ -112,7 +112,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXaxpy<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXaxpy<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXaxpy<double>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xdot.cpp b/src/tuning/kernels/xdot.cpp
index 2ba7d91d..f871d42a 100644
--- a/src/tuning/kernels/xdot.cpp
+++ b/src/tuning/kernels/xdot.cpp
@@ -119,7 +119,8 @@ using double2 = clblast::double2;
 // Function to tune a specific variation V (not within the clblast namespace)
 template <int V>
 void StartVariation(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXdot<half, V>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXdot<float, V>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXdot<double, V>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xgemm.cpp b/src/tuning/kernels/xgemm.cpp
index dc9040b0..f55eadd8 100644
--- a/src/tuning/kernels/xgemm.cpp
+++ b/src/tuning/kernels/xgemm.cpp
@@ -178,7 +178,8 @@ using double2 = clblast::double2;
 // Function to tune a specific variation V (not within the clblast namespace)
 template <int V>
 void StartVariation(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXgemm<half,V>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXgemm<float,V>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXgemm<double,V>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xgemm_direct.cpp b/src/tuning/kernels/xgemm_direct.cpp
index b1d5fbc4..ee5bcb7e 100644
--- a/src/tuning/kernels/xgemm_direct.cpp
+++ b/src/tuning/kernels/xgemm_direct.cpp
@@ -177,7 +177,8 @@ using double2 = clblast::double2;
 // Function to tune a specific variation V (not within the clblast namespace)
 template <int V>
 void StartVariation(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXgemmDirect<half,V>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXgemmDirect<float,V>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXgemmDirect<double,V>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xgemv.cpp b/src/tuning/kernels/xgemv.cpp
index 1ae641a7..97a45225 100644
--- a/src/tuning/kernels/xgemv.cpp
+++ b/src/tuning/kernels/xgemv.cpp
@@ -159,7 +159,8 @@ using double2 = clblast::double2;
 // Function to tune a specific variation V (not within the clblast namespace)
 template <int V>
 void StartVariation(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXgemv<half,V>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXgemv<float,V>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXgemv<double,V>, double>(argc, argv); break;
diff --git a/src/tuning/kernels/xger.cpp b/src/tuning/kernels/xger.cpp
index 8a3ede98..5057492f 100644
--- a/src/tuning/kernels/xger.cpp
+++ b/src/tuning/kernels/xger.cpp
@@ -117,7 +117,8 @@ using double2 = clblast::double2;
 
 // Main function (not within the clblast namespace)
 int main(int argc, char *argv[]) {
-  switch(clblast::GetPrecision(argc, argv)) {
+  const auto command_line_args = clblast::RetrieveCommandLineArguments(argc, argv);
+  switch(clblast::GetPrecision(command_line_args)) {
     case clblast::Precision::kHalf: clblast::Tuner<clblast::TuneXger<half>, half>(argc, argv); break;
     case clblast::Precision::kSingle: clblast::Tuner<clblast::TuneXger<float>, float>(argc, argv); break;
     case clblast::Precision::kDouble: clblast::Tuner<clblast::TuneXger<double>, double>(argc, argv); break;
diff --git a/src/tuning/tuning.hpp b/src/tuning/tuning.hpp
index c4ee0da0..1dd76894 100644
--- a/src/tuning/tuning.hpp
+++ b/src/tuning/tuning.hpp
@@ -33,20 +33,21 @@ void Tuner(int argc, char* argv[]) {
   constexpr auto kSeed = 42; // fixed seed for reproducibility
 
   // Sets the parameters and platform/device for which to tune (command-line options)
+  auto command_line_args = RetrieveCommandLineArguments(argc, argv);
   auto help = std::string{"* Options given/available:\n"};
   auto args = Arguments<T>{};
-  args.platform_id = GetArgument(argc, argv, help, kArgPlatform, size_t{0});
-  args.device_id   = GetArgument(argc, argv, help, kArgDevice, size_t{0});
-  args.precision   = GetArgument(argc, argv, help, kArgPrecision, Precision::kSingle);
+  args.platform_id = GetArgument(command_line_args, help, kArgPlatform, ConvertArgument(std::getenv("CLBLAST_PLATFORM"), size_t{0}));
+  args.device_id   = GetArgument(command_line_args, help, kArgDevice, ConvertArgument(std::getenv("CLBLAST_DEVICE"), size_t{0}));
+  args.precision   = GetArgument(command_line_args, help, kArgPrecision, Precision::kSingle);
   for (auto &o: C::GetOptions()) {
-    if (o == kArgM)        { args.m        = GetArgument(argc, argv, help, kArgM, C::DefaultM()); }
-    if (o == kArgN)        { args.n        = GetArgument(argc, argv, help, kArgN, C::DefaultN()); }
-    if (o == kArgK)        { args.k        = GetArgument(argc, argv, help, kArgK, C::DefaultK()); }
-    if (o == kArgAlpha)    { args.alpha    = GetArgument(argc, argv, help, kArgAlpha, GetScalar<T>()); }
-    if (o == kArgBeta)     { args.beta     = GetArgument(argc, argv, help, kArgBeta, GetScalar<T>()); }
-    if (o == kArgFraction) { args.fraction = GetArgument(argc, argv, help, kArgFraction, C::DefaultFraction()); }
+    if (o == kArgM)        { args.m        = GetArgument(command_line_args, help, kArgM, C::DefaultM()); }
+    if (o == kArgN)        { args.n        = GetArgument(command_line_args, help, kArgN, C::DefaultN()); }
+    if (o == kArgK)        { args.k        = GetArgument(command_line_args, help, kArgK, C::DefaultK()); }
+    if (o == kArgAlpha)    { args.alpha    = GetArgument(command_line_args, help, kArgAlpha, GetScalar<T>()); }
+    if (o == kArgBeta)     { args.beta     = GetArgument(command_line_args, help, kArgBeta, GetScalar<T>()); }
+    if (o == kArgFraction) { args.fraction = GetArgument(command_line_args, help, kArgFraction, C::DefaultFraction()); }
   }
-  const auto num_runs = GetArgument(argc, argv, help, kArgNumRuns, C::DefaultNumRuns());
+  const auto num_runs = GetArgument(command_line_args, help, kArgNumRuns, C::DefaultNumRuns());
 
   fprintf(stdout, "%s\n", help.c_str());
 
diff --git a/src/utilities/utilities.cpp b/src/utilities/utilities.cpp
index 24456252..5e445bb9 100644
--- a/src/utilities/utilities.cpp
+++ b/src/utilities/utilities.cpp
@@ -158,6 +158,27 @@ std::string ToString(StatusCode value) {
 
 // =================================================================================================
 
+// Retrieves the command-line arguments in a C++ fashion. Also adds command-line arguments from
+// pre-defined environmental variables
+std::vector<std::string> RetrieveCommandLineArguments(int argc, char *argv[]) {
+
+  // Regular command-line arguments
+  auto command_line_args = std::vector<std::string>();
+  for (auto i=0; i<argc; ++i) {
+    command_line_args.push_back(std::string{argv[i]});
+  }
+
+  // Extra CLBlast arguments
+  const auto extra_args = ConvertArgument(std::getenv("CLBLAST_ARGUMENTS"), std::string{""});
+  std::stringstream extra_args_stream;
+  extra_args_stream.str(extra_args);
+  std::string extra_arg;
+  while (std::getline(extra_args_stream, extra_arg, ' ')) {
+    command_line_args.push_back(extra_arg);
+  }
+  return command_line_args;
+}
+
 // Helper for the below function to convert the argument to the value type. Adds specialization for
 // complex data-types. Note that complex arguments are accepted as regular values and are copied to
 // both the real and imaginary parts.
@@ -167,6 +188,9 @@ T ConvertArgument(const char* value) {
 }
 template size_t ConvertArgument(const char* value);
 
+template <> std::string ConvertArgument(const char* value) {
+  return std::string{value};
+}
 template <> half ConvertArgument(const char* value) {
   return FloatToHalf(static_cast<float>(std::stod(value)));
 }
@@ -193,21 +217,22 @@ T ConvertArgument(const char* value, T default_value) {
   return default_value;
 }
 template size_t ConvertArgument(const char* value, size_t default_value);
+template std::string ConvertArgument(const char* value, std::string default_value);
 
 // This function matches patterns in the form of "-option value" or "--option value". It returns a
 // default value in case the option is not found in the argument string.
 template <typename T>
-T GetArgument(const int argc, char **argv, std::string &help,
+T GetArgument(const std::vector<std::string> &arguments, std::string &help,
               const std::string &option, const T default_value) {
 
   // Parses the argument. Note that this supports both the given option (e.g. -device) and one with
   // an extra dash in front (e.g. --device).
   auto return_value = static_cast<T>(default_value);
-  for (int c=0; c<argc; ++c) {
-    auto item = std::string{argv[c]};
+  for (auto c=size_t{0}; c<arguments.size(); ++c) {
+    auto item = arguments[c];
     if (item.compare("-"+option) == 0 || item.compare("--"+option) == 0) {
       ++c;
-      return_value = ConvertArgument<T>(argv[c]);
+      return_value = ConvertArgument<T>(arguments[c].c_str());
       break;
     }
   }
@@ -219,39 +244,39 @@ T GetArgument(const int argc, char **argv, std::string &help,
 }
 
 // Compiles the above function
-template int GetArgument<int>(const int, char **, std::string&, const std::string&, const int);
-template size_t GetArgument<size_t>(const int, char **, std::string&, const std::string&, const size_t);
-template half GetArgument<half>(const int, char **, std::string&, const std::string&, const half);
-template float GetArgument<float>(const int, char **, std::string&, const std::string&, const float);
-template double GetArgument<double>(const int, char **, std::string&, const std::string&, const double);
-template float2 GetArgument<float2>(const int, char **, std::string&, const std::string&, const float2);
-template double2 GetArgument<double2>(const int, char **, std::string&, const std::string&, const double2);
-template Layout GetArgument<Layout>(const int, char **, std::string&, const std::string&, const Layout);
-template Transpose GetArgument<Transpose>(const int, char **, std::string&, const std::string&, const Transpose);
-template Side GetArgument<Side>(const int, char **, std::string&, const std::string&, const Side);
-template Triangle GetArgument<Triangle>(const int, char **, std::string&, const std::string&, const Triangle);
-template Diagonal GetArgument<Diagonal>(const int, char **, std::string&, const std::string&, const Diagonal);
-template Precision GetArgument<Precision>(const int, char **, std::string&, const std::string&, const Precision);
+template int GetArgument<int>(const std::vector<std::string>&, std::string&, const std::string&, const int);
+template size_t GetArgument<size_t>(const std::vector<std::string>&, std::string&, const std::string&, const size_t);
+template half GetArgument<half>(const std::vector<std::string>&, std::string&, const std::string&, const half);
+template float GetArgument<float>(const std::vector<std::string>&, std::string&, const std::string&, const float);
+template double GetArgument<double>(const std::vector<std::string>&, std::string&, const std::string&, const double);
+template float2 GetArgument<float2>(const std::vector<std::string>&, std::string&, const std::string&, const float2);
+template double2 GetArgument<double2>(const std::vector<std::string>&, std::string&, const std::string&, const double2);
+template Layout GetArgument<Layout>(const std::vector<std::string>&, std::string&, const std::string&, const Layout);
+template Transpose GetArgument<Transpose>(const std::vector<std::string>&, std::string&, const std::string&, const Transpose);
+template Side GetArgument<Side>(const std::vector<std::string>&, std::string&, const std::string&, const Side);
+template Triangle GetArgument<Triangle>(const std::vector<std::string>&, std::string&, const std::string&, const Triangle);
+template Diagonal GetArgument<Diagonal>(const std::vector<std::string>&, std::string&, const std::string&, const Diagonal);
+template Precision GetArgument<Precision>(const std::vector<std::string>&, std::string&, const std::string&, const Precision);
 
 // =================================================================================================
 
 // Returns only the precision argument
-Precision GetPrecision(const int argc, char *argv[], const Precision default_precision) {
+Precision GetPrecision(const std::vector<std::string> &arguments, const Precision default_precision) {
   auto dummy = std::string{};
-  return GetArgument(argc, argv, dummy, kArgPrecision, default_precision);
+  return GetArgument(arguments, dummy, kArgPrecision, default_precision);
 }
 
 // =================================================================================================
 
 // Checks whether an argument is given. Returns true or false.
-bool CheckArgument(const int argc, char *argv[], std::string &help,
+bool CheckArgument(const std::vector<std::string> &arguments, std::string &help,
                    const std::string &option) {
 
   // Parses the argument. Note that this supports both the given option (e.g. -device) and one with
   // an extra dash in front (e.g. --device).
   auto return_value = false;
-  for (int c=0; c<argc; ++c) {
-    auto item = std::string{argv[c]};
+  for (auto c=size_t{0}; c<arguments.size(); ++c) {
+    auto item = arguments[c];
     if (item.compare("-"+option) == 0 || item.compare("--"+option) == 0) {
       ++c;
       return_value = true;
diff --git a/src/utilities/utilities.hpp b/src/utilities/utilities.hpp
index 9bc7401a..20587bd4 100644
--- a/src/utilities/utilities.hpp
+++ b/src/utilities/utilities.hpp
@@ -185,6 +185,9 @@ std::string ToString(T value);
 
 // =================================================================================================
 
+// Parses command-line and environmental-variable arguments into a std::vector of strings
+std::vector<std::string> RetrieveCommandLineArguments(int argc, char *argv[]);
+
 // Helper for the function "GetArgument"
 template <typename T>
 T ConvertArgument(const char* value);
@@ -195,15 +198,15 @@ T ConvertArgument(const char* value, T default_value);
 
 // Basic argument parser, matching patterns in the form of "-option value" and "--option value"
 template <typename T>
-T GetArgument(const int argc, char **argv, std::string &help,
+T GetArgument(const std::vector<std::string> &arguments, std::string &help,
               const std::string &option, const T default_value);
 
 // Returns the precision only
-Precision GetPrecision(const int argc, char *argv[],
+Precision GetPrecision(const std::vector<std::string> &arguments,
                        const Precision default_precision = Precision::kSingle);
 
 // As in "GetArgument", but now only checks whether an argument is given or not
-bool CheckArgument(const int argc, char *argv[], std::string &help, const std::string &option);
+bool CheckArgument(const std::vector<std::string> &arguments, std::string &help, const std::string &option);
 
 // =================================================================================================