IT WORKS

include/util/packed_vector.hpp

@@ -15,12 +15,22 @@ const constexpr std::size_t BITSIZE = 33;
 const constexpr std::size_t ELEMSIZE = 64;
 const constexpr std::size_t PACKSIZE = BITSIZE * ELEMSIZE;
 
+std::size_t PackedVectorSize(std::size_t elements)
+{
+    return ceil(float(elements) / ELEMSIZE) * BITSIZE;
+};
+
+std::size_t PackedVectorCapacity(std::size_t vec_size)
+{
+    return floor(float(vec_size) / BITSIZE) * ELEMSIZE;
+}
+
 /**
  * Since OSM node IDs are (at the time of writing) not quite yet overflowing 32 bits, and
  * will predictably be containable within 33 bits for a long time, the following packs
  * 64-bit OSM IDs as 33-bit numbers within a 64-bit vector.
  */
-class PackedVector
+template <bool UseSharedMemory> class PackedVector
 {
   public:
     PackedVector() = default;
@@ -38,24 +48,27 @@ class PackedVector
         {
             // insert ID at the left side of this element
             std::uint64_t at_left = node_id << (ELEMSIZE - BITSIZE);
-            vec.push_back(at_left);
+
+            add_last_elem(at_left);
         }
         else if (available >= BITSIZE)
         {
             // insert ID somewhere in the middle of this element; ID can be contained
             // entirely within one element
             const std::uint64_t shifted = node_id << (available - BITSIZE);
-            vec.back() = vec.back() | shifted;
+
+            replace_last_elem(vec_back() | shifted);
         }
         else
         {
             // ID will be split between the end of this element and the beginning
             // of the next element
             const std::uint64_t left = node_id >> (BITSIZE - available);
-            vec.back() = vec.back() | left;
 
             std::uint64_t right = node_id << (ELEMSIZE - (BITSIZE - available));
-            vec.push_back(right);
+
+            replace_last_elem(vec_back() | left);
+            add_last_elem(right);
         }
 
         num_elements++;
@@ -74,7 +87,7 @@ class PackedVector
                                   trunc((pack_index - back_half) / 2);
 
         BOOST_ASSERT(index < vec.size());
-        const std::uint64_t elem = vec.at(index);
+        const std::uint64_t elem = static_cast<std::uint64_t>(vec.at(index));
 
         if (left_index == 0)
         {
@@ -95,7 +108,7 @@ class PackedVector
             const std::uint64_t left_side = (elem & left_mask) << (BITSIZE - left_index);
 
             BOOST_ASSERT(index < vec.size() - 1);
-            const std::uint64_t next_elem = vec.at(index + 1);
+            const std::uint64_t next_elem = static_cast<std::uint64_t>(vec.at(index + 1));
 
             const std::uint64_t right_side = next_elem >> (ELEMSIZE - (BITSIZE - left_index));
             return static_cast<OSMNodeID>(left_side | right_side);
@@ -107,19 +120,73 @@ class PackedVector
         return num_elements;
     }
 
-    void reserve(std::size_t capacity)
+    template <bool enabled = UseSharedMemory>
+    void reserve(typename std::enable_if<!enabled, std::size_t>::type capacity)
     {
-        vec.reserve(ceil(float(capacity) / ELEMSIZE) * BITSIZE);
+        vec.reserve(PackedVectorSize(capacity));
+    }
+
+    template <bool enabled = UseSharedMemory>
+    void reset(typename std::enable_if<enabled, OSMNodeID>::type *ptr, typename std::enable_if<enabled, std::size_t>::type size)
+    {
+        vec.reset(reinterpret_cast<std::uint64_t *>(ptr), size);
+    }
+
+    template <bool enabled = UseSharedMemory>
+    void set_number_of_entries(typename std::enable_if<enabled, std::size_t>::type count)
+    {
+        num_elements = count;
     }
 
     std::size_t capacity() const
     {
-        return floor(float(vec.capacity()) / BITSIZE) * ELEMSIZE;
+        return PackedVectorCapacity(vec.capacity());
     }
 
   private:
-    std::vector<std::uint64_t> vec;
+
+    typename util::ShM<std::uint64_t, UseSharedMemory>::vector vec;
+
     std::size_t num_elements = 0;
+
+    signed cursor = -1;
+
+    template <bool enabled = UseSharedMemory>
+    void replace_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
+    {
+        vec[cursor] = last_elem;
+    }
+
+    template <bool enabled = UseSharedMemory>
+    void replace_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
+    {
+        vec.back() = last_elem;
+    }
+
+    template <bool enabled = UseSharedMemory>
+    void add_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
+    {
+        vec[cursor + 1] = last_elem;
+        cursor++;
+    }
+
+    template <bool enabled = UseSharedMemory>
+    void add_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
+    {
+        vec.push_back(last_elem);
+    }
+
+    template <bool enabled = UseSharedMemory>
+    std::uint64_t vec_back(typename std::enable_if<enabled>::type* = nullptr)
+    {
+        return vec[cursor];
+    }
+
+    template <bool enabled = UseSharedMemory>
+    std::uint64_t vec_back(typename std::enable_if<!enabled>::type* = nullptr)
+    {
+        return vec.back();
+    }
 };
 }
 }

include/util/shared_memory_vector_wrapper.hpp

@@ -3,6 +3,8 @@
 
 #include <boost/assert.hpp>
 
+#include "util/simple_logger.hpp"
+
 #include <cstddef>
 
 #include <algorithm>