Renumber nodes after running osrm-partition

The new numbering uses the partition information
to sort border nodes first to compactify storages
that need access indexed by border node ID.

We also get an optimized cache performance for free
sincr we can also recursively sort the nodes by cell ID.

This implements issue #3779.

include/extractor/edge_based_edge.hpp

@@ -13,23 +13,6 @@ namespace extractor
 struct EdgeBasedEdge
 {
   public:
-    EdgeBasedEdge();
-
-    template <class EdgeT> explicit EdgeBasedEdge(const EdgeT &other);
-
-    EdgeBasedEdge(const NodeID source,
-                  const NodeID target,
-                  const NodeID edge_id,
-                  const EdgeWeight weight,
-                  const EdgeWeight duration,
-                  const bool forward,
-                  const bool backward);
-
-    bool operator<(const EdgeBasedEdge &other) const;
-
-    NodeID source;
-    NodeID target;
-
     struct EdgeData
     {
         EdgeData() : turn_id(0), weight(0), duration(0), forward(false), backward(false) {}
@@ -51,7 +34,24 @@ struct EdgeBasedEdge
         std::uint32_t backward : 1;
 
         auto is_unidirectional() const { return !forward || !backward; }
-    } data;
+    };
+
+    EdgeBasedEdge();
+    template <class EdgeT> explicit EdgeBasedEdge(const EdgeT &other);
+    EdgeBasedEdge(const NodeID source,
+                  const NodeID target,
+                  const NodeID edge_id,
+                  const EdgeWeight weight,
+                  const EdgeWeight duration,
+                  const bool forward,
+                  const bool backward);
+    EdgeBasedEdge(const NodeID source, const NodeID target, const EdgeBasedEdge::EdgeData &data);
+
+    bool operator<(const EdgeBasedEdge &other) const;
+
+    NodeID source;
+    NodeID target;
+    EdgeData data;
 };
 static_assert(sizeof(extractor::EdgeBasedEdge) == 20,
               "Size of extractor::EdgeBasedEdge type is "
@@ -73,6 +73,13 @@ inline EdgeBasedEdge::EdgeBasedEdge(const NodeID source,
 {
 }
 
+inline EdgeBasedEdge::EdgeBasedEdge(const NodeID source,
+                                    const NodeID target,
+                                    const EdgeBasedEdge::EdgeData &data)
+    : source(source), target(target), data{data}
+{
+}
+
 inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
 {
     const auto unidirectional = data.is_unidirectional();

include/extractor/extractor.hpp

@@ -86,10 +86,6 @@ class Extractor
                        std::vector<util::Coordinate> &coordinates,
                        extractor::PackedOSMIDs &osm_node_ids);
 
-    void WriteEdgeBasedGraph(const std::string &output_file_filename,
-                             const EdgeID max_edge_id,
-                             util::DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list);
-
     void WriteIntersectionClassificationData(
         const std::string &output_file_name,
         const std::vector<std::uint32_t> &node_based_intersection_classes,

include/extractor/files.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_EXTRACTOR_FILES_HPP
 #define OSRM_EXTRACTOR_FILES_HPP
 
+#include "extractor/edge_based_edge.hpp"
 #include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/node_data_container.hpp"
 #include "extractor/serialization.hpp"
@@ -19,6 +20,32 @@ namespace extractor
 namespace files
 {
 
+template <typename EdgeBasedEdgeVector>
+void writeEdgeBasedGraph(const boost::filesystem::path &path,
+                         EdgeID const max_edge_id,
+                         const EdgeBasedEdgeVector &edge_based_edge_list)
+{
+    static_assert(std::is_same<typename EdgeBasedEdgeVector::value_type, EdgeBasedEdge>::value, "");
+
+    storage::io::FileWriter writer(path, storage::io::FileWriter::GenerateFingerprint);
+
+    writer.WriteElementCount64(max_edge_id);
+    storage::serialization::write(writer, edge_based_edge_list);
+}
+
+template <typename EdgeBasedEdgeVector>
+void readEdgeBasedGraph(const boost::filesystem::path &path,
+                        EdgeID &max_edge_id,
+                        EdgeBasedEdgeVector &edge_based_edge_list)
+{
+    static_assert(std::is_same<typename EdgeBasedEdgeVector::value_type, EdgeBasedEdge>::value, "");
+
+    storage::io::FileReader reader(path, storage::io::FileReader::VerifyFingerprint);
+
+    max_edge_id = reader.ReadElementCount64();
+    storage::serialization::read(reader, edge_based_edge_list);
+}
+
 // reads .osrm.nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
 inline void readNodes(const boost::filesystem::path &path,

include/extractor/node_data_container.hpp

@@ -1,9 +1,12 @@
 #ifndef OSRM_EXTRACTOR_NODE_DATA_CONTAINER_HPP
 #define OSRM_EXTRACTOR_NODE_DATA_CONTAINER_HPP
 
+#include "extractor/travel_mode.hpp"
+
 #include "storage/io_fwd.hpp"
 #include "storage/shared_memory_ownership.hpp"
 
+#include "util/permutation.hpp"
 #include "util/typedefs.hpp"
 #include "util/vector_view.hpp"
 
@@ -81,6 +84,15 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
     serialization::write<Ownership>(storage::io::FileWriter &writer,
                                     const EdgeBasedNodeDataContainerImpl &ebn_data_container);
 
+    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    void Renumber(const std::vector<std::uint32_t> &permutation)
+    {
+        util::inplacePermutation(geometry_ids.begin(), geometry_ids.end(), permutation);
+        util::inplacePermutation(name_ids.begin(), name_ids.end(), permutation);
+        util::inplacePermutation(component_ids.begin(), component_ids.end(), permutation);
+        util::inplacePermutation(travel_modes.begin(), travel_modes.end(), permutation);
+    }
+
   private:
     Vector<GeometryID> geometry_ids;
     Vector<NameID> name_ids;