Merge pull request #7 from paulapistrila3/main

Open Source Release for Legacy ON

Author: fistoc

CMakeLists.txt

@@ -21,10 +21,32 @@ option(VPUNN_ENABLE_VECTOR_INSTRUCTIONS "use vector instructions" ON)
 
 option(VPUNN_BUILD_SHARED_LIB "build shared library" ON)
 option(VPUNN_BUILD_EXAMPLES "build examples" ON)
+option(VPUNN_BUILD_APPS "build apps" OFF)
 option(VPUNN_BUILD_TESTS "build tests" ON)
 option(VPUNN_ENABLE_LOGGING "enable logging" OFF)
 option(ENABLE_PYTHON_BINDING "Build the python bindings" OFF)
 option(GENERATE_PYTHON_BINDING "Generate the python bindings code" OFF)
+
+option(VPUNN_OPT_LEGACY_ZTILING "Use legacy ZTiling mechanism" ON)
+if(VPUNN_OPT_LEGACY_ZTILING)
+ add_compile_definitions(VPUNN_OPT_LEGACY_ZTILING)
+ message(STATUS "-- Enable Legacy ZTiling (intratile) ")
+endif()
+
+#
+#option(VPUNN_OPT_LEGACY_DMA_TH_4 "Use legacy Theoretical DMA for Gen4" OFF)
+#if(VPUNN_OPT_LEGACY_DMA_TH_4)
+# add_compile_definitions(VPUNN_OPT_LEGACY_DMA_TH_4)
+# message(STATUS "-- Enable Legacy Gen4 DMA Theoretical")
+#endif()
+#
+#option(VPUNN_OPT_LEGACY_DMA_TH_5 "Use legacy Theoretical DMA for Gen5++" OFF)
+#if(VPUNN_OPT_LEGACY_DMA_TH_5)
+# add_compile_definitions(VPUNN_OPT_LEGACY_DMA_TH_5)
+# message(STATUS "-- Enable Legacy Gen5++ DMA Theoretical")
+#endif()
+
+
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(EXTERNAL_INSTALL_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/external)
 set(CMAKE_VPUNN_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
@@ -94,8 +116,10 @@ if(VPUNN_BUILD_EXAMPLES)
     add_subdirectory(example)
 endif()
 
-# not yet 
-# add_subdirectory(apps/data_augmenter)
+if(VPUNN_BUILD_APPS)
+    # add_subdirectory(apps/data_augmenter)
+    add_subdirectory(apps/cache_app)
+endif()
 
 if(VPUNN_BUILD_TESTS)
 	#enable_testing()

include/core/cache.h

@@ -15,32 +15,44 @@
 #include <stdexcept>
 #include <vector>
 
-#include "persistent_cache.h"
+#include "core/utils.h"
+#include "core/persistent_cache.h"
 
 namespace VPUNN {
 
 /**
  * @brief a workload cache using LRU (least recent used) replacement policy
- * @tparam T workload datatype
+ * @tparam K is the Key type
+ * @tparam V is the Value type
  */
-template <class T>
+template <typename K, typename V>
 class LRUCache {
 private:
-    typedef std::list<std::pair<std::vector<T>, T>> List;
-    typedef typename List::iterator List_Iter;
-    typedef std::map<std::vector<T>, List_Iter> Map;
-    typedef typename Map::iterator Map_Iter;
-    List workloads;
-    Map m_table;
-    size_t max_size, size;
+    typedef std::list<std::pair<K, V>> List;
+    typedef typename List::const_iterator List_Iter_cnst;
 
-    /// loaded from file, must be loaded from a file with the same descriptor signature
-    const FixedCache<T> deserialized_table;
+    typedef std::map<K, List_Iter_cnst> Map;
+    typedef typename Map::const_iterator Map_Iter_cnst;
+
+    List workloads;  ///< list with first being the most recently used key
+    Map m_table;     ///< table for fast searching of keys  (contains pointers to list objects)
+    const size_t max_size;
+    size_t size{0};
 
+    /// loaded from file, must be loaded from a file with the same descriptor signature
+    /// @note this is a draft implementation
+    /// This datatype knows it is a float Value and uint32 key. this beats the K, V template
+    const FixedCache deserialized_table;  // maybe send it as template, OR reuse V and hashable K?
+
+    /// @brief Decide which cache file to load  (DRAFT
+    /// @param filenamePrio1 the first filename to try to load. must be a valid name and extension.Must be empty to go
+    /// and try to select the second option
+    /// @param loadThisCSVIfPairedCacheExists the second filename to try to load if the first does not exist. Takes only
+    /// the name, and replaces the extension with the default extension for cache. Is selected only if exists on disk!
     static std::string decideCacheFilename(const std::string& filenamePrio1,
                                            const std::string& loadThisCSVIfPairedCacheExists) {
         auto selected_filename{filenamePrio1};  // can be empty or nonexistent
-        if (filenamePrio1.empty()) {            // prio 1 dropped
+        if (filenamePrio1.empty()) {            // prio 1 dropped, does not exist
             std::filesystem::path pairC{loadThisCSVIfPairedCacheExists};
             pairC.replace_extension(".cache_bin");
             if (!loadThisCSVIfPairedCacheExists.empty() && std::filesystem::exists(pairC)) {
@@ -56,17 +68,14 @@ class LRUCache {
      *
      * @param max_size the maximum size of the LRUCache
      */
-    explicit LRUCache(size_t max_size, size_t interface_size = 0, const std::string& filename = "",
-                      const std::string& loadIfPairedCacheExists = "")
-            : max_size(max_size),
-              size(0),
-              deserialized_table{interface_size, decideCacheFilename(filename, loadIfPairedCacheExists)} {
+    explicit LRUCache(size_t max_size, const std::string& filename = "",
+                      const std::string& prio2_loadIfPairedCacheExists = "")
+            : max_size(max_size), deserialized_table{decideCacheFilename(filename, prio2_loadIfPairedCacheExists)} {
     }
 
     // const char* model_data, size_t model_data_length, bool copy_model_data
-    explicit LRUCache(size_t max_size, size_t interface_size = 0, const char* file_data = nullptr,
-                      size_t file_data_length = 0)
-            : max_size(max_size), size(0), deserialized_table{interface_size, file_data, file_data_length} {
+    explicit LRUCache(size_t max_size, const char* file_data = nullptr, size_t file_data_length = 0)
+            : max_size(max_size), deserialized_table{file_data, file_data_length} {
     }
 
     /**
@@ -75,28 +84,31 @@ class LRUCache {
      * @param wl the workload descriptor (key)
      * @param value the workload value
      */
-    void add(const std::vector<T>& wl, const T& value) {
-        // If max_size == 0 we effectively disable the cache
+    void add(const K& wl, const V& value) {
+        // If max_size == 0 we effectively disable the cache!
         if (max_size == 0)
             return;
 
         // Check if the workload is already in the deserialized table
-        if (deserialized_table.contains(wl))
-            return;
+        {
+            if constexpr (has_hash_v<K>) {
+                if (deserialized_table.contains(wl.hash()))
+                    return;
+            } else {
+                if (deserialized_table.contains(NNDescriptor<float>(wl).hash()))
+                    return;
+            }
+        }
 
         // Insert items in the list and map
         workloads.push_front({wl, value});
-        auto it = workloads.begin();
-        m_table.insert({wl, it});
+        m_table.insert({wl, workloads.cbegin()});
         size++;
 
+        // delete the oldest ones that occupy more space than allowed
         while (size > max_size) {
-            // Get the last element.
-            auto last_item = workloads.end();
-            --last_item;
-
-            // Remove the last element
-            remove(last_item->first);
+            const auto& last_item{workloads.back()};
+            remove(last_item.first);  // key is first in pair
         }
     }
 
@@ -106,22 +118,17 @@ class LRUCache {
      *
      * @param wl the workload descriptor
      */
-    void remove(std::vector<T>& wl) {
-        // Remove the workload from the cache
-        auto it = m_table.find(wl);
+    void remove(const K& wl) {
+        Map_Iter_cnst it = m_table.find(wl);
 
-        if (it != m_table.end()) {
-            // Erase the element from the map
-            m_table.erase(it->first);
+        if (it != m_table.cend()) {
+            m_table.erase(it->first);  // key is first
         } else {
             throw std::out_of_range("VPUNN Cache out of range");
         }
 
-        // Remove the last element from the list
-        workloads.pop_back();
-
-        // Update the size
-        size--;
+        workloads.pop_back();  // Remove the last element from the list
+        size--;                // Update the size
     }
 
 public:
@@ -131,20 +138,28 @@ class LRUCache {
      * @param wl the workload descriptor
      * @return T* a pointer to the workload value stored in the cache, or nullptr if not available
      */
-    const T* get(const std::vector<T>& wl) {
+    const V* get(const K& wl) {
         // Check if the workload is in the deserialized table
-        const T* elementInPreloadedCache{deserialized_table.get_pointer(wl)};
-        if (elementInPreloadedCache) {
-            return elementInPreloadedCache;  // ret the pointer to the element in the preloaded cache
+        {
+            uint32_t wlhash{0};
+            if constexpr (has_hash_v<K>) {
+                wlhash = wl.hash();
+            } else {
+                wlhash = NNDescriptor<float>(wl).hash();
+            }
+
+            const V* elementInPreloadedCache{deserialized_table.get_pointer(wlhash)};
+            if (elementInPreloadedCache) {
+                return elementInPreloadedCache;  // ret the pointer to the element in the preloaded cache
+            }
         }
 
         // Check if the workload is in the main table
-        Map_Iter it = m_table.find(wl);
-        if (it != m_table.end()) {
+        Map_Iter_cnst it = m_table.find(wl);
+        if (it != m_table.cend()) {
             // Move the workload to the beginning of the list
-            workloads.splice(workloads.begin(), workloads, it->second);
-            // Return the value
-            return &(it->second->second);
+            workloads.splice(workloads.cbegin(), workloads, it->second);
+            return &(it->second->second);  // second is the list iterator
         } else {
             return nullptr;
         }

include/core/cache_descriptors.h

@@ -10,6 +10,9 @@
 #ifndef VPUNN_CACHE_DESCRIPTORS
 #define VPUNN_CACHE_DESCRIPTORS
 
+// OBSOLETE/TENTATIVE DEVELOPMENT NOW
+
+
 #include <list>
 #include <map>
 #include <stdexcept>