Prep alpha release for testing.

CHANGELOG.md

@@ -2,9 +2,12 @@
   - Changes from 5.18.0:
     - Optimizations:
       - CHANGED: Map matching is now almost twice as fast. [#5060](https://github.com/Project-OSRM/osrm-backend/pull/5060)
+      - CHANGED: Use Grisu2 for serializing floating point numbers. [#5188](https://github.com/Project-OSRM/osrm-backend/pull/5188)
     - Bugfixes:
       - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
       - FIXED: negative distances in table plugin annotation [#5106](https://github.com/Project-OSRM/osrm-backend/issues/5106)
+    - Misc:
+      - CHANGED: Support up to 512 named shared memory regions [#5185](https://github.com/Project-OSRM/osrm-backend/pull/5185)
 
 # 5.18.0
   - Changes from 5.17.0:

include/contractor/contractor_config.hpp

@@ -72,8 +72,14 @@ struct ContractorConfig final : storage::IOConfig
     // The remaining vertices form the core of the hierarchy
     //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
     double core_factor;
+
+    // Whether to store distances for CH edges in addition to duration/weight
+    // Defaults to false.  Setting to true will require more storage/memory,
+    // but avoids the need for path unpacking to learn the distance of a CH
+    // route (useful for faster distance results in table queries)
+    bool cache_distances;
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // EXTRACTOR_OPTIONS_HPP

include/contractor/contractor_graph.hpp

@@ -12,23 +12,26 @@ namespace contractor
 struct ContractorEdgeData
 {
     ContractorEdgeData()
-        : weight(0), duration(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0)
+        : weight(0), duration(0), distance(0), id(0), originalEdges(0), shortcut(0), forward(0),
+          backward(0)
     {
     }
     ContractorEdgeData(EdgeWeight weight,
                        EdgeWeight duration,
+                       EdgeDistance distance,
                        unsigned original_edges,
                        unsigned id,
                        bool shortcut,
                        bool forward,
                        bool backward)
-        : weight(weight), duration(duration), id(id),
+        : weight(weight), duration(duration), distance(distance), id(id),
           originalEdges(std::min((1u << 29) - 1u, original_edges)), shortcut(shortcut),
           forward(forward), backward(backward)
     {
     }
     EdgeWeight weight;
     EdgeWeight duration;
+    EdgeDistance distance;
     unsigned id;
     unsigned originalEdges : 29;
     bool shortcut : 1;

include/contractor/graph_contractor_adaptors.hpp

@@ -41,6 +41,7 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                            input_edge.target,
                            std::max(input_edge.data.weight, 1),
                            input_edge.data.duration,
+                           input_edge.data.distance,
                            1,
                            input_edge.data.turn_id,
                            false,
@@ -51,6 +52,7 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                            input_edge.source,
                            std::max(input_edge.data.weight, 1),
                            input_edge.data.duration,
+                           input_edge.data.distance,
                            1,
                            input_edge.data.turn_id,
                            false,
@@ -82,6 +84,7 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
         forward_edge.data.originalEdges = reverse_edge.data.originalEdges = 1;
         forward_edge.data.weight = reverse_edge.data.weight = INVALID_EDGE_WEIGHT;
         forward_edge.data.duration = reverse_edge.data.duration = MAXIMAL_EDGE_DURATION;
+        forward_edge.data.distance = reverse_edge.data.distance = MAXIMAL_EDGE_DISTANCE;
         // remove parallel edges
         while (i < edges.size() && edges[i].source == source && edges[i].target == target)
         {
@@ -90,12 +93,16 @@ ContractorGraph toContractorGraph(NodeID number_of_nodes, InputEdgeContainer inp
                 forward_edge.data.weight = std::min(edges[i].data.weight, forward_edge.data.weight);
                 forward_edge.data.duration =
                     std::min(edges[i].data.duration, forward_edge.data.duration);
+                forward_edge.data.distance =
+                    std::min(edges[i].data.distance, forward_edge.data.distance);
             }
             if (edges[i].data.backward)
             {
                 reverse_edge.data.weight = std::min(edges[i].data.weight, reverse_edge.data.weight);
                 reverse_edge.data.duration =
                     std::min(edges[i].data.duration, reverse_edge.data.duration);
+                reverse_edge.data.distance =
+                    std::min(edges[i].data.distance, reverse_edge.data.distance);
             }
             ++i;
         }
@@ -151,6 +158,7 @@ template <class Edge, typename GraphT> inline std::vector<Edge> toEdges(GraphT g
                 BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid");
                 new_edge.data.weight = data.weight;
                 new_edge.data.duration = data.duration;
+                new_edge.data.distance = data.distance;
                 new_edge.data.shortcut = data.shortcut;
                 new_edge.data.turn_id = data.id;
                 BOOST_ASSERT_MSG(new_edge.data.turn_id != INT_MAX, // 2^31

include/contractor/query_edge.hpp

@@ -17,7 +17,8 @@ struct QueryEdge
     struct EdgeData
     {
         explicit EdgeData()
-            : turn_id(0), shortcut(false), weight(0), duration(0), forward(false), backward(false)
+            : turn_id(0), shortcut(false), weight(0), duration(0), forward(false), backward(false),
+              distance(0)
         {
         }
 
@@ -25,10 +26,11 @@ struct QueryEdge
                  const bool shortcut,
                  const EdgeWeight weight,
                  const EdgeWeight duration,
+                 const EdgeDistance distance,
                  const bool forward,
                  const bool backward)
             : turn_id(turn_id), shortcut(shortcut), weight(weight), duration(duration),
-              forward(forward), backward(backward)
+              forward(forward), backward(backward), distance(distance)
         {
         }
 
@@ -40,6 +42,7 @@ struct QueryEdge
             turn_id = other.id;
             forward = other.forward;
             backward = other.backward;
+            distance = other.distance;
         }
         // this ID is either the middle node of the shortcut, or the ID of the edge based node (node
         // based edge) storing the appropriate data. If `shortcut` is set to true, we get the middle
@@ -50,6 +53,7 @@ struct QueryEdge
         EdgeWeight duration : 30;
         std::uint32_t forward : 1;
         std::uint32_t backward : 1;
+        EdgeDistance distance;
     } data;
 
     QueryEdge() : source(SPECIAL_NODEID), target(SPECIAL_NODEID) {}
@@ -69,10 +73,11 @@ struct QueryEdge
         return (source == right.source && target == right.target &&
                 data.weight == right.data.weight && data.duration == right.data.duration &&
                 data.shortcut == right.data.shortcut && data.forward == right.data.forward &&
-                data.backward == right.data.backward && data.turn_id == right.data.turn_id);
+                data.backward == right.data.backward && data.turn_id == right.data.turn_id &&
+                data.distance == right.data.distance);
     }
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // QUERYEDGE_HPP

include/engine/phantom_node.hpp

@@ -34,6 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"
 
+#include <iostream>
+
 #include <boost/assert.hpp>
 
 namespace osrm
@@ -44,14 +46,15 @@ namespace engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
+                                                                           false},
+          forward_weight(INVALID_EDGE_WEIGHT), reverse_weight(INVALID_EDGE_WEIGHT),
+          forward_weight_offset(0), reverse_weight_offset(0),
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
-          forward_duration_offset(0), reverse_duration_offset(0), fwd_segment_position(0),
-          is_valid_forward_source{false}, is_valid_forward_target{false},
+          forward_duration_offset(0), reverse_duration_offset(0),
+          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
 
     {
@@ -109,8 +112,9 @@ struct PhantomNode
 
     bool IsValid(const unsigned number_of_nodes) const
     {
-        return location.IsValid() && ((forward_segment_id.id < number_of_nodes) ||
-                                      (reverse_segment_id.id < number_of_nodes)) &&
+        return location.IsValid() &&
+               ((forward_segment_id.id < number_of_nodes) ||
+                (reverse_segment_id.id < number_of_nodes)) &&
                ((forward_weight != INVALID_EDGE_WEIGHT) ||
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
                ((forward_duration != MAXIMAL_EDGE_DURATION) ||
@@ -234,7 +238,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // PHANTOM_NODES_H

include/engine/routing_algorithms/many_to_many.hpp

@@ -25,15 +25,17 @@ struct NodeBucket
     unsigned from_clique_arc : 1;
     EdgeWeight weight;
     EdgeDuration duration;
+    EdgeDistance distance;
 
     NodeBucket(NodeID middle_node,
                NodeID parent_node,
                bool from_clique_arc,
                unsigned column_index,
                EdgeWeight weight,
-               EdgeDuration duration)
+               EdgeDuration duration,
+               EdgeDistance distance)
         : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
-          from_clique_arc(from_clique_arc), weight(weight), duration(duration)
+          from_clique_arc(from_clique_arc), weight(weight), duration(duration), distance(distance)
     {
     }
 
@@ -41,9 +43,10 @@ struct NodeBucket
                NodeID parent_node,
                unsigned column_index,
                EdgeWeight weight,
-               EdgeDuration duration)
+               EdgeDuration duration,
+               EdgeDistance distance)
         : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
-          from_clique_arc(false), weight(weight), duration(duration)
+          from_clique_arc(false), weight(weight), duration(duration), distance(distance)
     {
     }
 

include/engine/routing_algorithms/routing_base.hpp

@@ -54,13 +54,17 @@ void insertSourceInHeap(typename SearchEngineData<Algorithm>::ManyToManyQueryHea
     {
         heap.Insert(phantom_node.forward_segment_id.id,
                     -phantom_node.GetForwardWeightPlusOffset(),
-                    {phantom_node.forward_segment_id.id, -phantom_node.GetForwardDuration()});
+                    {phantom_node.forward_segment_id.id,
+                     -phantom_node.GetForwardDuration(),
+                     -phantom_node.GetForwardDistance()});
     }
     if (phantom_node.IsValidReverseTarget())
     {
         heap.Insert(phantom_node.reverse_segment_id.id,
                     -phantom_node.GetReverseWeightPlusOffset(),
-                    {phantom_node.reverse_segment_id.id, -phantom_node.GetReverseDuration()});
+                    {phantom_node.reverse_segment_id.id,
+                     -phantom_node.GetReverseDuration(),
+                     -phantom_node.GetReverseDistance()});
     }
 }
 
@@ -72,13 +76,17 @@ void insertTargetInHeap(typename SearchEngineData<Algorithm>::ManyToManyQueryHea
     {
         heap.Insert(phantom_node.forward_segment_id.id,
                     phantom_node.GetForwardWeightPlusOffset(),
-                    {phantom_node.forward_segment_id.id, phantom_node.GetForwardDuration()});
+                    {phantom_node.forward_segment_id.id,
+                     phantom_node.GetForwardDuration(),
+                     phantom_node.GetForwardDistance()});
     }
     if (phantom_node.IsValidReverseTarget())
     {
         heap.Insert(phantom_node.reverse_segment_id.id,
                     phantom_node.GetReverseWeightPlusOffset(),
-                    {phantom_node.reverse_segment_id.id, phantom_node.GetReverseDuration()});
+                    {phantom_node.reverse_segment_id.id,
+                     phantom_node.GetReverseDuration(),
+                     phantom_node.GetReverseDistance()});
     }
 }
 

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -186,9 +186,10 @@ void routingStep(const DataFacade<Algorithm> &facade,
 }
 
 template <bool UseDuration>
-EdgeWeight getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
+std::tuple<EdgeWeight,EdgeDistance> getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
+    EdgeDistance loop_distance = MAXIMAL_EDGE_DISTANCE;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
     {
         const auto &data = facade.GetEdgeData(edge);
@@ -198,11 +199,15 @@ EdgeWeight getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
             if (to == node)
             {
                 const auto value = UseDuration ? data.duration : data.weight;
-                loop_weight = std::min(loop_weight, value);
+                if (value < loop_weight)
+                {
+                    loop_weight = value;
+                    loop_distance = data.distance;
+                }
             }
         }
     }
-    return loop_weight;
+    return std::make_tuple(loop_weight, loop_distance);
 }
 
 /**

include/engine/search_engine_data.hpp

@@ -30,7 +30,11 @@ struct HeapData
 struct ManyToManyHeapData : HeapData
 {
     EdgeWeight duration;
-    ManyToManyHeapData(NodeID p, EdgeWeight duration) : HeapData(p), duration(duration) {}
+    EdgeDistance distance;
+    ManyToManyHeapData(NodeID p, EdgeWeight duration, EdgeDistance distance)
+        : HeapData(p), duration(duration), distance(distance)
+    {
+    }
 };
 
 template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
@@ -75,12 +79,16 @@ struct MultiLayerDijkstraHeapData
 struct ManyToManyMultiLayerDijkstraHeapData : MultiLayerDijkstraHeapData
 {
     EdgeWeight duration;
-    ManyToManyMultiLayerDijkstraHeapData(NodeID p, EdgeWeight duration)
-        : MultiLayerDijkstraHeapData(p), duration(duration)
+    EdgeDistance distance;
+    ManyToManyMultiLayerDijkstraHeapData(NodeID p, EdgeWeight duration, EdgeDistance distance)
+        : MultiLayerDijkstraHeapData(p), duration(duration), distance(distance)
     {
     }
-    ManyToManyMultiLayerDijkstraHeapData(NodeID p, bool from, EdgeWeight duration)
-        : MultiLayerDijkstraHeapData(p, from), duration(duration)
+    ManyToManyMultiLayerDijkstraHeapData(NodeID p,
+                                         bool from,
+                                         EdgeWeight duration,
+                                         EdgeDistance distance)
+        : MultiLayerDijkstraHeapData(p, from), duration(duration), distance(distance)
     {
     }
 };
@@ -112,7 +120,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // SEARCH_ENGINE_DATA_HPP

include/extractor/compressed_edge_container.hpp

@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // GEOMETRY_COMPRESSOR_HPP_

include/extractor/edge_based_edge.hpp

@@ -15,20 +15,25 @@ struct EdgeBasedEdge
   public:
     struct EdgeData
     {
-        EdgeData() : turn_id(0), weight(0), duration(0), forward(false), backward(false) {}
+        EdgeData()
+            : turn_id(0), weight(0), distance(0), duration(0), forward(false), backward(false)
+        {
+        }
 
         EdgeData(const NodeID turn_id,
                  const EdgeWeight weight,
+                 const EdgeDistance distance,
                  const EdgeWeight duration,
                  const bool forward,
                  const bool backward)
-            : turn_id(turn_id), weight(weight), duration(duration), forward(forward),
-              backward(backward)
+            : turn_id(turn_id), weight(weight), distance(distance), duration(duration),
+              forward(forward), backward(backward)
         {
         }
 
         NodeID turn_id; // ID of the edge based node (node based edge)
         EdgeWeight weight;
+        EdgeDistance distance;
         EdgeWeight duration : 30;
         std::uint32_t forward : 1;
         std::uint32_t backward : 1;
@@ -43,6 +48,7 @@ struct EdgeBasedEdge
                   const NodeID edge_id,
                   const EdgeWeight weight,
                   const EdgeWeight duration,
+                  const EdgeDistance distance,
                   const bool forward,
                   const bool backward);
     EdgeBasedEdge(const NodeID source, const NodeID target, const EdgeBasedEdge::EdgeData &data);
@@ -53,7 +59,7 @@ struct EdgeBasedEdge
     NodeID target;
     EdgeData data;
 };
-static_assert(sizeof(extractor::EdgeBasedEdge) == 20,
+static_assert(sizeof(extractor::EdgeBasedEdge) == 24,
               "Size of extractor::EdgeBasedEdge type is "
               "bigger than expected. This will influence "
               "memory consumption.");
@@ -67,9 +73,10 @@ inline EdgeBasedEdge::EdgeBasedEdge(const NodeID source,
                                     const NodeID turn_id,
                                     const EdgeWeight weight,
                                     const EdgeWeight duration,
+                                    const EdgeDistance distance,
                                     const bool forward,
                                     const bool backward)
-    : source(source), target(target), data{turn_id, weight, duration, forward, backward}
+    : source(source), target(target), data{turn_id, weight, distance, duration, forward, backward}
 {
 }
 
@@ -89,7 +96,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // ns extractor
-} // ns osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/internal_extractor_edge.hpp

@@ -49,7 +49,7 @@ struct ByEdgeOrByMeterValue
     using value_type = float;
     value_type value;
 };
-}
+} // namespace detail
 
 struct InternalExtractorEdge
 {
@@ -63,7 +63,7 @@ struct InternalExtractorEdge
                                    WeightData weight_data,
                                    DurationData duration_data,
                                    util::Coordinate source_coordinate)
-        : result(source, target, 0, 0, {}, -1, {}), weight_data(std::move(weight_data)),
+        : result(source, target, 0, 0, 0, {}, -1, {}), weight_data(std::move(weight_data)),
           duration_data(std::move(duration_data)), source_coordinate(std::move(source_coordinate))
     {
     }
@@ -113,7 +113,7 @@ struct InternalExtractorEdge
         return v;
     }
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // INTERNAL_EXTRACTOR_EDGE_HPP

include/extractor/node_based_edge.hpp

@@ -97,6 +97,7 @@ struct NodeBasedEdge
                   NodeID target,
                   EdgeWeight weight,
                   EdgeDuration duration,
+                  EdgeDistance distance,
                   GeometryID geometry_id,
                   AnnotationID annotation_data,
                   NodeBasedEdgeClassification flags);
@@ -107,6 +108,7 @@ struct NodeBasedEdge
     NodeID target;                     // 32 4
     EdgeWeight weight;                 // 32 4
     EdgeDuration duration;             // 32 4
+    EdgeDistance distance;             // 32 4
     GeometryID geometry_id;            // 32 4
     AnnotationID annotation_data;      // 32 4
     NodeBasedEdgeClassification flags; // 32 4
@@ -120,6 +122,7 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
                          OSMNodeID target,
                          EdgeWeight weight,
                          EdgeDuration duration,
+                         EdgeDistance distance,
                          GeometryID geometry_id,
                          AnnotationID annotation_data,
                          NodeBasedEdgeClassification flags);
@@ -137,7 +140,8 @@ inline NodeBasedEdgeClassification::NodeBasedEdgeClassification()
 }
 
 inline NodeBasedEdge::NodeBasedEdge()
-    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), weight(0), duration(0), annotation_data(-1)
+    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), weight(0), duration(0), distance(0),
+      annotation_data(-1)
 {
 }
 
@@ -145,11 +149,12 @@ inline NodeBasedEdge::NodeBasedEdge(NodeID source,
                                     NodeID target,
                                     EdgeWeight weight,
                                     EdgeDuration duration,
+                                    EdgeDistance distance,
                                     GeometryID geometry_id,
                                     AnnotationID annotation_data,
                                     NodeBasedEdgeClassification flags)
-    : source(source), target(target), weight(weight), duration(duration), geometry_id(geometry_id),
-      annotation_data(annotation_data), flags(flags)
+    : source(source), target(target), weight(weight), duration(duration), distance(distance),
+      geometry_id(geometry_id), annotation_data(annotation_data), flags(flags)
 {
 }
 
@@ -175,11 +180,18 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
                                                   OSMNodeID target,
                                                   EdgeWeight weight,
                                                   EdgeDuration duration,
+                                                  EdgeDistance distance,
                                                   GeometryID geometry_id,
                                                   AnnotationID annotation_data,
                                                   NodeBasedEdgeClassification flags)
-    : NodeBasedEdge(
-          SPECIAL_NODEID, SPECIAL_NODEID, weight, duration, geometry_id, annotation_data, flags),
+    : NodeBasedEdge(SPECIAL_NODEID,
+                    SPECIAL_NODEID,
+                    weight,
+                    duration,
+                    distance,
+                    geometry_id,
+                    annotation_data,
+                    flags),
       osm_source_id(std::move(source)), osm_target_id(std::move(target))
 {
 }
@@ -189,12 +201,12 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM()
 {
 }
 
-static_assert(sizeof(extractor::NodeBasedEdge) == 28,
+static_assert(sizeof(extractor::NodeBasedEdge) == 32,
               "Size of extractor::NodeBasedEdge type is "
               "bigger than expected. This will influence "
               "memory consumption.");
 
-} // ns extractor
-} // ns osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* NODE_BASED_EDGE_HPP */

include/partitioner/edge_based_graph_reader.hpp

@@ -14,6 +14,8 @@
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_reduce.h>
 
+#include <iostream>
+
 #include <cstdint>
 
 #include <algorithm>
@@ -43,6 +45,7 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
                               edge.data.turn_id,
                               std::max(edge.data.weight, 1),
                               edge.data.duration,
+                              edge.data.distance,
                               edge.data.forward,
                               edge.data.backward);
 
@@ -51,6 +54,7 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
                               edge.data.turn_id,
                               std::max(edge.data.weight, 1),
                               edge.data.duration,
+                              edge.data.distance,
                               edge.data.backward,
                               edge.data.forward);
     }
@@ -196,7 +200,7 @@ inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &p
     return DynamicEdgeBasedGraph(number_of_edge_based_nodes, std::move(tidied), checksum);
 }
 
-} // ns partition
-} // ns osrm
+} // namespace partitioner
+} // namespace osrm
 
 #endif

include/storage/shared_monitor.hpp

@@ -146,7 +146,9 @@ template <typename Data> struct SharedMonitor
     // like two-turnstile reusable barrier or boost/interprocess/sync/spin/condition.hpp
     // fail if a waiter is killed.
 
-    static constexpr int buffer_size = 4096;
+    // Buffer size needs to be large enough to hold all the semaphores for every
+    // listener you want to support.
+    static constexpr int buffer_size = 4096 * 4;
 
     struct InternalData
     {

include/util/debug.hpp

@@ -1,9 +1,11 @@
 #ifndef OSRM_UTIL_DEBUG_HPP_
 #define OSRM_UTIL_DEBUG_HPP_
 
+#include "extractor/edge_based_edge.hpp"
 #include "extractor/node_data_container.hpp"
 #include "extractor/query_node.hpp"
 #include "guidance/intersection.hpp"
+#include "guidance/turn_instruction.hpp"
 #include "guidance/turn_lane_data.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "util/node_based_graph.hpp"
@@ -25,7 +27,7 @@ inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
         << toFloating(coordinate.lat) << "}";
     return out;
 }
-}
+} // namespace util
 
 namespace engine
 {
@@ -60,8 +62,8 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 
     return out;
 }
-}
-}
+} // namespace guidance
+} // namespace engine
 
 namespace guidance
 {
@@ -74,7 +76,7 @@ inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
         << static_cast<std::int32_t>(road.lane_data_id) << "}";
     return out;
 }
-}
+} // namespace guidance
 
 namespace extractor
 {
@@ -93,7 +95,7 @@ inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &v
         << " angle: " << view.angle << " bearing: " << view.perceived_bearing << "}";
     return out;
 }
-}
+} // namespace intersection
 
 namespace TurnLaneType
 {
@@ -123,9 +125,9 @@ inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
 
     return out;
 }
-}
-}
-}
+} // namespace TurnLaneType
+} // namespace extractor
+} // namespace osrm
 
 namespace std
 {
@@ -145,7 +147,7 @@ inline std::ostream &operator<<(std::ostream &out,
 
     return out;
 }
-}
+} // namespace std
 
 namespace osrm
 {
@@ -184,8 +186,26 @@ inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_la
 
     return out;
 }
-}
-}
+} // namespace lanes
+} // namespace guidance
+
+namespace extractor
+{
+inline std::ostream &operator<<(std::ostream &out, const EdgeBasedEdge &edge)
+{
+    out << " EdgeBasedEdge {";
+    out << " source " << edge.source << ", target: " << edge.target;
+    out << " EdgeBasedEdgeData data {";
+    out << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
+    out << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
+    out << " forward: " << (edge.data.forward == 0 ? "false" : "true")
+        << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
+    out << " }";
+    out << "}";
+    return out;
 }
 
+} // namespace extractor
+} // namespace osrm
+
 #endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/

include/util/ieee754.hpp

@@ -0,0 +1,517 @@
+#ifndef IEEE754_HPP
+#define IEEE754_HPP
+/**
+Copyright (C) 2014 Milo Yip
+
+Imported from:
+https://github.com/miloyip/dtoa-benchmark/blob/c4020c62754950d38a1aaaed2975b05b441d1e7d/src/milo/dtoa_milo.h
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+**/
+
+#include <assert.h>
+#include <math.h>
+
+#if defined(_MSC_VER)
+#include "msinttypes/stdint.h"
+#include <intrin.h>
+#else
+#include <stdint.h>
+#endif
+
+#define UINT64_C2(h, l) ((static_cast<uint64_t>(h) << 32) | static_cast<uint64_t>(l))
+
+namespace osrm
+{
+namespace util
+{
+namespace ieee754
+{
+
+struct DiyFp
+{
+    DiyFp() {}
+
+    DiyFp(uint64_t f, int e) : f(f), e(e) {}
+
+    DiyFp(double d)
+    {
+        union {
+            double d;
+            uint64_t u64;
+        } u = {d};
+
+        int biased_e = (u.u64 & kDpExponentMask) >> kDpSignificandSize;
+        uint64_t significand = (u.u64 & kDpSignificandMask);
+        if (biased_e != 0)
+        {
+            f = significand + kDpHiddenBit;
+            e = biased_e - kDpExponentBias;
+        }
+        else
+        {
+            f = significand;
+            e = kDpMinExponent + 1;
+        }
+    }
+
+    DiyFp operator-(const DiyFp &rhs) const
+    {
+        assert(e == rhs.e);
+        assert(f >= rhs.f);
+        return DiyFp(f - rhs.f, e);
+    }
+
+    DiyFp operator*(const DiyFp &rhs) const
+    {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t h;
+        uint64_t l = _umul128(f, rhs.f, &h);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        unsigned __int128 p =
+            static_cast<unsigned __int128>(f) * static_cast<unsigned __int128>(rhs.f);
+        uint64_t h = p >> 64;
+        uint64_t l = static_cast<uint64_t>(p);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#else
+        const uint64_t M32 = 0xFFFFFFFF;
+        const uint64_t a = f >> 32;
+        const uint64_t b = f & M32;
+        const uint64_t c = rhs.f >> 32;
+        const uint64_t d = rhs.f & M32;
+        const uint64_t ac = a * c;
+        const uint64_t bc = b * c;
+        const uint64_t ad = a * d;
+        const uint64_t bd = b * d;
+        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
+        tmp += 1U << 31; /// mult_round
+        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
+#endif
+    }
+
+    DiyFp Normalize() const
+    {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        unsigned long index;
+        _BitScanReverse64(&index, f);
+        return DiyFp(f << (63 - index), e - (63 - index));
+#elif defined(__GNUC__)
+        int s = __builtin_clzll(f);
+        return DiyFp(f << s, e - s);
+#else
+        DiyFp res = *this;
+        while (!(res.f & kDpHiddenBit))
+        {
+            res.f <<= 1;
+            res.e--;
+        }
+        res.f <<= (kDiySignificandSize - kDpSignificandSize - 1);
+        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 1);
+        return res;
+#endif
+    }
+
+    DiyFp NormalizeBoundary() const
+    {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        unsigned long index;
+        _BitScanReverse64(&index, f);
+        return DiyFp(f << (63 - index), e - (63 - index));
+#else
+        DiyFp res = *this;
+        while (!(res.f & (kDpHiddenBit << 1)))
+        {
+            res.f <<= 1;
+            res.e--;
+        }
+        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
+        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
+        return res;
+#endif
+    }
+
+    void NormalizedBoundaries(DiyFp *minus, DiyFp *plus) const
+    {
+        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
+        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
+        mi.f <<= mi.e - pl.e;
+        mi.e = pl.e;
+        *plus = pl;
+        *minus = mi;
+    }
+
+    static const int kDiySignificandSize = 64;
+    static const int kDpSignificandSize = 52;
+    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
+    static const int kDpMinExponent = -kDpExponentBias;
+    static const uint64_t kDpExponentMask = UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kDpSignificandMask = UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kDpHiddenBit = UINT64_C2(0x00100000, 0x00000000);
+
+    uint64_t f;
+    int e;
+};
+
+inline DiyFp GetCachedPower(int e, int *K)
+{
+    // 10^-348, 10^-340, ..., 10^340
+    static const uint64_t kCachedPowers_F[] = {
+        UINT64_C2(0xfa8fd5a0, 0x081c0288), UINT64_C2(0xbaaee17f, 0xa23ebf76),
+        UINT64_C2(0x8b16fb20, 0x3055ac76), UINT64_C2(0xcf42894a, 0x5dce35ea),
+        UINT64_C2(0x9a6bb0aa, 0x55653b2d), UINT64_C2(0xe61acf03, 0x3d1a45df),
+        UINT64_C2(0xab70fe17, 0xc79ac6ca), UINT64_C2(0xff77b1fc, 0xbebcdc4f),
+        UINT64_C2(0xbe5691ef, 0x416bd60c), UINT64_C2(0x8dd01fad, 0x907ffc3c),
+        UINT64_C2(0xd3515c28, 0x31559a83), UINT64_C2(0x9d71ac8f, 0xada6c9b5),
+        UINT64_C2(0xea9c2277, 0x23ee8bcb), UINT64_C2(0xaecc4991, 0x4078536d),
+        UINT64_C2(0x823c1279, 0x5db6ce57), UINT64_C2(0xc2109436, 0x4dfb5637),
+        UINT64_C2(0x9096ea6f, 0x3848984f), UINT64_C2(0xd77485cb, 0x25823ac7),
+        UINT64_C2(0xa086cfcd, 0x97bf97f4), UINT64_C2(0xef340a98, 0x172aace5),
+        UINT64_C2(0xb23867fb, 0x2a35b28e), UINT64_C2(0x84c8d4df, 0xd2c63f3b),
+        UINT64_C2(0xc5dd4427, 0x1ad3cdba), UINT64_C2(0x936b9fce, 0xbb25c996),
+        UINT64_C2(0xdbac6c24, 0x7d62a584), UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
+        UINT64_C2(0xf3e2f893, 0xdec3f126), UINT64_C2(0xb5b5ada8, 0xaaff80b8),
+        UINT64_C2(0x87625f05, 0x6c7c4a8b), UINT64_C2(0xc9bcff60, 0x34c13053),
+        UINT64_C2(0x964e858c, 0x91ba2655), UINT64_C2(0xdff97724, 0x70297ebd),
+        UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), UINT64_C2(0xf8a95fcf, 0x88747d94),
+        UINT64_C2(0xb9447093, 0x8fa89bcf), UINT64_C2(0x8a08f0f8, 0xbf0f156b),
+        UINT64_C2(0xcdb02555, 0x653131b6), UINT64_C2(0x993fe2c6, 0xd07b7fac),
+        UINT64_C2(0xe45c10c4, 0x2a2b3b06), UINT64_C2(0xaa242499, 0x697392d3),
+        UINT64_C2(0xfd87b5f2, 0x8300ca0e), UINT64_C2(0xbce50864, 0x92111aeb),
+        UINT64_C2(0x8cbccc09, 0x6f5088cc), UINT64_C2(0xd1b71758, 0xe219652c),
+        UINT64_C2(0x9c400000, 0x00000000), UINT64_C2(0xe8d4a510, 0x00000000),
+        UINT64_C2(0xad78ebc5, 0xac620000), UINT64_C2(0x813f3978, 0xf8940984),
+        UINT64_C2(0xc097ce7b, 0xc90715b3), UINT64_C2(0x8f7e32ce, 0x7bea5c70),
+        UINT64_C2(0xd5d238a4, 0xabe98068), UINT64_C2(0x9f4f2726, 0x179a2245),
+        UINT64_C2(0xed63a231, 0xd4c4fb27), UINT64_C2(0xb0de6538, 0x8cc8ada8),
+        UINT64_C2(0x83c7088e, 0x1aab65db), UINT64_C2(0xc45d1df9, 0x42711d9a),
+        UINT64_C2(0x924d692c, 0xa61be758), UINT64_C2(0xda01ee64, 0x1a708dea),
+        UINT64_C2(0xa26da399, 0x9aef774a), UINT64_C2(0xf209787b, 0xb47d6b85),
+        UINT64_C2(0xb454e4a1, 0x79dd1877), UINT64_C2(0x865b8692, 0x5b9bc5c2),
+        UINT64_C2(0xc83553c5, 0xc8965d3d), UINT64_C2(0x952ab45c, 0xfa97a0b3),
+        UINT64_C2(0xde469fbd, 0x99a05fe3), UINT64_C2(0xa59bc234, 0xdb398c25),
+        UINT64_C2(0xf6c69a72, 0xa3989f5c), UINT64_C2(0xb7dcbf53, 0x54e9bece),
+        UINT64_C2(0x88fcf317, 0xf22241e2), UINT64_C2(0xcc20ce9b, 0xd35c78a5),
+        UINT64_C2(0x98165af3, 0x7b2153df), UINT64_C2(0xe2a0b5dc, 0x971f303a),
+        UINT64_C2(0xa8d9d153, 0x5ce3b396), UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
+        UINT64_C2(0xbb764c4c, 0xa7a44410), UINT64_C2(0x8bab8eef, 0xb6409c1a),
+        UINT64_C2(0xd01fef10, 0xa657842c), UINT64_C2(0x9b10a4e5, 0xe9913129),
+        UINT64_C2(0xe7109bfb, 0xa19c0c9d), UINT64_C2(0xac2820d9, 0x623bf429),
+        UINT64_C2(0x80444b5e, 0x7aa7cf85), UINT64_C2(0xbf21e440, 0x03acdd2d),
+        UINT64_C2(0x8e679c2f, 0x5e44ff8f), UINT64_C2(0xd433179d, 0x9c8cb841),
+        UINT64_C2(0x9e19db92, 0xb4e31ba9), UINT64_C2(0xeb96bf6e, 0xbadf77d9),
+        UINT64_C2(0xaf87023b, 0x9bf0ee6b)};
+    static const int16_t kCachedPowers_E[] = {
+        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+        -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,  -635, -608, -582, -555,
+        -529,  -502,  -475,  -449,  -422,  -396,  -369,  -343,  -316,  -289, -263, -236, -210,
+        -183,  -157,  -130,  -103,  -77,   -50,   -24,   3,     30,    56,   83,   109,  136,
+        162,   189,   216,   242,   269,   295,   322,   348,   375,   402,  428,  455,  481,
+        508,   534,   561,   588,   614,   641,   667,   694,   720,   747,  774,  800,  827,
+        853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+
+    // int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
+    double dk =
+        (-61 - e) * 0.30102999566398114 + 347; // dk must be positive, so can do ceiling in positive
+    int k = static_cast<int>(dk);
+    if (k != dk)
+        k++;
+
+    unsigned index = static_cast<unsigned>((k >> 3) + 1);
+    *K = -(-348 + static_cast<int>(index << 3)); // decimal exponent no need lookup table
+
+    assert(index < sizeof(kCachedPowers_F) / sizeof(kCachedPowers_F[0]));
+    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
+}
+
+inline void
+GrisuRound(char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
+{
+    while (rest < wp_w && delta - rest >= ten_kappa && (rest + ten_kappa < wp_w || /// closer
+                                                        wp_w - rest > rest + ten_kappa - wp_w))
+    {
+        buffer[len - 1]--;
+        rest += ten_kappa;
+    }
+}
+
+inline unsigned CountDecimalDigit32(uint32_t n)
+{
+    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
+    if (n < 10)
+        return 1;
+    if (n < 100)
+        return 2;
+    if (n < 1000)
+        return 3;
+    if (n < 10000)
+        return 4;
+    if (n < 100000)
+        return 5;
+    if (n < 1000000)
+        return 6;
+    if (n < 10000000)
+        return 7;
+    if (n < 100000000)
+        return 8;
+    if (n < 1000000000)
+        return 9;
+    return 10;
+}
+
+inline void
+DigitGen(const DiyFp &W, const DiyFp &Mp, uint64_t delta, char *buffer, int *len, int *K)
+{
+    static const uint32_t kPow10[] = {
+        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
+    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
+    const DiyFp wp_w = Mp - W;
+    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
+    uint64_t p2 = Mp.f & (one.f - 1);
+    int kappa = static_cast<int>(CountDecimalDigit32(p1));
+    *len = 0;
+
+    while (kappa > 0)
+    {
+        uint32_t d;
+        switch (kappa)
+        {
+        case 10:
+            d = p1 / 1000000000;
+            p1 %= 1000000000;
+            break;
+        case 9:
+            d = p1 / 100000000;
+            p1 %= 100000000;
+            break;
+        case 8:
+            d = p1 / 10000000;
+            p1 %= 10000000;
+            break;
+        case 7:
+            d = p1 / 1000000;
+            p1 %= 1000000;
+            break;
+        case 6:
+            d = p1 / 100000;
+            p1 %= 100000;
+            break;
+        case 5:
+            d = p1 / 10000;
+            p1 %= 10000;
+            break;
+        case 4:
+            d = p1 / 1000;
+            p1 %= 1000;
+            break;
+        case 3:
+            d = p1 / 100;
+            p1 %= 100;
+            break;
+        case 2:
+            d = p1 / 10;
+            p1 %= 10;
+            break;
+        case 1:
+            d = p1;
+            p1 = 0;
+            break;
+        default:
+#if defined(_MSC_VER)
+            __assume(0);
+#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+            __builtin_unreachable();
+#else
+            d = 0;
+#endif
+        }
+        if (d || *len)
+            buffer[(*len)++] = '0' + static_cast<char>(d);
+        kappa--;
+        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
+        if (tmp <= delta)
+        {
+            *K += kappa;
+            GrisuRound(
+                buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
+            return;
+        }
+    }
+
+    // kappa = 0
+    for (;;)
+    {
+        p2 *= 10;
+        delta *= 10;
+        char d = static_cast<char>(p2 >> -one.e);
+        if (d || *len)
+            buffer[(*len)++] = '0' + d;
+        p2 &= one.f - 1;
+        kappa--;
+        if (p2 < delta)
+        {
+            *K += kappa;
+            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
+            return;
+        }
+    }
+}
+
+inline void Grisu2(double value, char *buffer, int *length, int *K)
+{
+    const DiyFp v(value);
+    DiyFp w_m, w_p;
+    v.NormalizedBoundaries(&w_m, &w_p);
+
+    const DiyFp c_mk = GetCachedPower(w_p.e, K);
+    const DiyFp W = v.Normalize() * c_mk;
+    DiyFp Wp = w_p * c_mk;
+    DiyFp Wm = w_m * c_mk;
+    Wm.f++;
+    Wp.f--;
+    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
+}
+
+inline const char *GetDigitsLut()
+{
+    static const char cDigitsLut[200] = {
+        '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0',
+        '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6',
+        '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2',
+        '5', '2', '6', '2', '7', '2', '8', '2', '9', '3', '0', '3', '1', '3', '2', '3', '3',
+        '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', '4', '0', '4', '1', '4',
+        '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '5', '0',
+        '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5',
+        '9', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7',
+        '6', '8', '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7',
+        '6', '7', '7', '7', '8', '7', '9', '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',
+        '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '9', '0', '9', '1', '9', '2', '9',
+        '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
+    return cDigitsLut;
+}
+
+inline void WriteExponent(int K, char *buffer)
+{
+    if (K < 0)
+    {
+        *buffer++ = '-';
+        K = -K;
+    }
+
+    if (K >= 100)
+    {
+        *buffer++ = '0' + static_cast<char>(K / 100);
+        K %= 100;
+        const char *d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else if (K >= 10)
+    {
+        const char *d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else
+        *buffer++ = '0' + static_cast<char>(K);
+
+    *buffer = '\0';
+}
+
+inline void Prettify(char *buffer, int length, int k)
+{
+    const int kk = length + k; // 10^(kk-1) <= v < 10^kk
+
+    if (length <= kk && kk <= 21)
+    {
+        // 1234e7 -> 12340000000
+        for (int i = length; i < kk; i++)
+            buffer[i] = '0';
+        buffer[kk] = '.';
+        buffer[kk + 1] = '0';
+        buffer[kk + 2] = '\0';
+    }
+    else if (0 < kk && kk <= 21)
+    {
+        // 1234e-2 -> 12.34
+        memmove(&buffer[kk + 1], &buffer[kk], length - kk);
+        buffer[kk] = '.';
+        buffer[length + 1] = '\0';
+    }
+    else if (-6 < kk && kk <= 0)
+    {
+        // 1234e-6 -> 0.001234
+        const int offset = 2 - kk;
+        memmove(&buffer[offset], &buffer[0], length);
+        buffer[0] = '0';
+        buffer[1] = '.';
+        for (int i = 2; i < offset; i++)
+            buffer[i] = '0';
+        buffer[length + offset] = '\0';
+    }
+    else if (length == 1)
+    {
+        // 1e30
+        buffer[1] = 'e';
+        WriteExponent(kk - 1, &buffer[2]);
+    }
+    else
+    {
+        // 1234e30 -> 1.234e33
+        memmove(&buffer[2], &buffer[1], length - 1);
+        buffer[1] = '.';
+        buffer[length + 1] = 'e';
+        WriteExponent(kk - 1, &buffer[0 + length + 2]);
+    }
+}
+
+inline void dtoa_milo(double value, char *buffer)
+{
+    // Not handling NaN and inf
+    assert(!isnan(value));
+    assert(!isinf(value));
+
+    if (value == 0)
+    {
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        buffer[3] = '\0';
+    }
+    else
+    {
+        if (value < 0)
+        {
+            *buffer++ = '-';
+            value = -value;
+        }
+        int length, K;
+        Grisu2(value, buffer, &length, &K);
+        Prettify(buffer, length, K);
+    }
+}
+} // namespace ieee754
+} // namespace util
+} // namespace osrm
+
+#endif // IEEE754_HPP

include/util/json_renderer.hpp

@@ -5,6 +5,7 @@
 #define JSON_RENDERER_HPP
 
 #include "util/cast.hpp"
+#include "util/ieee754.hpp"
 #include "util/string_util.hpp"
 
 #include "osrm/json_container.hpp"
@@ -21,6 +22,11 @@ namespace util
 namespace json
 {
 
+namespace
+{
+constexpr int MAX_FLOAT_STRING_LENGTH = 256;
+}
+
 struct Renderer
 {
     explicit Renderer(std::ostream &_out) : out(_out) {}
@@ -34,8 +40,31 @@ struct Renderer
 
     void operator()(const Number &number) const
     {
-        out.precision(10);
-        out << number.value;
+        char buffer[MAX_FLOAT_STRING_LENGTH] = {'\0'};
+        ieee754::dtoa_milo(number.value, buffer);
+
+        // Trucate to 10 decimal places
+        int pos = 0;
+        int decimalpos = 0;
+        while (decimalpos == 0 && pos < MAX_FLOAT_STRING_LENGTH && buffer[pos] != 0)
+        {
+            if (buffer[pos] == '.')
+            {
+                decimalpos = pos;
+                break;
+            }
+            ++pos;
+        }
+        while (pos < MAX_FLOAT_STRING_LENGTH && buffer[pos] != 0)
+        {
+            if (pos - decimalpos == 10)
+            {
+                buffer[pos] = '\0';
+                break;
+            }
+            ++pos;
+        }
+        out << buffer;
     }
 
     void operator()(const Object &object) const

include/util/node_based_graph.hpp

@@ -20,24 +20,27 @@ namespace util
 struct NodeBasedEdgeData
 {
     NodeBasedEdgeData()
-        : weight(INVALID_EDGE_WEIGHT), duration(INVALID_EDGE_WEIGHT), geometry_id({0, false}),
-          reversed(false), annotation_data(-1)
+        : weight(INVALID_EDGE_WEIGHT), duration(INVALID_EDGE_WEIGHT),
+          distance(INVALID_EDGE_DISTANCE), geometry_id({0, false}), reversed(false),
+          annotation_data(-1)
     {
     }
 
     NodeBasedEdgeData(EdgeWeight weight,
                       EdgeWeight duration,
+                      EdgeDistance distance,
                       GeometryID geometry_id,
                       bool reversed,
                       extractor::NodeBasedEdgeClassification flags,
                       AnnotationID annotation_data)
-        : weight(weight), duration(duration), geometry_id(geometry_id), reversed(reversed),
-          flags(flags), annotation_data(annotation_data)
+        : weight(weight), duration(duration), distance(distance), geometry_id(geometry_id),
+          reversed(reversed), flags(flags), annotation_data(annotation_data)
     {
     }
 
     EdgeWeight weight;
     EdgeWeight duration;
+    EdgeDistance distance;
     GeometryID geometry_id;
     bool reversed : 1;
     extractor::NodeBasedEdgeClassification flags;
@@ -80,18 +83,20 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
            const extractor::NodeBasedEdge &input_edge) {
             output_edge.data.weight = input_edge.weight;
             output_edge.data.duration = input_edge.duration;
+            output_edge.data.distance = input_edge.distance;
             output_edge.data.flags = input_edge.flags;
             output_edge.data.annotation_data = input_edge.annotation_data;
 
             BOOST_ASSERT(output_edge.data.weight > 0);
             BOOST_ASSERT(output_edge.data.duration > 0);
+            BOOST_ASSERT(output_edge.data.distance > 0);
         });
 
     tbb::parallel_sort(edges_list.begin(), edges_list.end());
 
     return NodeBasedDynamicGraph(number_of_nodes, edges_list);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // NODE_BASED_GRAPH_HPP

include/util/typedefs.hpp

@@ -48,7 +48,7 @@ struct osm_way_id
 struct duplicated_node
 {
 };
-}
+} // namespace tag
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
 static_assert(std::is_pod<OSMNodeID>(), "OSMNodeID is not a valid alias");
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;
@@ -113,6 +113,7 @@ static const SegmentWeight MAX_SEGMENT_WEIGHT = INVALID_SEGMENT_WEIGHT - 1;
 static const SegmentDuration MAX_SEGMENT_DURATION = INVALID_SEGMENT_DURATION - 1;
 static const EdgeWeight INVALID_EDGE_WEIGHT = std::numeric_limits<EdgeWeight>::max();
 static const EdgeDuration MAXIMAL_EDGE_DURATION = std::numeric_limits<EdgeDuration>::max();
+static const EdgeDistance MAXIMAL_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 static const TurnPenalty INVALID_TURN_PENALTY = std::numeric_limits<TurnPenalty>::max();
 static const EdgeDistance INVALID_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.18.0-latest.1",
+  "version": "5.20.0-alpha.1",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {

profiles/car.lua

@@ -120,9 +120,6 @@ function setup()
 
     -- classes to support for exclude flags
     excludable = Sequence {
-        Set {'toll'},
-        Set {'motorway'},
-        Set {'ferry'}
     },
 
     avoid = Set {

src/contractor/contractor.cpp

@@ -102,6 +102,7 @@ int Contractor::Run()
     QueryGraph query_graph;
     std::vector<std::vector<bool>> edge_filters;
     std::vector<std::vector<bool>> cores;
+
     std::tie(query_graph, edge_filters) = contractExcludableGraph(
         toContractorGraph(number_of_edge_based_nodes, std::move(edge_based_edge_list)),
         std::move(node_weights),

src/contractor/graph_contractor.cpp

@@ -215,6 +215,7 @@ void ContractNode(ContractorThreadData *data,
                                                     target,
                                                     path_weight,
                                                     in_data.duration + out_data.duration,
+                                                    in_data.distance + out_data.distance,
                                                     out_data.originalEdges + in_data.originalEdges,
                                                     node,
                                                     SHORTCUT_ARC,
@@ -225,6 +226,7 @@ void ContractNode(ContractorThreadData *data,
                                                     source,
                                                     path_weight,
                                                     in_data.duration + out_data.duration,
+                                                    in_data.distance + out_data.distance,
                                                     out_data.originalEdges + in_data.originalEdges,
                                                     node,
                                                     SHORTCUT_ARC,
@@ -280,6 +282,7 @@ void ContractNode(ContractorThreadData *data,
                                                 target,
                                                 path_weight,
                                                 in_data.duration + out_data.duration,
+                                                in_data.distance + out_data.distance,
                                                 out_data.originalEdges + in_data.originalEdges,
                                                 node,
                                                 SHORTCUT_ARC,
@@ -290,6 +293,7 @@ void ContractNode(ContractorThreadData *data,
                                                 source,
                                                 path_weight,
                                                 in_data.duration + out_data.duration,
+                                                in_data.distance + out_data.distance,
                                                 out_data.originalEdges + in_data.originalEdges,
                                                 node,
                                                 SHORTCUT_ARC,
@@ -556,7 +560,7 @@ bool IsNodeIndependent(const util::XORFastHash<> &hash,
     }
     return true;
 }
-}
+} // namespace
 
 std::vector<bool> contractGraph(ContractorGraph &graph,
                                 std::vector<bool> node_is_uncontracted_,

src/engine/routing_algorithms/alternative_path_ch.cpp

@@ -90,7 +90,7 @@ void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
             else
             {
                 // check whether there is a loop present at the node
-                const auto loop_weight = getLoopWeight<false>(facade, node);
+                const auto loop_weight = std::get<0>(getLoopWeight<false>(facade, node));
                 const EdgeWeight new_weight_with_loop = new_weight + loop_weight;
                 if (loop_weight != INVALID_EDGE_WEIGHT &&
                     new_weight_with_loop <= *upper_bound_to_shortest_path_weight)
@@ -558,7 +558,7 @@ bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_dat
     }
     return (upper_bound <= t_test_path_weight);
 }
-} // anon. namespace
+} // namespace
 
 InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
                                                const DataFacade<Algorithm> &facade,
@@ -853,4 +853,4 @@ InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engi
 
 } // namespace routing_algorithms
 } // namespace engine
-} // namespace osrm}
+} // namespace osrm

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -21,18 +21,21 @@ namespace ch
 inline bool addLoopWeight(const DataFacade<ch::Algorithm> &facade,
                           const NodeID node,
                           EdgeWeight &weight,
-                          EdgeDuration &duration)
+                          EdgeDuration &duration,
+                          EdgeDistance &distance)
 { // Special case for CH when contractor creates a loop edge node->node
     BOOST_ASSERT(weight < 0);
 
     const auto loop_weight = ch::getLoopWeight<false>(facade, node);
-    if (loop_weight != INVALID_EDGE_WEIGHT)
+    if (std::get<0>(loop_weight) != INVALID_EDGE_WEIGHT)
     {
-        const auto new_weight_with_loop = weight + loop_weight;
+        const auto new_weight_with_loop = weight + std::get<0>(loop_weight);
         if (new_weight_with_loop >= 0)
         {
             weight = new_weight_with_loop;
-            duration += ch::getLoopWeight<true>(facade, node);
+            auto result = ch::getLoopWeight<true>(facade, node);
+            duration += std::get<0>(result);
+            distance += std::get<1>(result);
             return true;
         }
     }
@@ -46,6 +49,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
+                        const EdgeDistance distance,
                         typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                         const PhantomNode &)
 {
@@ -63,21 +67,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto edge_weight = data.weight;
 
             const auto edge_duration = data.duration;
+            const auto edge_distance = data.distance;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
             const auto to_weight = weight + edge_weight;
             const auto to_duration = duration + edge_duration;
+            const auto to_distance = distance + edge_distance;
 
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
             {
-                query_heap.Insert(to, to_weight, {node, to_duration});
+                query_heap.Insert(to, to_weight, {node, to_duration, to_distance});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration) <
                      std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
             {
-                query_heap.GetData(to) = {node, to_duration};
+                query_heap.GetData(to) = {node, to_duration, to_distance};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -91,12 +97,14 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const std::vector<NodeBucket> &search_space_with_buckets,
                         std::vector<EdgeWeight> &weights_table,
                         std::vector<EdgeDuration> &durations_table,
+                        std::vector<EdgeDistance> &distances_table,
                         std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
     const auto node = query_heap.DeleteMin();
     const auto source_weight = query_heap.GetKey(node);
     const auto source_duration = query_heap.GetData(node).duration;
+    const auto source_distance = query_heap.GetData(node).distance;
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
@@ -109,20 +117,24 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         const auto column_index = current_bucket.column_index;
         const auto target_weight = current_bucket.weight;
         const auto target_duration = current_bucket.duration;
+        const auto target_distance = current_bucket.distance;
 
         auto &current_weight = weights_table[row_index * number_of_targets + column_index];
         auto &current_duration = durations_table[row_index * number_of_targets + column_index];
+        auto &current_distance = distances_table[row_index * number_of_targets + column_index];
 
         // Check if new weight is better
         auto new_weight = source_weight + target_weight;
         auto new_duration = source_duration + target_duration;
+        auto new_distance = source_distance + target_distance;
 
         if (new_weight < 0)
         {
-            if (addLoopWeight(facade, node, new_weight, new_duration))
+            if (addLoopWeight(facade, node, new_weight, new_duration, new_distance))
             {
                 current_weight = std::min(current_weight, new_weight);
                 current_duration = std::min(current_duration, new_duration);
+                current_distance = std::min(current_distance, new_distance);
                 middle_nodes_table[row_index * number_of_targets + column_index] = node;
             }
         }
@@ -130,12 +142,13 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         {
             current_weight = new_weight;
             current_duration = new_duration;
+            current_distance = new_distance;
             middle_nodes_table[row_index * number_of_targets + column_index] = node;
         }
     }
 
     relaxOutgoingEdges<FORWARD_DIRECTION>(
-        facade, node, source_weight, source_duration, query_heap, phantom_node);
+        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
 }
 
 void backwardRoutingStep(const DataFacade<Algorithm> &facade,
@@ -147,14 +160,15 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
+    const auto target_distance = query_heap.GetData(node).distance;
     const auto parent = query_heap.GetData(node).parent;
 
     // Store settled nodes in search space bucket
     search_space_with_buckets.emplace_back(
-        node, parent, column_index, target_weight, target_duration);
+        node, parent, column_index, target_weight, target_duration, target_distance);
 
     relaxOutgoingEdges<REVERSE_DIRECTION>(
-        facade, node, target_weight, target_duration, query_heap, phantom_node);
+        facade, node, target_weight, target_duration, target_distance, query_heap, phantom_node);
 }
 
 } // namespace ch
@@ -235,7 +249,7 @@ void calculateDistances(typename SearchEngineData<ch::Algorithm>::ManyToManyQuer
                                        needsLoopBackwards(source_phantom, target_phantom)))
         {
             auto weight = ch::getLoopWeight<false>(facade, packed_leg.front());
-            if (weight != INVALID_EDGE_WEIGHT)
+            if (std::get<0>(weight) != INVALID_EDGE_WEIGHT)
                 packed_leg.push_back(packed_leg.front());
         }
         if (!packed_leg.empty())
@@ -269,7 +283,7 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table;
+    std::vector<EdgeDistance> distances_table(number_of_entries, MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
@@ -318,6 +332,7 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                                search_space_with_buckets,
                                weights_table,
                                durations_table,
+                               distances_table,
                                middle_nodes_table,
                                source_phantom);
         }
@@ -325,17 +340,21 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
         if (calculate_distance)
         {
             distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
-            calculateDistances(query_heap,
-                               facade,
-                               phantom_nodes,
-                               target_indices,
-                               row_index,
-                               source_index,
-                               source_phantom,
-                               number_of_targets,
-                               search_space_with_buckets,
-                               distances_table,
-                               middle_nodes_table);
+            // TODO: this is a hack to work around stuff
+            if (number_of_entries == 0)
+            {
+                calculateDistances(query_heap,
+                                   facade,
+                                   phantom_nodes,
+                                   target_indices,
+                                   row_index,
+                                   source_index,
+                                   source_phantom,
+                                   number_of_targets,
+                                   search_space_with_buckets,
+                                   distances_table,
+                                   middle_nodes_table);
+            }
         }
     }
 

src/engine/routing_algorithms/many_to_many_mld.cpp

@@ -41,6 +41,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
+                        const EdgeDistance /* distance TODO use this */,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         Args... args)
 {
@@ -77,14 +78,14 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     const auto to_duration = duration + shortcut_durations.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
                     }
                     else if (std::tie(to_weight, to_duration, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration};
+                        query_heap.GetData(to) = {node, true, to_duration, 0};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
@@ -109,14 +110,14 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     const auto to_duration = duration + shortcut_durations.front();
                     if (!query_heap.WasInserted(to))
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration});
+                        query_heap.Insert(to, to_weight, {node, true, to_duration, 0});
                     }
                     else if (std::tie(to_weight, to_duration, node) <
                              std::tie(query_heap.GetKey(to),
                                       query_heap.GetData(to).duration,
                                       query_heap.GetData(to).parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration};
+                        query_heap.GetData(to) = {node, true, to_duration, 0};
                         query_heap.DecreaseKey(to, to_weight);
                     }
                 }
@@ -153,7 +154,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
             {
-                query_heap.Insert(to, to_weight, {node, false, to_duration});
+                query_heap.Insert(to, to_weight, {node, false, to_duration, 0});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration, node) <
@@ -161,7 +162,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                               query_heap.GetData(to).duration,
                               query_heap.GetData(to).parent))
             {
-                query_heap.GetData(to) = {node, false, to_duration};
+                query_heap.GetData(to) = {node, false, to_duration, 0};
                 query_heap.DecreaseKey(to, to_weight);
             }
         }
@@ -178,15 +179,15 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 const std::vector<PhantomNode> &phantom_nodes,
                 std::size_t phantom_index,
                 const std::vector<std::size_t> &phantom_indices,
-                const bool calculate_distance)
+                const bool /* calculate_distance */)
 {
     std::vector<EdgeWeight> weights(phantom_indices.size(), INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
-    std::vector<EdgeDistance> distances_table;
+    std::vector<EdgeDistance> distances_table(phantom_indices.size(), MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
 
     // Collect destination (source) nodes into a map
-    std::unordered_multimap<NodeID, std::tuple<std::size_t, EdgeWeight, EdgeDuration>>
+    std::unordered_multimap<NodeID, std::tuple<std::size_t, EdgeWeight, EdgeDuration, EdgeDistance>>
         target_nodes_index;
     target_nodes_index.reserve(phantom_indices.size());
     for (std::size_t index = 0; index < phantom_indices.size(); ++index)
@@ -201,13 +202,15 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     {phantom_node.forward_segment_id.id,
                      std::make_tuple(index,
                                      phantom_node.GetForwardWeightPlusOffset(),
-                                     phantom_node.GetForwardDuration())});
+                                     phantom_node.GetForwardDuration(),
+                                     phantom_node.GetForwardDistance())});
             if (phantom_node.IsValidReverseTarget())
                 target_nodes_index.insert(
                     {phantom_node.reverse_segment_id.id,
                      std::make_tuple(index,
                                      phantom_node.GetReverseWeightPlusOffset(),
-                                     phantom_node.GetReverseDuration())});
+                                     phantom_node.GetReverseDuration(),
+                                     phantom_node.GetReverseDistance())});
         }
         else if (DIRECTION == REVERSE_DIRECTION)
         {
@@ -216,13 +219,15 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                     {phantom_node.forward_segment_id.id,
                      std::make_tuple(index,
                                      -phantom_node.GetForwardWeightPlusOffset(),
-                                     -phantom_node.GetForwardDuration())});
+                                     -phantom_node.GetForwardDuration(),
+                                     -phantom_node.GetForwardDistance())});
             if (phantom_node.IsValidReverseSource())
                 target_nodes_index.insert(
                     {phantom_node.reverse_segment_id.id,
                      std::make_tuple(index,
                                      -phantom_node.GetReverseWeightPlusOffset(),
-                                     -phantom_node.GetReverseDuration())});
+                                     -phantom_node.GetReverseDuration(),
+                                     -phantom_node.GetReverseDistance())});
         }
     }
 
@@ -232,44 +237,50 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
     auto &query_heap = *(engine_working_data.many_to_many_heap);
 
     // Check if node is in the destinations list and update weights/durations
-    auto update_values = [&](NodeID node, EdgeWeight weight, EdgeDuration duration) {
-        auto candidates = target_nodes_index.equal_range(node);
-        for (auto it = candidates.first; it != candidates.second;)
-        {
-            std::size_t index;
-            EdgeWeight target_weight;
-            EdgeDuration target_duration;
-            std::tie(index, target_weight, target_duration) = it->second;
-
-            const auto path_weight = weight + target_weight;
-            if (path_weight >= 0)
+    auto update_values =
+        [&](NodeID node, EdgeWeight weight, EdgeDuration duration, EdgeDistance distance) {
+            auto candidates = target_nodes_index.equal_range(node);
+            for (auto it = candidates.first; it != candidates.second;)
             {
-                const auto path_duration = duration + target_duration;
+                std::size_t index;
+                EdgeWeight target_weight;
+                EdgeDuration target_duration;
+                EdgeDuration target_distance;
+                std::tie(index, target_weight, target_duration, target_distance) = it->second;
 
-                if (std::tie(path_weight, path_duration) <
-                    std::tie(weights[index], durations[index]))
+                const auto path_weight = weight + target_weight;
+                if (path_weight >= 0)
                 {
-                    weights[index] = path_weight;
-                    durations[index] = path_duration;
-                    middle_nodes_table[index] = node;
+                    const auto path_duration = duration + target_duration;
+                    const auto path_distance = distance + target_distance;
+
+                    if (std::tie(path_weight, path_duration) <
+                        std::tie(weights[index], durations[index]))
+                    {
+                        weights[index] = path_weight;
+                        durations[index] = path_duration;
+                        distances_table[index] = path_distance;
+                        middle_nodes_table[index] = node;
+                    }
+
+                    // Remove node from destinations list
+                    it = target_nodes_index.erase(it);
+                }
+                else
+                {
+                    ++it;
                 }
-
-                // Remove node from destinations list
-                it = target_nodes_index.erase(it);
             }
-            else
-            {
-                ++it;
-            }
-        }
-    };
-
-    auto insert_node = [&](NodeID node, EdgeWeight initial_weight, EdgeDuration initial_duration) {
+        };
 
+    auto insert_node = [&](NodeID node,
+                           EdgeWeight initial_weight,
+                           EdgeDuration initial_duration,
+                           EdgeDistance initial_distance) {
         // Update single node paths
-        update_values(node, initial_weight, initial_duration);
+        update_values(node, initial_weight, initial_duration, initial_distance);
 
-        query_heap.Insert(node, initial_weight, {node, initial_duration});
+        query_heap.Insert(node, initial_weight, {node, initial_duration, initial_distance});
 
         // Place adjacent nodes into heap
         for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -292,8 +303,9 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                                          facade.GetWeightPenaltyForEdgeID(turn_id);
                 const auto edge_duration = initial_duration + facade.GetNodeDuration(node_id) +
                                            facade.GetDurationPenaltyForEdgeID(turn_id);
+                const auto edge_distance = initial_distance;
 
-                query_heap.Insert(to, edge_weight, {node, edge_duration});
+                query_heap.Insert(to, edge_weight, {node, edge_duration, edge_distance});
             }
         }
     };
@@ -307,14 +319,16 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
             {
                 insert_node(phantom_node.forward_segment_id.id,
                             -phantom_node.GetForwardWeightPlusOffset(),
-                            -phantom_node.GetForwardDuration());
+                            -phantom_node.GetForwardDuration(),
+                            -phantom_node.GetForwardDistance());
             }
 
             if (phantom_node.IsValidReverseSource())
             {
                 insert_node(phantom_node.reverse_segment_id.id,
                             -phantom_node.GetReverseWeightPlusOffset(),
-                            -phantom_node.GetReverseDuration());
+                            -phantom_node.GetReverseDuration(),
+                            -phantom_node.GetReverseDistance());
             }
         }
         else if (DIRECTION == REVERSE_DIRECTION)
@@ -323,14 +337,16 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
             {
                 insert_node(phantom_node.forward_segment_id.id,
                             phantom_node.GetForwardWeightPlusOffset(),
-                            phantom_node.GetForwardDuration());
+                            phantom_node.GetForwardDuration(),
+                            phantom_node.GetForwardDistance());
             }
 
             if (phantom_node.IsValidReverseTarget())
             {
                 insert_node(phantom_node.reverse_segment_id.id,
                             phantom_node.GetReverseWeightPlusOffset(),
-                            phantom_node.GetReverseDuration());
+                            phantom_node.GetReverseDuration(),
+                            phantom_node.GetReverseDistance());
             }
         }
     }
@@ -341,22 +357,26 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
         const auto node = query_heap.DeleteMin();
         const auto weight = query_heap.GetKey(node);
         const auto duration = query_heap.GetData(node).duration;
+        const auto distance = query_heap.GetData(node).distance;
 
         // Update values
-        update_values(node, weight, duration);
+        update_values(node, weight, duration, distance);
 
         // Relax outgoing edges
         relaxOutgoingEdges<DIRECTION>(facade,
                                       node,
                                       weight,
                                       duration,
+                                      distance,
                                       query_heap,
                                       phantom_nodes,
                                       phantom_index,
                                       phantom_indices);
     }
 
-    if (calculate_distance)
+    // TODO: re-enable this if we need to fallback
+    // if (calculate_distance)
+    if (false)
     {
         // Initialize unpacking heaps
         engine_working_data.InitializeOrClearFirstThreadLocalStorage(
@@ -497,6 +517,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto source_weight = query_heap.GetKey(node);
     const auto source_duration = query_heap.GetData(node).duration;
+    const auto source_distance = query_heap.GetData(node).distance;
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
@@ -533,7 +554,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     }
 
     relaxOutgoingEdges<DIRECTION>(
-        facade, node, source_weight, source_duration, query_heap, phantom_node);
+        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
 }
 
 template <bool DIRECTION>
@@ -546,6 +567,7 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
+    const auto target_distance = query_heap.GetData(node).distance;
     const auto parent = query_heap.GetData(node).parent;
     const auto from_clique_arc = query_heap.GetData(node).from_clique_arc;
 
@@ -556,8 +578,14 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
 
-    relaxOutgoingEdges<!DIRECTION>(
-        facade, node, target_weight, target_duration, query_heap, phantom_node, maximal_level);
+    relaxOutgoingEdges<!DIRECTION>(facade,
+                                   node,
+                                   target_weight,
+                                   target_duration,
+                                   target_distance,
+                                   query_heap,
+                                   phantom_node,
+                                   maximal_level);
 }
 
 template <bool DIRECTION>

src/extractor/compressed_edge_container.cpp

@@ -396,5 +396,5 @@ std::unique_ptr<SegmentDataContainer> CompressedEdgeContainer::ToSegmentData()
 
     return std::move(segment_data);
 }
-}
-}
+} // namespace extractor
+} // namespace osrm

src/extractor/edge_based_graph_factory.cpp

@@ -51,7 +51,7 @@ template <> struct hash<std::pair<NodeID, NodeID>>
         return seed;
     }
 };
-}
+} // namespace std
 
 // Buffer size of turn_indexes_write_buffer to reduce number of write(v) syscals
 const constexpr int TURN_INDEX_WRITE_BUFFER_SIZE = 1000;
@@ -555,22 +555,21 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                     &scripting_environment,
                                     weight_multiplier,
                                     &conditional_restriction_map](
-            // what nodes will be used? In most cases this will be the id
-            // stored in the edge_data. In case of duplicated nodes (e.g.
-            // due to via-way restrictions), one/both of these might
-            // refer to a newly added edge based node
-            const auto edge_based_node_from,
-            const auto edge_based_node_to,
-            // the situation of the turn
-            const auto node_along_road_entering,
-            const auto node_based_edge_from,
-            const auto intersection_node,
-            const auto node_based_edge_to,
-            const auto &turn_angle,
-            const auto &road_legs_on_the_right,
-            const auto &road_legs_on_the_left,
-            const auto &edge_geometries) {
-
+                                       // what nodes will be used? In most cases this will be the id
+                                       // stored in the edge_data. In case of duplicated nodes (e.g.
+                                       // due to via-way restrictions), one/both of these might
+                                       // refer to a newly added edge based node
+                                       const auto edge_based_node_from,
+                                       const auto edge_based_node_to,
+                                       // the situation of the turn
+                                       const auto node_along_road_entering,
+                                       const auto node_based_edge_from,
+                                       const auto intersection_node,
+                                       const auto node_based_edge_to,
+                                       const auto &turn_angle,
+                                       const auto &road_legs_on_the_right,
+                                       const auto &road_legs_on_the_left,
+                                       const auto &edge_geometries) {
             const auto node_restricted =
                 isRestricted(node_along_road_entering,
                              intersection_node,
@@ -652,16 +651,17 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             // auto turn_id = m_edge_based_edge_list.size();
             auto weight = boost::numeric_cast<EdgeWeight>(edge_data1.weight + weight_penalty);
             auto duration = boost::numeric_cast<EdgeWeight>(edge_data1.duration + duration_penalty);
+            auto distance = boost::numeric_cast<EdgeDistance>(edge_data1.distance);
 
-            EdgeBasedEdge edge_based_edge = {
-                edge_based_node_from,
-                edge_based_node_to,
-                SPECIAL_NODEID, // This will be updated once the main loop
-                                // completes!
-                weight,
-                duration,
-                true,
-                false};
+            EdgeBasedEdge edge_based_edge = {edge_based_node_from,
+                                             edge_based_node_to,
+                                             SPECIAL_NODEID, // This will be updated once the main
+                                                             // loop completes!
+                                             weight,
+                                             duration,
+                                             distance,
+                                             true,
+                                             false};
 
             // We write out the mapping between the edge-expanded edges and the original nodes.
             // Since each edge represents a possible maneuver, external programs can use this to
@@ -693,7 +693,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         //
         tbb::filter_t<tbb::blocked_range<NodeID>, EdgesPipelineBufferPtr> processor_stage(
             tbb::filter::parallel, [&](const tbb::blocked_range<NodeID> &intersection_node_range) {
-
                 auto buffer = std::make_shared<EdgesPipelineBuffer>();
                 buffer->nodes_processed = intersection_node_range.size();
 
@@ -891,7 +890,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                             // TODO: this loop is not optimized - once we have a few
                             //       overrides available, we should index this for faster
                             //       lookups
-                            for (auto & override : unresolved_maneuver_overrides)
+                            for (auto &override : unresolved_maneuver_overrides)
                             {
                                 for (auto &turn : override.turn_sequence)
                                 {
@@ -1032,7 +1031,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         std::vector<EdgeWithData> delayed_data;
         tbb::filter_t<EdgesPipelineBufferPtr, void> output_stage(
             tbb::filter::serial_in_order, [&](auto buffer) {
-
                 routing_progress.PrintAddition(buffer->nodes_processed);
 
                 m_connectivity_checksum = buffer->checksum.update_checksum(m_connectivity_checksum);

src/extractor/extraction_containers.cpp

@@ -99,7 +99,7 @@ inline NodeID mapExternalToInternalNodeID(Iter first, Iter last, const OSMNodeID
     return (it == last || value < *it) ? SPECIAL_NODEID
                                        : static_cast<NodeID>(std::distance(first, it));
 }
-}
+} // namespace
 
 namespace osrm
 {
@@ -277,8 +277,8 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
         {
             if (edge_iterator->result.osm_source_id < node_iterator->node_id)
             {
-                util::Log(logDEBUG) << "Found invalid node reference "
-                                    << edge_iterator->result.source;
+                util::Log(logDEBUG)
+                    << "Found invalid node reference " << edge_iterator->result.source;
                 edge_iterator->result.source = SPECIAL_NODEID;
                 ++edge_iterator;
                 continue;
@@ -387,12 +387,16 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
             const auto weight = edge_iterator->weight_data(distance);
             const auto duration = edge_iterator->duration_data(distance);
 
+            const auto accurate_distance =
+                util::coordinate_calculation::fccApproximateDistance(source_coord, target_coord);
+
             ExtractionSegment segment(source_coord, target_coord, distance, weight, duration);
             scripting_environment.ProcessSegment(segment);
 
             auto &edge = edge_iterator->result;
             edge.weight = std::max<EdgeWeight>(1, std::round(segment.weight * weight_multiplier));
             edge.duration = std::max<EdgeWeight>(1, std::round(segment.duration * 10.));
+            edge.distance = accurate_distance;
 
             // assign new node id
             const auto node_id = mapExternalToInternalNodeID(
@@ -740,7 +744,6 @@ void ExtractionContainers::PrepareManeuverOverrides()
      **/
     auto const find_turn_from_way_tofrom_nodes = [&](auto const &from_segment,
                                                      auto const &to_segment) {
-
         if (from_segment.first_segment_source_id == to_segment.first_segment_source_id)
         {
             return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.first_segment_target_id),
@@ -857,7 +860,6 @@ void ExtractionContainers::PrepareManeuverOverrides()
     // Later, the UnresolvedManeuverOverride will be converted into a final ManeuverOverride
     // once the edge-based-node IDs are generated by the edge-based-graph-factory
     const auto transform = [&](const auto &external, auto &internal) {
-
         // Create a stub override
         auto maneuver_override =
             UnresolvedManeuverOverride{{},
@@ -1036,8 +1038,9 @@ void ExtractionContainers::PrepareRestrictions()
     // translate the turn from one segment onto another into a node restriction (the ways can
     // only
     // be connected at a single location)
-    auto const get_node_restriction_from_OSM_ids = [&](
-        auto const from_id, auto const to_id, const OSMNodeID via_node) {
+    auto const get_node_restriction_from_OSM_ids = [&](auto const from_id,
+                                                       auto const to_id,
+                                                       const OSMNodeID via_node) {
         auto const from_segment_itr = referenced_ways.find(from_id);
         if (from_segment_itr->second.way_id != from_id)
         {

src/extractor/extractor_callbacks.cpp

@@ -75,7 +75,7 @@ void ExtractorCallbacks::ProcessRestriction(const InputConditionalTurnRestrictio
     // util::Log() << restriction.toString();
 }
 
-void ExtractorCallbacks::ProcessManeuverOverride(const InputManeuverOverride & override)
+void ExtractorCallbacks::ProcessManeuverOverride(const InputManeuverOverride &override)
 {
     external_memory.external_maneuver_overrides_list.push_back(override);
 }
@@ -415,6 +415,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
                     0,  // weight
                     0,  // duration
+                    0,  // distance
                     {}, // geometry id
                     static_cast<AnnotationID>(annotation_data_id),
                     {true,
@@ -450,6 +451,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
                     0,  // weight
                     0,  // duration
+                    0,  // distance
                     {}, // geometry id
                     static_cast<AnnotationID>(annotation_data_id),
                     {false,

src/extractor/graph_compressor.cpp

@@ -185,17 +185,18 @@ void GraphCompressor::Compress(
                  * just
                  * like a barrier.
                  */
-                const auto selectAnnotation = [&node_data_container](
-                    const AnnotationID front_annotation, const AnnotationID back_annotation) {
-                    // A lane has tags: u - (front) - v - (back) - w
-                    // During contraction, we keep only one of the tags. Usually the one closer
-                    // to the intersection is preferred. If its empty, however, we keep the
-                    // non-empty one
-                    if (node_data_container[back_annotation].lane_description_id ==
-                        INVALID_LANE_DESCRIPTIONID)
-                        return front_annotation;
-                    return back_annotation;
-                };
+                const auto selectAnnotation =
+                    [&node_data_container](const AnnotationID front_annotation,
+                                           const AnnotationID back_annotation) {
+                        // A lane has tags: u - (front) - v - (back) - w
+                        // During contraction, we keep only one of the tags. Usually the one closer
+                        // to the intersection is preferred. If its empty, however, we keep the
+                        // non-empty one
+                        if (node_data_container[back_annotation].lane_description_id ==
+                            INVALID_LANE_DESCRIPTIONID)
+                            return front_annotation;
+                        return back_annotation;
+                    };
 
                 graph.GetEdgeData(forward_e1).annotation_data = selectAnnotation(
                     fwd_edge_data1.annotation_data, fwd_edge_data2.annotation_data);
@@ -259,6 +260,8 @@ void GraphCompressor::Compress(
                 const auto forward_weight2 = fwd_edge_data2.weight;
                 const auto forward_duration1 = fwd_edge_data1.duration;
                 const auto forward_duration2 = fwd_edge_data2.duration;
+                // const auto forward_distance1 = fwd_edge_data1.distance;
+                const auto forward_distance2 = fwd_edge_data2.distance;
 
                 BOOST_ASSERT(0 != forward_weight1);
                 BOOST_ASSERT(0 != forward_weight2);
@@ -267,6 +270,8 @@ void GraphCompressor::Compress(
                 const auto reverse_weight2 = rev_edge_data2.weight;
                 const auto reverse_duration1 = rev_edge_data1.duration;
                 const auto reverse_duration2 = rev_edge_data2.duration;
+                // const auto reverse_distance1 = rev_edge_data1.distance;
+                const auto reverse_distance2 = rev_edge_data2.distance;
 
                 BOOST_ASSERT(0 != reverse_weight1);
                 BOOST_ASSERT(0 != reverse_weight2);
@@ -279,6 +284,10 @@ void GraphCompressor::Compress(
                 graph.GetEdgeData(forward_e1).duration += forward_duration2;
                 graph.GetEdgeData(reverse_e1).duration += reverse_duration2;
 
+                // add duration of e2's to e1
+                graph.GetEdgeData(forward_e1).distance += forward_distance2;
+                graph.GetEdgeData(reverse_e1).distance += reverse_distance2;
+
                 if (node_weight_penalty != INVALID_EDGE_WEIGHT &&
                     node_duration_penalty != MAXIMAL_EDGE_DURATION)
                 {
@@ -286,6 +295,7 @@ void GraphCompressor::Compress(
                     graph.GetEdgeData(reverse_e1).weight += node_weight_penalty;
                     graph.GetEdgeData(forward_e1).duration += node_duration_penalty;
                     graph.GetEdgeData(reverse_e1).duration += node_duration_penalty;
+                    // Note: no penalties for distances
                 }
 
                 // extend e1's to targets of e2's
@@ -359,5 +369,5 @@ void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
     util::Log() << "Node compression ratio: " << new_node_count / (double)original_number_of_nodes;
     util::Log() << "Edge compression ratio: " << new_edge_count / (double)original_number_of_edges;
 }
-}
-}
+} // namespace extractor
+} // namespace osrm

src/tools/contract.cpp

@@ -81,7 +81,8 @@ return_code parseArguments(int argc,
         "time-zone-file",
         boost::program_options::value<std::string>(&contractor_config.updater_config.tz_file_path),
         "Required for conditional turn restriction parsing, provide a geojson file containing "
-        "time zone boundaries");
+        "time zone boundaries")("cache-distances",boost::program_options::bool_switch(&contractor_config.cache_distances)->default_value(false),
+        "Store distances for CH edges, avoiding the need for query-time re-calculation.");
 
     // hidden options, will be allowed on command line, but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");

src/tools/store.cpp

@@ -82,7 +82,8 @@ void springClean()
     }
     else
     {
-        for (auto key : util::irange<storage::SharedRegionRegister::RegionID>(0, storage::SharedRegionRegister::MAX_SHM_KEYS))
+        for (auto key : util::irange<storage::SharedRegionRegister::RegionID>(
+                 0, storage::SharedRegionRegister::MAX_SHM_KEYS))
         {
             deleteRegion(key);
         }