Refactor cell weights and durations to own file and allow for multiple metrics

include/customizer/cell_customizer.hpp

@@ -32,9 +32,9 @@ class CellCustomizer
 
     template <typename GraphT>
     void Customize(
-        const GraphT &graph, Heap &heap, partition::CellStorage &cells, LevelID level, CellID id)
+        const GraphT &graph, Heap &heap, const partition::CellStorage &cells, CellMetric &metric, LevelID level, CellID id)
     {
-        auto cell = cells.GetCell(level, id);
+        auto cell = cells.GetCell(metric, level, id);
         auto destinations = cell.GetDestinationNodes();
 
         // for each source do forward search
@@ -52,9 +52,9 @@ class CellCustomizer
                 const EdgeDuration duration = heap.GetData(node).duration;
 
                 if (level == 1)
-                    RelaxNode<true>(graph, cells, heap, level, node, weight, duration);
+                    RelaxNode<true>(graph, cells, metric, heap, level, node, weight, duration);
                 else
-                    RelaxNode<false>(graph, cells, heap, level, node, weight, duration);
+                    RelaxNode<false>(graph, cells, metric, heap, level, node, weight, duration);
 
                 destinations_set.erase(node);
             }
@@ -80,7 +80,7 @@ class CellCustomizer
         }
     }
 
-    template <typename GraphT> void Customize(const GraphT &graph, partition::CellStorage &cells)
+    template <typename GraphT> void Customize(const GraphT &graph, const partition::CellStorage &cells, CellMetric &metric)
     {
         Heap heap_exemplar(graph.GetNumberOfNodes());
         HeapPtr heaps(heap_exemplar);
@@ -92,7 +92,7 @@ class CellCustomizer
                                   auto &heap = heaps.local();
                                   for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                   {
-                                      Customize(graph, heap, cells, level, id);
+                                      Customize(graph, heap, cells, metric, level, id);
                                   }
                               });
         }
@@ -102,6 +102,7 @@ class CellCustomizer
     template <bool first_level, typename GraphT>
     void RelaxNode(const GraphT &graph,
                    const partition::CellStorage &cells,
+                   const CellMetric &metric,
                    Heap &heap,
                    LevelID level,
                    NodeID node,
@@ -123,7 +124,7 @@ class CellCustomizer
             {
                 // Relax sub-cell nodes
                 auto subcell_id = partition.GetCell(level - 1, node);
-                auto subcell = cells.GetCell(level - 1, subcell_id);
+                auto subcell = cells.GetCell(metric, level - 1, subcell_id);
                 auto subcell_destination = subcell.GetDestinationNodes().begin();
                 auto subcell_duration = subcell.GetOutDuration(node).begin();
                 for (auto subcell_weight : subcell.GetOutWeight(node))

include/customizer/cell_metric.hpp

@@ -0,0 +1,32 @@
+#ifndef OSRM_CUSTOMIZER_CELL_METRIC_HPP
+#define OSRM_CUSTOMIZER_CELL_METRIC_HPP
+
+#include "storage/io_fwd.hpp"
+#include "storage/shared_memory_ownership.hpp"
+
+#include "util/vector_view.hpp"
+#include "util/typedefs.hpp"
+
+namespace osrm
+{
+namespace customizer
+{
+namespace detail
+{
+// Encapsulated one metric to make it easily replacable in CelLStorage
+template <storage::Ownership Ownership> struct CellMetricImpl
+{
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+
+    Vector<EdgeWeight> weights;
+    Vector<EdgeDuration> durations;
+};
+}
+
+using CellMetric = detail::CellMetricImpl<storage::Ownership::Container>;
+using CellMetricView = detail::CellMetricImpl<storage::Ownership::View>;
+
+}
+}
+
+#endif

include/customizer/customizer_config.hpp

@@ -17,12 +17,9 @@ namespace customizer
 struct CustomizationConfig final : storage::IOConfig
 {
     CustomizationConfig()
-        : IOConfig(
-              {
-                  ".osrm",
-              },
-              {},
-              {".osrm.ebg", ".osrm.partition", ".osrm.cells", ".osrm.mldgr"}),
+        : IOConfig({".osrm.ebg", ".osrm.partition", ".osrm.cells"},
+                   {},
+                   {".osrm.cell_metrics", ".osrm.mldgr"}),
           requested_num_threads(0)
     {
     }

include/customizer/files.hpp

@@ -0,0 +1,59 @@
+#ifndef OSRM_CUSTOMIZER_FILES_HPP
+#define OSRM_CUSTOMIZER_FILES_HPP
+
+#include "customizer/serialization.hpp"
+
+#include "storage/io.hpp"
+
+#include "util/integer_range.hpp"
+
+namespace osrm
+{
+namespace customizer
+{
+namespace files
+{
+
+// reads .osrm.cell_metrics file
+template <typename CellMetricT>
+inline void readCellMetrics(const boost::filesystem::path &path, std::vector<CellMetricT> &metrics)
+{
+    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
+                      std::is_same<CellMetric, CellMetricT>::value,
+                  "");
+
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    auto num_metrics = reader.ReadElementCount64();
+    metrics.resize(num_metrics);
+
+    for (auto& metric : metrics)
+    {
+        serialization::read(reader, metric);
+    }
+}
+
+// writes .osrm.cell_metrics file
+template <typename CellMetricT>
+inline void writeCellMetrics(const boost::filesystem::path &path, const std::vector<CellMetricT> &metrics)
+{
+    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
+                      std::is_same<CellMetric, CellMetricT>::value,
+                  "");
+
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    writer.WriteElementCount64(metrics.size());
+    for (const auto& metric : metrics)
+    {
+        serialization::write(writer, metric);
+    }
+}
+
+}
+}
+}
+
+#endif

include/customizer/serialization.hpp

@@ -0,0 +1,34 @@
+#ifndef OSRM_CUSTOMIZER_SERIALIZATION_HPP
+#define OSRM_CUSTOMIZER_SERIALIZATION_HPP
+
+#include "partition/cell_storage.hpp"
+
+#include "storage/io.hpp"
+#include "storage/serialization.hpp"
+#include "storage/shared_memory_ownership.hpp"
+
+namespace osrm
+{
+namespace customizer
+{
+namespace serialization
+{
+
+template <storage::Ownership Ownership>
+inline void read(storage::io::FileReader &reader, detail::CellMetricImpl<Ownership> &metric)
+{
+    storage::serialization::read(reader, metric.weights);
+    storage::serialization::read(reader, metric.durations);
+}
+
+template <storage::Ownership Ownership>
+inline void write(storage::io::FileWriter &writer, const detail::CellMetricImpl<Ownership> &metric)
+{
+    storage::serialization::write(writer, metric.weights);
+    storage::serialization::write(writer, metric.durations);
+}
+}
+}
+}
+
+#endif