Refactored the tuning architecture: less duplicate now; more defaults

1 files changed, 46 insertions, 64 deletions

diff --git a/src/tuning/kernels/xaxpy.cpp b/src/tuning/kernels/xaxpy.cpp
index f8e1d93e..e201949a 100644
--- a/src/tuning/kernels/xaxpy.cpp
+++ b/src/tuning/kernels/xaxpy.cpp
@@ -25,19 +25,54 @@ template <typename T>
 class TuneXaxpy {
  public:
 
-  // The representative kernel and the source code
-  static std::string KernelFamily() { return "xaxpy"; }
-  static std::string KernelName() { return "XaxpyFastest"; }
-  static std::string GetSources() {
-    return
-      #include "../src/kernels/common.opencl"
-      #include "../src/kernels/level1/level1.opencl"
-      #include "../src/kernels/level1/xaxpy.opencl"
-    ;
+  // Settings for this kernel (default command-line arguments)
+  static TunerDefaults GetTunerDefaults() {
+    auto settings = TunerDefaults();
+    settings.options = {kArgN, kArgAlpha};
+    settings.default_n = 4096*1024;
+    return settings;
   }
 
-  // The list of arguments relevant for this routine
-  static std::vector<std::string> GetOptions() { return {kArgN, kArgAlpha}; }
+  // Settings for this kernel (general)
+  static TunerSettings GetTunerSettings(const Arguments<T> &args) {
+    auto settings = TunerSettings();
+
+    // Identification of the kernel
+    settings.kernel_family = "xaxpy";
+    settings.kernel_name = "XaxpyFastest";
+    settings.sources =
+#include "../src/kernels/common.opencl"
+#include "../src/kernels/level1/level1.opencl"
+#include "../src/kernels/level1/xaxpy.opencl"
+    ;
+
+    // Buffer sizes
+    settings.size_x = args.n;
+    settings.size_y = args.n;
+
+    // Sets the base thread configuration
+    settings.global_size = {args.n};
+    settings.global_size_ref = settings.global_size;
+    settings.local_size = {1};
+    settings.local_size_ref = {64};
+
+    // Transforms the thread configuration based on the parameters
+    settings.mul_local = {{"WGS"}};
+    settings.div_global = {{"WPT"},{"VW"}};
+
+    // Sets the tuning parameters and their possible values
+    settings.parameters = {
+      {"WGS", {64, 128, 256, 512, 1024, 2048}},
+      {"WPT", {1, 2, 4, 8}},
+      {"VW", {1, 2, 4, 8}},
+    };
+
+    // Describes how to compute the performance metrics
+    settings.metric_amount = 3 * args.n * GetBytes(args.precision);
+    settings.performance_unit = "GB/s";
+
+    return settings;
+  }
 
   // Tests for valid arguments
   static void TestValidArguments(const Arguments<T> &args) {
@@ -46,52 +81,10 @@ class TuneXaxpy {
     }
   }
 
-  // Sets the default values for the arguments
-  static size_t DefaultM() { return 1; } // N/A for this kernel
-  static size_t DefaultN() { return 4096*1024; }
-  static size_t DefaultK() { return 1; } // N/A for this kernel
-  static size_t DefaultBatchCount() { return 1; } // N/A for this kernel
-  static double DefaultFraction() { return 1.0; } // N/A for this kernel
-  static size_t DefaultNumRuns() { return 10; } // run every kernel this many times for averaging
-  static size_t DefaultSwarmSizePSO() { return 8; } // N/A for this kernel
-  static double DefaultInfluenceGlobalPSO(){ return 0.1; }// N/A for this kernel
-  static double DefaultInfluenceLocalPSO(){ return 0.3; }// N/A for this kernel
-  static double DefaultInfluenceRandomPSO(){ return 0.6; }// N/A for this kernel
-  static size_t DefaultHeuristic(){ return static_cast<size_t> (cltune::SearchMethod::FullSearch);} 
-  static double DefaultMaxTempAnn(){ return 1.0;} // N/A for this kernel
-  
-  // Describes how to obtain the sizes of the buffers
-  static size_t GetSizeX(const Arguments<T> &args) { return args.n; }
-  static size_t GetSizeY(const Arguments<T> &args) { return args.n; }
-  static size_t GetSizeA(const Arguments<T> &) { return 1; } // N/A for this kernel
-  static size_t GetSizeB(const Arguments<T> &) { return 1; } // N/A for this kernel
-  static size_t GetSizeC(const Arguments<T> &) { return 1; } // N/A for this kernel
-  static size_t GetSizeTemp(const Arguments<T> &) { return 1; } // N/A for this kernel
-
-  // Sets the tuning parameters and their possible values
-  static void SetParameters(cltune::Tuner &tuner, const size_t id) {
-    tuner.AddParameter(id, "WGS", {64, 128, 256, 512, 1024, 2048});
-    tuner.AddParameter(id, "WPT", {1, 2, 4, 8});
-    tuner.AddParameter(id, "VW", {1, 2, 4, 8});
-  }
-
   // Sets the constraints and local memory size
   static void SetConstraints(cltune::Tuner &, const size_t) { }
   static void SetLocalMemorySize(cltune::Tuner &, const size_t, const Arguments<T> &) { }
 
-  // Sets the base thread configuration
-  static std::vector<size_t> GlobalSize(const Arguments<T> &args) { return {args.n}; }
-  static std::vector<size_t> GlobalSizeRef(const Arguments<T> &args) { return GlobalSize(args); }
-  static std::vector<size_t> LocalSize() { return {1}; }
-  static std::vector<size_t> LocalSizeRef() { return {64}; }
-
-  // Transforms the thread configuration based on the parameters
-  using TransformVector = std::vector<std::vector<std::string>>;
-  static TransformVector MulLocal() { return {{"WGS"}}; }
-  static TransformVector DivLocal() { return {}; }
-  static TransformVector MulGlobal() { return {}; }
-  static TransformVector DivGlobal() { return {{"WPT"},{"VW"}}; }
-
   // Sets the kernel's arguments
   static void SetArguments(cltune::Tuner &tuner, const Arguments<T> &args,
                            std::vector<T> &x_vec, std::vector<T> &y_vec,
@@ -102,17 +95,6 @@ class TuneXaxpy {
     tuner.AddArgumentInput(x_vec);
     tuner.AddArgumentOutput(y_vec);
   }
-
-  // Describes how to compute the performance metrics
-  static size_t GetMetric(const Arguments<T> &args) {
-    return 3 * args.n * GetBytes(args.precision);
-  }
-  static std::string PerformanceUnit() { return "GB/s"; }
-
-  // Returns which Heuristic to run 
-  static size_t GetHeuristic(const Arguments<T> &args){
-    return static_cast<size_t> (cltune::SearchMethod::FullSearch);
-  }
 };
 
 // =================================================================================================