Change routing index temporary store container to unordered_map

indexer/features_offsets_table.cpp

@@ -13,7 +13,7 @@
 
 namespace feature
 {
-  void FeaturesOffsetsTable::Builder::PushOffset(uint64_t const offset)
+  void FeaturesOffsetsTable::Builder::PushOffset(uint32_t const offset)
   {
     ASSERT(m_offsets.empty() || m_offsets.back() < offset, ());
     m_offsets.push_back(offset);
@@ -33,13 +33,13 @@ namespace feature
   // static
   unique_ptr<FeaturesOffsetsTable> FeaturesOffsetsTable::Build(Builder & builder)
   {
-    vector<uint64_t> const & offsets = builder.m_offsets;
+    vector<uint32_t> const & offsets = builder.m_offsets;
 
-    uint64_t const numOffsets = offsets.size();
-    uint64_t const maxOffset = offsets.empty() ? 0 : offsets.back();
+    size_t const numOffsets = offsets.size();
+    uint32_t const maxOffset = offsets.empty() ? 0 : offsets.back();
 
     succinct::elias_fano::elias_fano_builder elias_fano_builder(maxOffset, numOffsets);
-    for (uint64_t offset : offsets)
+    for (uint32_t offset : offsets)
       elias_fano_builder.push_back(offset);
 
     return unique_ptr<FeaturesOffsetsTable>(new FeaturesOffsetsTable(elias_fano_builder));
@@ -88,13 +88,13 @@ namespace feature
     my::RenameFileX(fileNameTmp, fileName);
   }
 
-  uint64_t FeaturesOffsetsTable::GetFeatureOffset(size_t index) const
+  uint32_t FeaturesOffsetsTable::GetFeatureOffset(size_t index) const
   {
     ASSERT_LESS(index, size(), ("Index out of bounds", index, size()));
     return m_table.select(index);
   }
 
-  size_t FeaturesOffsetsTable::GetFeatureIndexbyOffset(uint64_t offset) const
+  size_t FeaturesOffsetsTable::GetFeatureIndexbyOffset(uint32_t offset) const
   {
     ASSERT_GREATER(size(), 0, ("We must not ask empty table"));
     ASSERT_LESS_OR_EQUAL(offset, m_table.select(size() - 1), ("Offset out of bounds", offset,

indexer/features_offsets_table.hpp

@@ -27,18 +27,18 @@ namespace feature
       /// greater than all previously added offsets.
       ///
       /// \param offset a feature's offset in a MWM file
-      void PushOffset(uint64_t offset);
+      void PushOffset(uint32_t offset);
 
       /// \return number of already accumulated offsets
-      inline uint64_t size() const
+      inline size_t size() const
       {
-        return static_cast<uint64_t>(m_offsets.size());
+        return m_offsets.size();
       }
 
     private:
       friend class FeaturesOffsetsTable;
 
-      vector<uint64_t> m_offsets;
+      vector<uint32_t> m_offsets;
     };
 
     /// Builds FeaturesOffsetsTable from the strictly increasing
@@ -83,22 +83,22 @@ namespace feature
 
     /// \param index index of a feature
     /// \return offset a feature
-    uint64_t GetFeatureOffset(size_t index) const;
+    uint32_t GetFeatureOffset(size_t index) const;
 
     /// \param offset offset of a feature
     /// \return index of a feature
-    size_t GetFeatureIndexbyOffset(uint64_t offset) const;
+    size_t GetFeatureIndexbyOffset(uint32_t offset) const;
 
     /// \return number of features offsets in a table.
-    inline uint64_t size() const
+    inline size_t size() const
     {
-      return m_table.num_ones();
+      return static_cast<size_t>(m_table.num_ones());
     }
 
     /// \return byte size of a table, may be slightly different from a
     ///         real byte size in memory or on disk due to alignment, but
     ///         can be used in benchmarks, logging, etc.
-    inline uint64_t byte_size()
+    inline size_t byte_size()
     {
       return succinct::mapper::size_of(m_table);
     }

routing/osrm2feature_map.cpp

@@ -395,7 +395,7 @@ void OsrmFtSegBackwardIndex::Construct(OsrmFtSegMapping & mapping, const uint32_
   mapping.Map(routingFile);
 
   // Generate temporary index to speedup processing
-  unordered_multimap<uint64_t, uint32_t> temporaryBackwardIndex;
+  unordered_map<uint32_t, TNodesList> temporaryBackwardIndex;
   for (uint32_t i = 0; i < maxNodeId; ++i)
   {
     auto indexes = mapping.GetSegmentsRange(i);
@@ -403,7 +403,7 @@ void OsrmFtSegBackwardIndex::Construct(OsrmFtSegMapping & mapping, const uint32_
     {
       OsrmMappingTypes::FtSeg seg;
       mapping.GetSegmentByIndex(indexes.first, seg);
-      temporaryBackwardIndex.insert(make_pair(seg.m_fid, i));
+      temporaryBackwardIndex[seg.m_fid].push_back(i);;
     }
   }
 
@@ -412,26 +412,20 @@ void OsrmFtSegBackwardIndex::Construct(OsrmFtSegMapping & mapping, const uint32_
 
   // Create final index
   vector<bool> inIndex(m_table->size(), false);
-  vector<TNodesList> nodeIds;
+  m_nodeIds.reserve(temporaryBackwardIndex.size());
 
   for (size_t i = 0; i < m_table->size(); ++i)
   {
-    uint64_t fid = m_table->GetFeatureOffset(i);
-    auto it = temporaryBackwardIndex.equal_range(fid);
-    if (it.first != it.second)
+    uint32_t fid = m_table->GetFeatureOffset(i);
+    auto it = temporaryBackwardIndex.find(fid);
+    if (it != temporaryBackwardIndex.end())
     {
       inIndex[i] = true;
-      TNodesList nodesList(distance(it.first, it.second));
-      for (auto & node: nodesList)
-        node = (it.first++)->second;
-      nodeIds.emplace_back(nodesList);
+      m_nodeIds.emplace_back(move(it->second));
     }
-    // Cleaning index because we have no free space on old devices.
-    temporaryBackwardIndex.erase(fid);
   }
 
   // Pack and save index
-  nodeIds.swap(m_nodeIds);
   succinct::rs_bit_vector(inIndex).swap(m_rankIndex);
 
   LOG(LINFO, ("Writing section to data file", routingName));