From e4a4a8d91a6bb65f6b6931e2e0a9c1041bb404c0 Mon Sep 17 00:00:00 2001
From: Kajari Ghosh <ghoshkaj@gmail.com>
Date: Fri, 20 Apr 2018 08:50:59 -0400
Subject: [PATCH] fixes and a rebase

---
 include/engine/unpacking_cache.hpp | 71 ++++++++++++------------------
 1 file changed, 28 insertions(+), 43 deletions(-)

diff --git a/include/engine/unpacking_cache.hpp b/include/engine/unpacking_cache.hpp
index 487588f18..c348a742f 100644
--- a/include/engine/unpacking_cache.hpp
+++ b/include/engine/unpacking_cache.hpp
@@ -7,36 +7,23 @@
 #include "../../third_party/compute_detail/lru_cache.hpp"
 #include "util/typedefs.hpp"
 
+
+// sizeof size_t: 8
+// sizeof unsigned: 4
+// sizeof unchar: 1
+// sizeof uint32: 4
 namespace osrm
 {
 namespace engine
 {
 typedef unsigned char ExcludeIndex;
 typedef unsigned Timestamp;
-typedef std::tuple<NodeID, NodeID, ExcludeIndex> Key;
-typedef std::size_t HashedKey;
-
-struct HashKey
-{
-    std::size_t operator()(Key const &key) const noexcept
-    {
-        std::size_t h1 = std::hash<NodeID>{}(std::get<0>(key));
-        std::size_t h2 = std::hash<NodeID>{}(std::get<1>(key));
-        std::size_t h3 = std::hash<ExcludeIndex>{}(std::get<2>(key));
-
-        std::size_t seed = 0;
-        boost::hash_combine(seed, h1);
-        boost::hash_combine(seed, h2);
-        boost::hash_combine(seed, h3);
-
-        return seed;
-    }
-};
+typedef std::tuple<NodeID, NodeID, unsigned char> Key;
 
 class UnpackingCache
 {
   private:
-    boost::compute::detail::lru_cache<HashedKey, EdgeDuration> m_cache;
+    boost::compute::detail::lru_cache<std::tuple<NodeID, NodeID, unsigned char>, EdgeDuration> m_cache;
     unsigned m_current_data_timestamp = 0;
 
   public:
@@ -45,27 +32,28 @@ class UnpackingCache
     // https://github.com/Project-OSRM/osrm-backend/issues/4798#issue-288608332)
 
     // LRU CACHE IMPLEMENTATION HAS THESE TWO STORAGE CONTAINERS
-    // map: n * tuple_hash + n * EdgeDuration
-    //    = n * std::size_t + n * std::int32_t
-    //    = n * 8 bytes + n * 4 bytes
-    //    = n * 12 bytes
-    // list: n * HashedKey
-    //     = n * std::size_t
-    //     = n * 8 bytes
-    // Total = n * 20 bytes
+    // Key is of size: std::uint32_t * 2 + (unsigned char) * 1 + unsigned * 1
+    //                = 4 * 2 + 1 * 1 + 4 * 1 =  21
+    // map: n * Key + n * EdgeDuration
+    //    = n * 21 bytes + n * std::int32_t
+    //    = n * 21 bytes + n * 4 bytes
+    //    = n * 25 bytes
+    // list: n * Key
+    //     = n * 21 bytes
+    // Total = n * (25 + 21) = n * 46 bytes
     // Total cache size: 500 mb = 500 * 1024 *1024 bytes = 524288000 bytes
 
     // THREAD LOCAL STORAGE
-    // Number of lines we need  = 524288000 / 20 / number of threads = 26214400 / number of threads
-    // 16 threads: 26214400 / 16 = 1638400
-    // 8 threads: 26214400 / 8 = 3276800
-    // 4 threads: 26214400 / 4 = 6553600
-    // 2 threads: 26214400 / 2 = 13107200
+    // Number of lines we need  = 524288000 / 46 / number of threads = 11397565 / number of threads
+    // 16 threads: 11397565 / 16 = 712347
+    // 8 threads: 11397565 / 8 = 1424695
+    // 4 threads: 11397565 / 4 = 2849391
+    // 2 threads: 11397565 / 2 = 5698782
 
     // SHARED STORAGE CACHE
     // Number of lines we need for shared storage cache = 524288000 / 20 = 26214400
 
-    UnpackingCache(unsigned timestamp) : m_cache(13107200), m_current_data_timestamp(timestamp){};
+    UnpackingCache(unsigned timestamp) : m_cache(712347), m_current_data_timestamp(timestamp){};
 
     UnpackingCache(std::size_t cache_size, unsigned timestamp)
         : m_cache(cache_size), m_current_data_timestamp(timestamp){};
@@ -79,22 +67,19 @@ class UnpackingCache
         }
     }
 
-    bool IsEdgeInCache(Key edge)
+    bool IsEdgeInCache(std::tuple<NodeID, NodeID, unsigned char> edge)
     {
-        HashedKey hashed_edge = HashKey{}(edge);
-        return m_cache.contains(hashed_edge);
+        return m_cache.contains(edge);
     }
 
-    void AddEdge(Key edge, EdgeDuration duration)
+    void AddEdge(std::tuple<NodeID, NodeID, unsigned char> edge, EdgeDuration duration)
     {
-        HashedKey hashed_edge = HashKey{}(edge);
-        m_cache.insert(hashed_edge, duration);
+        m_cache.insert(edge, duration);
     }
 
-    EdgeDuration GetDuration(Key edge)
+    EdgeDuration GetDuration(std::tuple<NodeID, NodeID, unsigned char> edge)
     {
-        HashedKey hashed_edge = HashKey{}(edge);
-        boost::optional<EdgeDuration> duration = m_cache.get(hashed_edge);
+        boost::optional<EdgeDuration> duration = m_cache.get(edge);
         return duration ? *duration : MAXIMAL_EDGE_DURATION;
     }
 };