Moved all cache-related functions to a separate file; added a ClearCompiledProgramCache function to clear the cache

4 files changed, 87 insertions, 39 deletions

diff --git a/src/cache.cc b/src/cache.cc
new file mode 100644
index 00000000..beeb1b35
--- /dev/null
+++ b/src/cache.cc
@@ -0,0 +1,73 @@
+
+// =================================================================================================
+// 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>
+//
+// This file implements the caching functionality of compiled binaries.
+//
+// =================================================================================================
+
+#include <string>
+#include <vector>
+#include <mutex>
+
+#include "internal/cache.h"
+
+namespace clblast {
+namespace cache {
+// =================================================================================================
+
+// Stores the compiled program in the cache
+void StoreProgramToCache(const Program& program, const std::string &device_name,
+                         const Precision &precision, const std::string &routine_name) {
+  program_cache_mutex_.lock();
+  program_cache_.push_back({program, device_name, precision, routine_name});
+  program_cache_mutex_.unlock();
+}
+
+// Queries the cache and retrieves a matching program. Assumes that the match is available, throws
+// otherwise.
+const Program& GetProgramFromCache(const std::string &device_name, const Precision &precision,
+                                   const std::string &routine_name) {
+  program_cache_mutex_.lock();
+  for (auto &cached_program: program_cache_) {
+    if (cached_program.MatchInCache(device_name, precision, routine_name)) {
+      program_cache_mutex_.unlock();
+      return cached_program.program;
+    }
+  }
+  program_cache_mutex_.unlock();
+  throw std::runtime_error("Internal CLBlast error: Expected program in cache, but found none.");
+}
+
+// Queries the cache to see whether or not the compiled kernel is already there
+bool ProgramIsInCache(const std::string &device_name, const Precision &precision,
+                      const std::string &routine_name) {
+  program_cache_mutex_.lock();
+  for (auto &cached_program: program_cache_) {
+    if (cached_program.MatchInCache(device_name, precision, routine_name)) {
+      program_cache_mutex_.unlock();
+      return true;
+    }
+  }
+  program_cache_mutex_.unlock();
+  return false;
+}
+
+// =================================================================================================
+
+// Clears the cache of stored program binaries
+StatusCode ClearCompiledProgramCache() {
+  program_cache_mutex_.lock();
+  program_cache_.clear();
+  program_cache_mutex_.unlock();
+  return StatusCode::kSuccess;
+}
+
+// =================================================================================================
+} // namespace cache
+} // namespace clblast
diff --git a/src/clblast.cc b/src/clblast.cc
index 145b6bf6..b6efd185 100644
--- a/src/clblast.cc
+++ b/src/clblast.cc
@@ -17,6 +17,7 @@
 
 #include "clblast.h"
 #include "internal/public_api.h"
+#include "internal/cache.h"
 
 // BLAS level-1 includes
 #include "internal/routines/level1/xswap.h"
@@ -1788,4 +1789,9 @@ template StatusCode PUBLIC_API Trsm<double2>(const Layout, const Side, const Tri
                                              cl_command_queue*, cl_event*);
 
 // =================================================================================================
+
+// Clears the cache of stored program binaries
+StatusCode ClearCompiledProgramCache() { return cache::ClearCompiledProgramCache(); }
+
+// =================================================================================================
 } // namespace clblast
diff --git a/src/clblast_c.cc b/src/clblast_c.cc
index 23c96feb..6e238b77 100644
--- a/src/clblast_c.cc
+++ b/src/clblast_c.cc
@@ -2258,3 +2258,10 @@ StatusCode CLBlastZtrsm(const Layout layout, const Side side, const Triangle tri
 }
 
 // =================================================================================================
+
+// Clears the cache of stored program binaries
+StatusCode CLBlastClearCompiledProgramCache() {
+  return static_cast<StatusCode>(clblast::ClearCompiledProgramCache());
+}
+
+// =================================================================================================
diff --git a/src/routine.cc b/src/routine.cc
index b5ba63eb..e0a75e41 100644
--- a/src/routine.cc
+++ b/src/routine.cc
@@ -13,17 +13,12 @@
 
 #include <string>
 #include <vector>
-#include <mutex>
 
 #include "internal/routine.h"
 
 namespace clblast {
 // =================================================================================================
 
-// The cache of compiled OpenCL programs and its mutex for thread safety
-template <typename T> std::vector<typename Routine<T>::ProgramCache> Routine<T>::program_cache_;
-template <typename T> std::mutex Routine<T>::program_cache_mutex_;
-
 // Constructor: not much here, because no status codes can be returned
 template <typename T>
 Routine<T>::Routine(Queue &queue, EventPointer event, const std::string &name,
@@ -102,9 +97,7 @@ StatusCode Routine<T>::SetUp() {
       if (build_status == BuildStatus::kInvalid) { return StatusCode::kInvalidBinary; }
 
       // Store the compiled program in the cache (atomic for thread-safety)
-      program_cache_mutex_.lock();
-      program_cache_.push_back({program, device_name_, precision_, routine_name_});
-      program_cache_mutex_.unlock();
+      StoreProgramToCache(program);
     } catch (...) { return StatusCode::kBuildProgramFailure; }
   }
 
@@ -374,37 +367,6 @@ StatusCode Routine<T>::PadCopyTransposeMatrix(EventPointer event, std::vector<Ev
 
 // =================================================================================================
 
-// Queries the cache and retrieves a matching program. Assumes that the match is available, throws
-// otherwise.
-template <typename T>
-const Program& Routine<T>::GetProgramFromCache() const {
-  program_cache_mutex_.lock();
-  for (auto &cached_program: program_cache_) {
-    if (cached_program.MatchInCache(device_name_, precision_, routine_name_)) {
-      program_cache_mutex_.unlock();
-      return cached_program.program;
-    }
-  }
-  program_cache_mutex_.unlock();
-  throw std::runtime_error("Internal CLBlast error: Expected program in cache, but found none.");
-}
-
-// Queries the cache to see whether or not the compiled kernel is already there
-template <typename T>
-bool Routine<T>::ProgramIsInCache() const {
-  program_cache_mutex_.lock();
-  for (auto &cached_program: program_cache_) {
-    if (cached_program.MatchInCache(device_name_, precision_, routine_name_)) {
-      program_cache_mutex_.unlock();
-      return true;
-    }
-  }
-  program_cache_mutex_.unlock();
-  return false;
-}
-
-// =================================================================================================
-
 // Compiles the templated class
 template class Routine<float>;
 template class Routine<double>;