Bump backed version to latest.4

Does not run the nodejs tests in sanitized builds. We'd have to

    export LD_PRELOAD='/usr/lib/x86_64-linux-gnu/libasan.so.2'

the asan lib. But it seems like our Clang from mason does not like the
system's libasan. Also we'd need a suppression file for v8 and node.

.travis.yml

@@ -223,6 +223,10 @@ script:
   - ./unit_tests/util-tests
   - ./unit_tests/server-tests
   - ./unit_tests/partition-tests
+  - |
+    if [ -n "${ENABLE_NODE_BINDINGS}" ] && [ -z "${ENABLE_SANITIZER}" ]; then
+      npm run nodejs-tests
+    fi
   - popd
   - yarn test
 

CMakeLists.txt

@@ -303,6 +303,8 @@ endif()
 if (ENABLE_SANITIZER)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
   set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -fsanitize=address")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
 endif()
 
 # Configuring compilers

include/customizer/cell_customizer.hpp

@@ -5,7 +5,8 @@
 #include "partition/multi_level_partition.hpp"
 #include "util/binary_heap.hpp"
 
-#include <boost/thread/tss.hpp>
+#include <tbb/enumerable_thread_specific.h>
+
 #include <unordered_set>
 
 namespace osrm
@@ -15,12 +16,22 @@ namespace customizer
 
 class CellCustomizer
 {
+  private:
+    struct HeapData
+    {
+        bool from_clique;
+    };
 
   public:
+    using Heap =
+        util::BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::ArrayStorage<NodeID, int>>;
+    using HeapPtr = tbb::enumerable_thread_specific<Heap>;
+
     CellCustomizer(const partition::MultiLevelPartition &partition) : partition(partition) {}
 
     template <typename GraphT>
-    void Customize(const GraphT &graph, partition::CellStorage &cells, LevelID level, CellID id)
+    void Customize(
+        const GraphT &graph, Heap &heap, partition::CellStorage &cells, LevelID level, CellID id)
     {
         auto cell = cells.GetCell(level, id);
         auto destinations = cell.GetDestinationNodes();
@@ -29,8 +40,8 @@ class CellCustomizer
         for (auto source : cell.GetSourceNodes())
         {
             std::unordered_set<NodeID> destinations_set(destinations.begin(), destinations.end());
-            Heap heap(graph.GetNumberOfNodes());
-            heap.Insert(source, 0, {});
+            heap.Clear();
+            heap.Insert(source, 0, {false});
 
             // explore search space
             while (!heap.Empty() && !destinations_set.empty())
@@ -60,26 +71,23 @@ class CellCustomizer
 
     template <typename GraphT> void Customize(const GraphT &graph, partition::CellStorage &cells)
     {
+        Heap heap_exemplar(graph.GetNumberOfNodes());
+        HeapPtr heaps(heap_exemplar);
+
         for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
         {
             tbb::parallel_for(tbb::blocked_range<std::size_t>(0, partition.GetNumberOfCells(level)),
                               [&](const tbb::blocked_range<std::size_t> &range) {
+                                  auto &heap = heaps.local();
                                   for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                   {
-                                      Customize(graph, cells, level, id);
+                                      Customize(graph, heap, cells, level, id);
                                   }
                               });
         }
     }
 
   private:
-    struct HeapData
-    {
-    };
-    using Heap = util::
-        BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::UnorderedMapStorage<NodeID, int>>;
-    using HeapPtr = boost::thread_specific_ptr<Heap>;
-
     template <bool first_level, typename GraphT>
     void RelaxNode(const GraphT &graph,
                    const partition::CellStorage &cells,
@@ -88,29 +96,42 @@ class CellCustomizer
                    NodeID node,
                    EdgeWeight weight) const
     {
+        BOOST_ASSERT(heap.WasInserted(node));
+
         if (!first_level)
         {
-            // Relax sub-cell nodes
-            auto subcell_id = partition.GetCell(level - 1, node);
-            auto subcell = cells.GetCell(level - 1, subcell_id);
-            auto subcell_destination = subcell.GetDestinationNodes().begin();
-            for (auto subcell_weight : subcell.GetOutWeight(node))
+            // if we reaches this node from a clique arc we don't need to scan
+            // the clique arcs again because of the triangle inequality
+            //
+            // d(parent, node) + d(node, v) >= d(parent, v)
+            //
+            // And if there is a path (parent, node, v) there must also be a
+            // clique arc (parent, v) with d(parent, v).
+            if (!heap.GetData(node).from_clique)
             {
-                if (subcell_weight != INVALID_EDGE_WEIGHT)
+                // Relax sub-cell nodes
+                auto subcell_id = partition.GetCell(level - 1, node);
+                auto subcell = cells.GetCell(level - 1, subcell_id);
+                auto subcell_destination = subcell.GetDestinationNodes().begin();
+                for (auto subcell_weight : subcell.GetOutWeight(node))
                 {
-                    const NodeID to = *subcell_destination;
-                    const EdgeWeight to_weight = subcell_weight + weight;
-                    if (!heap.WasInserted(to))
+                    if (subcell_weight != INVALID_EDGE_WEIGHT)
                     {
-                        heap.Insert(to, to_weight, {});
+                        const NodeID to = *subcell_destination;
+                        const EdgeWeight to_weight = subcell_weight + weight;
+                        if (!heap.WasInserted(to))
+                        {
+                            heap.Insert(to, to_weight, {true});
+                        }
+                        else if (to_weight < heap.GetKey(to))
+                        {
+                            heap.DecreaseKey(to, to_weight);
+                            heap.GetData(to).from_clique = true;
+                        }
                     }
-                    else if (to_weight < heap.GetKey(to))
-                    {
-                        heap.DecreaseKey(to, to_weight);
-                    }
-                }
 
-                ++subcell_destination;
+                    ++subcell_destination;
+                }
             }
         }
 
@@ -126,11 +147,12 @@ class CellCustomizer
                 const EdgeWeight to_weight = data.weight + weight;
                 if (!heap.WasInserted(to))
                 {
-                    heap.Insert(to, to_weight, {});
+                    heap.Insert(to, to_weight, {false});
                 }
                 else if (to_weight < heap.GetKey(to))
                 {
                     heap.DecreaseKey(to, to_weight);
+                    heap.GetData(to).from_clique = false;
                 }
             }
         }

include/customizer/edge_based_graph.hpp

@@ -7,6 +7,8 @@
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/filesystem/path.hpp>
 
 namespace osrm
@@ -16,16 +18,17 @@ namespace customizer
 
 using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;
 
-struct MultiLevelEdgeBasedGraph : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>
+struct MultiLevelEdgeBasedGraph
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
     using Base::Base;
 };
 
 struct MultiLevelEdgeBasedGraphView
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
     using Base::Base;
 };
 

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -20,6 +20,7 @@
 #include "partition/multi_level_partition.hpp"
 
 #include "storage/shared_datatype.hpp"
+#include "storage/shared_memory_ownership.hpp"
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
@@ -61,7 +62,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
     : public datafacade::AlgorithmDataFacade<algorithm::CH>
 {
   private:
-    using QueryGraph = util::StaticGraph<EdgeData, true>;
+    using QueryGraph = util::StaticGraph<EdgeData, storage::Ownership::View>;
     using GraphNode = QueryGraph::NodeArrayEntry;
     using GraphEdge = QueryGraph::EdgeArrayEntry;
 
@@ -78,9 +79,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
         auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
             memory_block, storage::DataLayout::CH_GRAPH_EDGE_LIST);
 
-        util::ShM<GraphNode, true>::vector node_list(
+        util::vector_view<GraphNode> node_list(
             graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_NODE_LIST]);
-        util::ShM<GraphEdge, true>::vector edge_list(
+        util::vector_view<GraphEdge> edge_list(
             graph_edges_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_EDGE_LIST]);
         m_query_graph.reset(new QueryGraph(node_list, edge_list));
     }
@@ -154,7 +155,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
     : public datafacade::AlgorithmDataFacade<algorithm::CoreCH>
 {
   private:
-    util::ShM<bool, true>::vector m_is_core_node;
+    util::vector_view<bool> m_is_core_node;
 
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -163,7 +164,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
     {
         auto core_marker_ptr =
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::CH_CORE_MARKER);
-        util::ShM<bool, true>::vector is_core_node(
+        util::vector_view<bool> is_core_node(
             core_marker_ptr, data_layout.num_entries[storage::DataLayout::CH_CORE_MARKER]);
         m_is_core_node = std::move(is_core_node);
     }
@@ -199,10 +200,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 {
   private:
     using super = BaseDataFacade;
-    using IndexBlock = util::RangeTable<16, true>::BlockT;
+    using IndexBlock = util::RangeTable<16, storage::Ownership::View>::BlockT;
     using RTreeLeaf = super::RTreeLeaf;
     using SharedRTree =
-        util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>;
+        util::StaticRTree<RTreeLeaf, util::vector_view<util::Coordinate>, storage::Ownership::View>;
     using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
     using RTreeNode = SharedRTree::TreeNode;
 
@@ -211,28 +212,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::Datasources *m_datasources;
 
     unsigned m_check_sum;
-    util::ShM<util::Coordinate, true>::vector m_coordinate_list;
-    util::PackedVector<OSMNodeID, true> m_osmnodeid_list;
-    util::ShM<GeometryID, true>::vector m_via_geometry_list;
-    util::ShM<NameID, true>::vector m_name_ID_list;
-    util::ShM<LaneDataID, true>::vector m_lane_data_id;
-    util::ShM<extractor::guidance::TurnInstruction, true>::vector m_turn_instruction_list;
-    util::ShM<extractor::TravelMode, true>::vector m_travel_mode_list;
-    util::ShM<util::guidance::TurnBearing, true>::vector m_pre_turn_bearing;
-    util::ShM<util::guidance::TurnBearing, true>::vector m_post_turn_bearing;
+    util::vector_view<util::Coordinate> m_coordinate_list;
+    util::PackedVector<OSMNodeID, storage::Ownership::View> m_osmnodeid_list;
+    util::vector_view<GeometryID> m_via_geometry_list;
+    util::vector_view<NameID> m_name_ID_list;
+    util::vector_view<LaneDataID> m_lane_data_id;
+    util::vector_view<extractor::guidance::TurnInstruction> m_turn_instruction_list;
+    util::vector_view<extractor::TravelMode> m_travel_mode_list;
+    util::vector_view<util::guidance::TurnBearing> m_pre_turn_bearing;
+    util::vector_view<util::guidance::TurnBearing> m_post_turn_bearing;
     util::NameTable m_names_table;
-    util::ShM<unsigned, true>::vector m_name_begin_indices;
-    util::ShM<bool, true>::vector m_is_core_node;
-    util::ShM<std::uint32_t, true>::vector m_lane_description_offsets;
-    util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector m_lane_description_masks;
-    util::ShM<TurnPenalty, true>::vector m_turn_weight_penalties;
-    util::ShM<TurnPenalty, true>::vector m_turn_duration_penalties;
+    util::vector_view<unsigned> m_name_begin_indices;
+    util::vector_view<bool> m_is_core_node;
+    util::vector_view<std::uint32_t> m_lane_description_offsets;
+    util::vector_view<extractor::guidance::TurnLaneType::Mask> m_lane_description_masks;
+    util::vector_view<TurnPenalty> m_turn_weight_penalties;
+    util::vector_view<TurnPenalty> m_turn_duration_penalties;
     extractor::SegmentDataView segment_data;
 
-    util::ShM<char, true>::vector m_datasource_name_data;
-    util::ShM<std::size_t, true>::vector m_datasource_name_offsets;
-    util::ShM<std::size_t, true>::vector m_datasource_name_lengths;
-    util::ShM<util::guidance::LaneTupleIdPair, true>::vector m_lane_tupel_id_pairs;
+    util::vector_view<char> m_datasource_name_data;
+    util::vector_view<std::size_t> m_datasource_name_offsets;
+    util::vector_view<std::size_t> m_datasource_name_lengths;
+    util::vector_view<util::guidance::LaneTupleIdPair> m_lane_tupel_id_pairs;
 
     std::unique_ptr<SharedRTree> m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
@@ -240,17 +241,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     util::NameTable m_name_table;
     // bearing classes by node based node
-    util::ShM<BearingClassID, true>::vector m_bearing_class_id_table;
+    util::vector_view<BearingClassID> m_bearing_class_id_table;
     // entry class IDs
-    util::ShM<EntryClassID, true>::vector m_entry_class_id_list;
+    util::vector_view<EntryClassID> m_entry_class_id_list;
 
     // the look-up table for entry classes. An entry class lists the possibility of entry for all
     // available turns. Such a class id is stored with every edge.
-    util::ShM<util::guidance::EntryClass, true>::vector m_entry_class_table;
+    util::vector_view<util::guidance::EntryClass> m_entry_class_table;
     // the look-up table for distinct bearing classes. A bearing class lists the available bearings
     // at an intersection
-    std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
-    util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;
+    std::shared_ptr<util::RangeTable<16, storage::Ownership::View>> m_bearing_ranges_table;
+    util::vector_view<DiscreteBearing> m_bearing_values_table;
 
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -326,52 +327,52 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
         const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
             memory_block, storage::DataLayout::TRAVEL_MODE);
-        util::ShM<extractor::TravelMode, true>::vector travel_mode_list(
+        util::vector_view<extractor::TravelMode> travel_mode_list(
             travel_mode_list_ptr, data_layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
         m_travel_mode_list = std::move(travel_mode_list);
 
         const auto lane_data_id_ptr =
             data_layout.GetBlockPtr<LaneDataID>(memory_block, storage::DataLayout::LANE_DATA_ID);
-        util::ShM<LaneDataID, true>::vector lane_data_id(
+        util::vector_view<LaneDataID> lane_data_id(
             lane_data_id_ptr, data_layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
         m_lane_data_id = std::move(lane_data_id);
 
         const auto lane_tupel_id_pair_ptr =
             data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
                 memory_block, storage::DataLayout::TURN_LANE_DATA);
-        util::ShM<util::guidance::LaneTupleIdPair, true>::vector lane_tupel_id_pair(
+        util::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
             lane_tupel_id_pair_ptr, data_layout.num_entries[storage::DataLayout::TURN_LANE_DATA]);
         m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
 
         const auto turn_instruction_list_ptr =
             data_layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
                 memory_block, storage::DataLayout::TURN_INSTRUCTION);
-        util::ShM<extractor::guidance::TurnInstruction, true>::vector turn_instruction_list(
+        util::vector_view<extractor::guidance::TurnInstruction> turn_instruction_list(
             turn_instruction_list_ptr,
             data_layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
         m_turn_instruction_list = std::move(turn_instruction_list);
 
         const auto name_id_list_ptr =
             data_layout.GetBlockPtr<NameID>(memory_block, storage::DataLayout::NAME_ID_LIST);
-        util::ShM<NameID, true>::vector name_id_list(
+        util::vector_view<NameID> name_id_list(
             name_id_list_ptr, data_layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
         m_name_ID_list = std::move(name_id_list);
 
         const auto entry_class_id_list_ptr =
             data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID);
-        typename util::ShM<EntryClassID, true>::vector entry_class_id_list(
+        typename util::vector_view<EntryClassID> entry_class_id_list(
             entry_class_id_list_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
         m_entry_class_id_list = std::move(entry_class_id_list);
 
         const auto pre_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
             memory_block, storage::DataLayout::PRE_TURN_BEARING);
-        typename util::ShM<util::guidance::TurnBearing, true>::vector pre_turn_bearing(
+        typename util::vector_view<util::guidance::TurnBearing> pre_turn_bearing(
             pre_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
         m_pre_turn_bearing = std::move(pre_turn_bearing);
 
         const auto post_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
             memory_block, storage::DataLayout::POST_TURN_BEARING);
-        typename util::ShM<util::guidance::TurnBearing, true>::vector post_turn_bearing(
+        typename util::vector_view<util::guidance::TurnBearing> post_turn_bearing(
             post_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
         m_post_turn_bearing = std::move(post_turn_bearing);
     }
@@ -380,7 +381,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto via_geometry_list_ptr =
             data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
-        util::ShM<GeometryID, true>::vector via_geometry_list(
+        util::vector_view<GeometryID> via_geometry_list(
             via_geometry_list_ptr, data_layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
         m_via_geometry_list = std::move(via_geometry_list);
     }
@@ -398,14 +399,14 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
             memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::ShM<std::uint32_t, true>::vector offsets(
+        util::vector_view<std::uint32_t> offsets(
             offsets_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]);
         m_lane_description_offsets = std::move(offsets);
 
         auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>(
             memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);
 
-        util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector masks(
+        util::vector_view<extractor::guidance::TurnLaneType::Mask> masks(
             masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
         m_lane_description_masks = std::move(masks);
     }
@@ -414,12 +415,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
             memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES);
-        m_turn_weight_penalties = util::ShM<TurnPenalty, true>::vector(
+        m_turn_weight_penalties = util::vector_view<TurnPenalty>(
             turn_weight_penalties_ptr,
             data_layout.num_entries[storage::DataLayout::TURN_WEIGHT_PENALTIES]);
         auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
             memory_block, storage::DataLayout::TURN_DURATION_PENALTIES);
-        m_turn_duration_penalties = util::ShM<TurnPenalty, true>::vector(
+        m_turn_duration_penalties = util::vector_view<TurnPenalty>(
             turn_duration_penalties_ptr,
             data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
     }
@@ -428,42 +429,42 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto geometries_index_ptr =
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::ShM<unsigned, true>::vector geometry_begin_indices(
+        util::vector_view<unsigned> geometry_begin_indices(
             geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);
 
         auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
             memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::ShM<NodeID, true>::vector geometry_node_list(
+        util::vector_view<NodeID> geometry_node_list(
             geometries_node_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST]);
 
         auto geometries_fwd_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_fwd_weight_list(
+        util::vector_view<EdgeWeight> geometry_fwd_weight_list(
             geometries_fwd_weight_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]);
 
         auto geometries_rev_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_rev_weight_list(
+        util::vector_view<EdgeWeight> geometry_rev_weight_list(
             geometries_rev_weight_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]);
 
         auto geometries_fwd_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_fwd_duration_list(
+        util::vector_view<EdgeWeight> geometry_fwd_duration_list(
             geometries_fwd_duration_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]);
 
         auto geometries_rev_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
             memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_rev_duration_list(
+        util::vector_view<EdgeWeight> geometry_rev_duration_list(
             geometries_rev_duration_list_ptr,
             data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]);
 
         auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
             memory_block, storage::DataLayout::DATASOURCES_LIST);
-        util::ShM<DatasourceID, true>::vector datasources_list(
+        util::vector_view<DatasourceID> datasources_list(
             datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);
 
         segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
@@ -482,13 +483,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
             memory_block, storage::DataLayout::BEARING_CLASSID);
-        typename util::ShM<BearingClassID, true>::vector bearing_class_id_table(
+        typename util::vector_view<BearingClassID> bearing_class_id_table(
             bearing_class_id_ptr, data_layout.num_entries[storage::DataLayout::BEARING_CLASSID]);
         m_bearing_class_id_table = std::move(bearing_class_id_table);
 
         auto bearing_class_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
             memory_block, storage::DataLayout::BEARING_VALUES);
-        typename util::ShM<DiscreteBearing, true>::vector bearing_class_table(
+        typename util::vector_view<DiscreteBearing> bearing_class_table(
             bearing_class_ptr, data_layout.num_entries[storage::DataLayout::BEARING_VALUES]);
         m_bearing_values_table = std::move(bearing_class_table);
 
@@ -496,17 +497,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS);
         auto blocks_ptr =
             data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS);
-        util::ShM<unsigned, true>::vector bearing_offsets(
+        util::vector_view<unsigned> bearing_offsets(
             offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
-        util::ShM<IndexBlock, true>::vector bearing_blocks(
+        util::vector_view<IndexBlock> bearing_blocks(
             blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);
 
-        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, true>>(
+        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, storage::Ownership::View>>(
             bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size()));
 
         auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
             memory_block, storage::DataLayout::ENTRY_CLASS);
-        typename util::ShM<util::guidance::EntryClass, true>::vector entry_class_table(
+        typename util::vector_view<util::guidance::EntryClass> entry_class_table(
             entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
         m_entry_class_table = std::move(entry_class_table);
     }
@@ -929,15 +930,13 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
                 memory_block, storage::DataLayout::MLD_PARTITION);
             auto partition_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::ShM<PartitionID, true>::vector partition(mld_partition_ptr,
-                                                           partition_entries_count);
+            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
 
             auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
                 memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN);
             auto children_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            util::ShM<CellID, true>::vector cell_to_children(mld_chilren_ptr,
-                                                             children_entries_count);
+            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
 
             mld_partition =
                 partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
@@ -969,15 +968,15 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
             auto cell_level_offsets_entries_count =
                 data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
 
-            util::ShM<EdgeWeight, true>::vector weights(mld_cell_weights_ptr, weight_entries_count);
-            util::ShM<NodeID, true>::vector source_boundary(mld_source_boundary_ptr,
-                                                            source_boundary_entries_count);
-            util::ShM<NodeID, true>::vector destination_boundary(
-                mld_destination_boundary_ptr, destination_boundary_entries_count);
-            util::ShM<partition::CellStorageView::CellData, true>::vector cells(
-                mld_cells_ptr, cells_entries_counts);
-            util::ShM<std::uint64_t, true>::vector level_offsets(mld_cell_level_offsets_ptr,
-                                                                 cell_level_offsets_entries_count);
+            util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
+            util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
+                                                      source_boundary_entries_count);
+            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
+                                                           destination_boundary_entries_count);
+            util::vector_view<partition::CellStorageView::CellData> cells(mld_cells_ptr,
+                                                                          cells_entries_counts);
+            util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
+                                                           cell_level_offsets_entries_count);
 
             mld_cell_storage = partition::CellStorageView{std::move(weights),
                                                           std::move(source_boundary),
@@ -997,11 +996,11 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
         auto graph_node_to_offset_ptr = data_layout.GetBlockPtr<QueryGraph::EdgeOffset>(
             memory_block, storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET);
 
-        util::ShM<GraphNode, true>::vector node_list(
+        util::vector_view<GraphNode> node_list(
             graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
-        util::ShM<GraphEdge, true>::vector edge_list(
+        util::vector_view<GraphEdge> edge_list(
             graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
-        util::ShM<QueryGraph::EdgeOffset, true>::vector node_to_offset(
+        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
             graph_node_to_offset_ptr,
             data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);
 

include/extractor/segment_data_container.hpp

@@ -4,6 +4,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -22,24 +24,24 @@ class CompressedEdgeContainer;
 
 namespace detail
 {
-template <bool UseShareMemory> class SegmentDataContainerImpl;
+template <storage::Ownership Ownership> class SegmentDataContainerImpl;
 }
 
 namespace io
 {
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
 inline void read(const boost::filesystem::path &path,
-                 detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
-template <bool UseShareMemory>
+                 detail::SegmentDataContainerImpl<Ownership> &segment_data);
+template <storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+                  const detail::SegmentDataContainerImpl<Ownership> &segment_data);
 }
 
 namespace detail
 {
-template <bool UseShareMemory> class SegmentDataContainerImpl
+template <storage::Ownership Ownership> class SegmentDataContainerImpl
 {
-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
 
     friend CompressedEdgeContainer;
 
@@ -188,12 +190,11 @@ template <bool UseShareMemory> class SegmentDataContainerImpl
     auto GetNumberOfGeometries() const { return index.size() - 1; }
     auto GetNumberOfSegments() const { return fwd_weights.size(); }
 
+    friend void io::read<Ownership>(const boost::filesystem::path &path,
+                                    detail::SegmentDataContainerImpl<Ownership> &segment_data);
     friend void
-    io::read<UseShareMemory>(const boost::filesystem::path &path,
-                             detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
-    friend void
-    io::write<UseShareMemory>(const boost::filesystem::path &path,
-                              const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+    io::write<Ownership>(const boost::filesystem::path &path,
+                         const detail::SegmentDataContainerImpl<Ownership> &segment_data);
 
   private:
     Vector<std::uint32_t> index;
@@ -206,8 +207,8 @@ template <bool UseShareMemory> class SegmentDataContainerImpl
 };
 }
 
-using SegmentDataView = detail::SegmentDataContainerImpl<true>;
-using SegmentDataContainer = detail::SegmentDataContainerImpl<false>;
+using SegmentDataView = detail::SegmentDataContainerImpl<storage::Ownership::View>;
+using SegmentDataContainer = detail::SegmentDataContainerImpl<storage::Ownership::Container>;
 }
 }
 

include/partition/cell_storage.hpp

@@ -10,6 +10,7 @@
 #include "util/typedefs.hpp"
 
 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"
 
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -26,24 +27,23 @@ namespace partition
 {
 namespace detail
 {
-template <bool UseShareMemory> class CellStorageImpl;
+template <storage::Ownership Ownership> class CellStorageImpl;
 }
-using CellStorage = detail::CellStorageImpl<false>;
-using CellStorageView = detail::CellStorageImpl<true>;
+using CellStorage = detail::CellStorageImpl<storage::Ownership::Container>;
+using CellStorageView = detail::CellStorageImpl<storage::Ownership::View>;
 
 namespace io
 {
-template <bool UseShareMemory>
-inline void read(const boost::filesystem::path &path,
-                 detail::CellStorageImpl<UseShareMemory> &storage);
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
+inline void read(const boost::filesystem::path &path, detail::CellStorageImpl<Ownership> &storage);
+template <storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const detail::CellStorageImpl<UseShareMemory> &storage);
+                  const detail::CellStorageImpl<Ownership> &storage);
 }
 
 namespace detail
 {
-template <bool UseShareMemory> class CellStorageImpl
+template <storage::Ownership Ownership> class CellStorageImpl
 {
   public:
     using WeightOffset = std::uint32_t;
@@ -65,7 +65,7 @@ template <bool UseShareMemory> class CellStorageImpl
     };
 
   private:
-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
 
     // Implementation of the cell view. We need a template parameter here
     // because we need to derive a read-only and read-write view from this.
@@ -185,7 +185,8 @@ template <bool UseShareMemory> class CellStorageImpl
 
     CellStorageImpl() {}
 
-    template <typename GraphT, typename = std::enable_if<!UseShareMemory>>
+    template <typename GraphT,
+              typename = std::enable_if<Ownership == storage::Ownership::Container>>
     CellStorageImpl(const partition::MultiLevelPartition &partition, const GraphT &base_graph)
     {
         // pre-allocate storge for CellData so we can have random access to it by cell id
@@ -314,7 +315,7 @@ template <bool UseShareMemory> class CellStorageImpl
         weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT);
     }
 
-    template <typename = std::enable_if<UseShareMemory>>
+    template <typename = std::enable_if<Ownership == storage::Ownership::View>>
     CellStorageImpl(Vector<EdgeWeight> weights_,
                     Vector<NodeID> source_boundary_,
                     Vector<NodeID> destination_boundary_,
@@ -339,7 +340,8 @@ template <bool UseShareMemory> class CellStorageImpl
                          destination_boundary.empty() ? nullptr : destination_boundary.data()};
     }
 
-    template <typename = std::enable_if<!UseShareMemory>> Cell GetCell(LevelID level, CellID id)
+    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    Cell GetCell(LevelID level, CellID id)
     {
         const auto level_index = LevelIDToIndex(level);
         BOOST_ASSERT(level_index < level_to_cell_offset.size());
@@ -350,10 +352,10 @@ template <bool UseShareMemory> class CellStorageImpl
             cells[cell_index], weights.data(), source_boundary.data(), destination_boundary.data()};
     }
 
-    friend void io::read<UseShareMemory>(const boost::filesystem::path &path,
-                                         detail::CellStorageImpl<UseShareMemory> &storage);
-    friend void io::write<UseShareMemory>(const boost::filesystem::path &path,
-                                          const detail::CellStorageImpl<UseShareMemory> &storage);
+    friend void io::read<Ownership>(const boost::filesystem::path &path,
+                                    detail::CellStorageImpl<Ownership> &storage);
+    friend void io::write<Ownership>(const boost::filesystem::path &path,
+                                     const detail::CellStorageImpl<Ownership> &storage);
 
   private:
     Vector<EdgeWeight> weights;

include/partition/io.hpp

@@ -7,6 +7,7 @@
 #include "partition/multi_level_partition.hpp"
 
 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"
 
 namespace osrm
 {
@@ -15,9 +16,8 @@ namespace partition
 namespace io
 {
 
-template <typename EdgeDataT, bool UseSharedMemory>
-inline void read(const boost::filesystem::path &path,
-                 MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
     const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
     storage::io::FileReader reader{path, fingerprint};
@@ -27,9 +27,9 @@ inline void read(const boost::filesystem::path &path,
     reader.DeserializeVector(graph.edge_to_level);
 }
 
-template <typename EdgeDataT, bool UseSharedMemory>
+template <typename EdgeDataT, storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
     const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
     storage::io::FileWriter writer{path, fingerprint};

include/partition/multi_level_graph.hpp

@@ -3,6 +3,8 @@
 
 #include "partition/multi_level_partition.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include "util/static_graph.hpp"
 
 #include <tbb/parallel_sort.h>
@@ -14,24 +16,23 @@ namespace osrm
 {
 namespace partition
 {
-template <typename EdgeDataT, bool UseSharedMemory> class MultiLevelGraph;
+template <typename EdgeDataT, storage::Ownership Ownership> class MultiLevelGraph;
 
 namespace io
 {
-template <typename EdgeDataT, bool UseSharedMemory>
-void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+template <typename EdgeDataT, storage::Ownership Ownership>
+void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, Ownership> &graph);
 
-template <typename EdgeDataT, bool UseSharedMemory>
-void write(const boost::filesystem::path &path,
-           const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+template <typename EdgeDataT, storage::Ownership Ownership>
+void write(const boost::filesystem::path &path, const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 }
 
-template <typename EdgeDataT, bool UseSharedMemory>
-class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
+template <typename EdgeDataT, storage::Ownership Ownership>
+class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
 {
   private:
-    using SuperT = util::StaticGraph<EdgeDataT, UseSharedMemory>;
-    template <typename T> using Vector = typename util::ShM<T, UseSharedMemory>::vector;
+    using SuperT = util::StaticGraph<EdgeDataT, Ownership>;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
 
   public:
     // We limit each node to have 255 edges
@@ -189,12 +190,10 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
         node_to_edge_offset.push_back(mlp.GetNumberOfLevels());
     }
 
-    friend void
-    io::read<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
-                                         MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
-    friend void
-    io::write<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
-                                          const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+    friend void io::read<EdgeDataT, Ownership>(const boost::filesystem::path &path,
+                                               MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    friend void io::write<EdgeDataT, Ownership>(const boost::filesystem::path &path,
+                                                const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 
     Vector<EdgeOffset> node_to_edge_offset;
 };

include/partition/multi_level_partition.hpp

@@ -8,6 +8,7 @@
 #include "util/typedefs.hpp"
 
 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"
 
 #include <algorithm>
 #include <array>
@@ -25,31 +26,30 @@ namespace partition
 {
 namespace detail
 {
-template <bool UseShareMemory> class MultiLevelPartitionImpl;
+template <storage::Ownership Ownership> class MultiLevelPartitionImpl;
 }
-using MultiLevelPartition = detail::MultiLevelPartitionImpl<false>;
-using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<true>;
+using MultiLevelPartition = detail::MultiLevelPartitionImpl<storage::Ownership::Container>;
+using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<storage::Ownership::View>;
 
 namespace io
 {
-template <bool UseShareMemory>
-void read(const boost::filesystem::path &file,
-          detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
+void read(const boost::filesystem::path &file, detail::MultiLevelPartitionImpl<Ownership> &mlp);
+template <storage::Ownership Ownership>
 void write(const boost::filesystem::path &file,
-           const detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
+           const detail::MultiLevelPartitionImpl<Ownership> &mlp);
 }
 
 namespace detail
 {
 
-template <bool UseShareMemory> class MultiLevelPartitionImpl final
+template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
 {
     // we will support at most 16 levels
     static const constexpr std::uint8_t MAX_NUM_LEVEL = 16;
     static const constexpr std::uint8_t NUM_PARTITION_BITS = sizeof(PartitionID) * CHAR_BIT;
 
-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
 
   public:
     // Contains all data necessary to describe the level hierarchy
@@ -68,7 +68,7 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
     // cell_sizes is index by level (starting at 0, the base graph).
     // However level 0 always needs to have cell size 1, since it is the
     // basegraph.
-    template <typename = typename std::enable_if<!UseShareMemory>>
+    template <typename = typename std::enable_if<Ownership == storage::Ownership::Container>>
     MultiLevelPartitionImpl(const std::vector<std::vector<CellID>> &partitions,
                             const std::vector<std::uint32_t> &lidx_to_num_cells)
         : level_data(MakeLevelData(lidx_to_num_cells))
@@ -76,7 +76,7 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
         InitializePartitionIDs(partitions);
     }
 
-    template <typename = typename std::enable_if<UseShareMemory>>
+    template <typename = typename std::enable_if<Ownership == storage::Ownership::View>>
     MultiLevelPartitionImpl(LevelData level_data,
                             Vector<PartitionID> partition_,
                             Vector<CellID> cell_to_children_)
@@ -134,10 +134,10 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
         return cell_to_children[offset + cell + 1];
     }
 
-    friend void io::read<UseShareMemory>(const boost::filesystem::path &file,
-                                         MultiLevelPartitionImpl &mlp);
-    friend void io::write<UseShareMemory>(const boost::filesystem::path &file,
-                                          const MultiLevelPartitionImpl &mlp);
+    friend void io::read<Ownership>(const boost::filesystem::path &file,
+                                    MultiLevelPartitionImpl &mlp);
+    friend void io::write<Ownership>(const boost::filesystem::path &file,
+                                     const MultiLevelPartitionImpl &mlp);
 
   private:
     auto MakeLevelData(const std::vector<std::uint32_t> &lidx_to_num_cells)

include/storage/shared_memory.hpp

@@ -25,6 +25,8 @@
 #include <exception>
 #include <thread>
 
+#include "storage/shared_memory_ownership.hpp"
+
 namespace osrm
 {
 namespace storage

include/storage/shared_memory_ownership.hpp

@@ -0,0 +1,17 @@
+#ifndef SHARED_MEMORY_OWNERSHIP_HPP
+#define SHARED_MEMORY_OWNERSHIP_HPP
+
+namespace osrm
+{
+namespace storage
+{
+
+enum class Ownership
+{
+    Container,
+    View
+};
+}
+}
+
+#endif // SHARED_MEMORY_OWNERSHIP_HPP

include/util/binary_heap.hpp

@@ -16,6 +16,48 @@ namespace osrm
 namespace util
 {
 
+template <typename NodeID, typename Key> class GenerationArrayStorage
+{
+    using GenerationCounter = std::uint16_t;
+
+  public:
+    explicit GenerationArrayStorage(std::size_t size)
+        : positions(size, 0), generation(1), generations(size, 0)
+    {
+    }
+
+    Key &operator[](NodeID node)
+    {
+        generation[node] = generation;
+        return positions[node];
+    }
+
+    Key peek_index(const NodeID node) const
+    {
+        if (generations[node] < generation)
+        {
+            return std::numeric_limits<Key>::max();
+        }
+        return positions[node];
+    }
+
+    void Clear()
+    {
+        generation++;
+        // if generation overflows we end up at 0 again and need to clear the vector
+        if (generation == 0)
+        {
+            generation = 1;
+            std::fill(generations.begin(), generations.end(), 0);
+        }
+    }
+
+  private:
+    GenerationCounter generation;
+    std::vector<GenerationCounter> generations;
+    std::vector<Key> positions;
+};
+
 template <typename NodeID, typename Key> class ArrayStorage
 {
   public:
@@ -92,10 +134,6 @@ template <typename NodeID,
           typename IndexStorage = ArrayStorage<NodeID, NodeID>>
 class BinaryHeap
 {
-  private:
-    BinaryHeap(const BinaryHeap &right);
-    void operator=(const BinaryHeap &right);
-
   public:
     using WeightType = Weight;
     using DataType = Data;

include/util/packed_vector.hpp

@@ -4,6 +4,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <cmath>
 #include <vector>
 
@@ -20,7 +22,8 @@ namespace util
  * NOTE: this type is templated for future use, but will require a slight refactor to
  * configure BITSIZE and ELEMSIZE
  */
-template <typename T, bool UseSharedMemory = false> class PackedVector
+template <typename T, storage::Ownership Ownership = storage::Ownership::Container>
+class PackedVector
 {
     static const constexpr std::size_t BITSIZE = 33;
     static const constexpr std::size_t ELEMSIZE = 64;
@@ -120,20 +123,20 @@ template <typename T, bool UseSharedMemory = false> class PackedVector
 
     std::size_t size() const { return num_elements; }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void reserve(typename std::enable_if<!enabled, std::size_t>::type capacity)
     {
         vec.reserve(elements_to_blocks(capacity));
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void reset(typename std::enable_if<enabled, std::uint64_t>::type *ptr,
                typename std::enable_if<enabled, std::size_t>::type size)
     {
         vec.reset(ptr, size);
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void set_number_of_entries(typename std::enable_if<enabled, std::size_t>::type count)
     {
         num_elements = count;
@@ -145,44 +148,44 @@ template <typename T, bool UseSharedMemory = false> class PackedVector
     }
 
   private:
-    typename util::ShM<std::uint64_t, UseSharedMemory>::vector vec;
+    typename util::ShM<std::uint64_t, Ownership>::vector vec;
 
     std::size_t num_elements = 0;
 
     signed cursor = -1;
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void replace_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
     {
         vec[cursor] = last_elem;
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void replace_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
     {
         vec.back() = last_elem;
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void add_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
     {
         vec[cursor + 1] = last_elem;
         cursor++;
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     void add_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
     {
         vec.push_back(last_elem);
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     std::uint64_t vec_back(typename std::enable_if<enabled>::type * = nullptr)
     {
         return vec[cursor];
     }
 
-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
     std::uint64_t vec_back(typename std::enable_if<!enabled>::type * = nullptr)
     {
         return vec.back();

include/util/range_table.hpp

@@ -2,6 +2,7 @@
 #define RANGE_TABLE_HPP
 
 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"
 #include "util/integer_range.hpp"
 #include "util/shared_memory_vector_wrapper.hpp"
 
@@ -18,13 +19,14 @@ namespace util
  * and otherwise the compiler gets confused.
  */
 
-template <unsigned BLOCK_SIZE = 16, bool USE_SHARED_MEMORY = false> class RangeTable;
+template <unsigned BLOCK_SIZE = 16, storage::Ownership Ownership = storage::Ownership::Container>
+class RangeTable;
 
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table);
 
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table);
 
 /**
  * Stores adjacent ranges in a compressed format.
@@ -35,12 +37,12 @@ std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEM
  * But each block consists of an absolute value and BLOCK_SIZE differential values.
  * So the effective block size is sizeof(unsigned) + BLOCK_SIZE.
  */
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
 {
   public:
     using BlockT = std::array<unsigned char, BLOCK_SIZE>;
-    using BlockContainerT = typename ShM<BlockT, USE_SHARED_MEMORY>::vector;
-    using OffsetContainerT = typename ShM<unsigned, USE_SHARED_MEMORY>::vector;
+    using BlockContainerT = typename ShM<BlockT, Ownership>::vector;
+    using OffsetContainerT = typename ShM<unsigned, Ownership>::vector;
     using RangeT = range<unsigned>;
 
     friend std::ostream &operator<<<>(std::ostream &out, const RangeTable &table);
@@ -139,7 +141,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
         sum_lengths = lengths_prefix_sum;
     }
 
-    void Write(osrm::storage::io::FileWriter &filewriter)
+    void Write(storage::io::FileWriter &filewriter)
     {
         unsigned number_of_blocks = diff_blocks.size();
 
@@ -151,7 +153,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
         filewriter.WriteFrom(diff_blocks.data(), number_of_blocks);
     }
 
-    void Read(osrm::storage::io::FileReader &filereader)
+    void Read(storage::io::FileReader &filereader)
     {
         unsigned number_of_blocks = filereader.ReadElementCount32();
         // read total length
@@ -212,9 +214,8 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
     unsigned sum_lengths;
 };
 
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::PrefixSumAtIndex(int index,
-                                                                     const BlockT &block) const
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const BlockT &block) const
 {
     // this loop looks inefficent, but a modern compiler
     // will emit nice SIMD here, at least for sensible block sizes. (I checked.)
@@ -227,8 +228,8 @@ unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::PrefixSumAtIndex(int index,
     return sum;
 }
 
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table)
 {
     // write number of block
     const unsigned number_of_blocks = table.diff_blocks.size();
@@ -243,8 +244,8 @@ std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHA
     return out;
 }
 
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table)
 {
     // read number of block
     unsigned number_of_blocks;

include/util/shared_memory_vector_wrapper.hpp

@@ -3,6 +3,8 @@
 
 #include "util/log.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
@@ -52,7 +54,7 @@ class ShMemIterator
     DataT *m_value;
 };
 
-template <typename DataT> class SharedMemoryWrapper
+template <typename DataT> class vector_view
 {
   private:
     DataT *m_ptr;
@@ -64,9 +66,9 @@ template <typename DataT> class SharedMemoryWrapper
     using const_iterator = ShMemIterator<const DataT>;
     using reverse_iterator = boost::reverse_iterator<iterator>;
 
-    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
+    vector_view() : m_ptr(nullptr), m_size(0) {}
 
-    SharedMemoryWrapper(DataT *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
+    vector_view(DataT *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
 
     void reset(DataT *ptr, std::size_t size)
     {
@@ -126,20 +128,19 @@ template <typename DataT> class SharedMemoryWrapper
 
     auto data() const { return m_ptr; }
 
-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
+    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
 };
 
-template <> class SharedMemoryWrapper<bool>
+template <> class vector_view<bool>
 {
   private:
     unsigned *m_ptr;
     std::size_t m_size;
 
   public:
-    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
+    vector_view() : m_ptr(nullptr), m_size(0) {}
 
-    SharedMemoryWrapper(unsigned *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
+    vector_view(unsigned *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}
 
     bool at(const std::size_t index) const
     {
@@ -161,22 +162,20 @@ template <> class SharedMemoryWrapper<bool>
 
     bool operator[](const unsigned index) const { return at(index); }
 
-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
+    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
 };
 
-// Both SharedMemoryWrapper<T> and the SharedMemoryWrapper<bool> specializations share this impl.
-template <typename DataT>
-void swap(SharedMemoryWrapper<DataT> &lhs, SharedMemoryWrapper<DataT> &rhs) noexcept
+// Both vector_view<T> and the vector_view<bool> specializations share this impl.
+template <typename DataT> void swap(vector_view<DataT> &lhs, vector_view<DataT> &rhs) noexcept
 {
     std::swap(lhs.m_ptr, rhs.m_ptr);
     std::swap(lhs.m_size, rhs.m_size);
 }
 
-template <typename DataT, bool UseSharedMemory> struct ShM
+template <typename DataT, storage::Ownership Ownership> struct ShM
 {
-    using vector = typename std::conditional<UseSharedMemory,
-                                             SharedMemoryWrapper<DataT>,
+    using vector = typename std::conditional<Ownership == storage::Ownership::View,
+                                             vector_view<DataT>,
                                              std::vector<DataT>>::type;
 };
 }

include/util/static_graph.hpp

@@ -7,6 +7,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>
 
 #include <algorithm>
@@ -97,7 +99,8 @@ EntryT edgeToEntry(const OtherEdge &from, std::false_type)
 
 } // namespace static_graph_details
 
-template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
+template <typename EdgeDataT, storage::Ownership Ownership = storage::Ownership::Container>
+class StaticGraph
 {
   public:
     using InputEdge = static_graph_details::SortableEdgeWithData<EdgeDataT>;
@@ -122,8 +125,8 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
         InitializeFromSortedEdgeRange(nodes, edges.begin(), edges.end());
     }
 
-    StaticGraph(typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array_,
-                typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array_)
+    StaticGraph(typename util::ShM<NodeArrayEntry, Ownership>::vector node_array_,
+                typename util::ShM<EdgeArrayEntry, Ownership>::vector edge_array_)
         : node_array(std::move(node_array_)), edge_array(std::move(edge_array_))
     {
         BOOST_ASSERT(!node_array.empty());
@@ -258,8 +261,8 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
     NodeIterator number_of_nodes;
     EdgeIterator number_of_edges;
 
-    typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array;
-    typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array;
+    typename ShM<NodeArrayEntry, Ownership>::vector node_array;
+    typename ShM<EdgeArrayEntry, Ownership>::vector edge_array;
 };
 
 } // namespace util

include/util/static_rtree.hpp

@@ -15,6 +15,8 @@
 
 #include "osrm/coordinate.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -52,7 +54,7 @@ namespace util
 // are computed, this means the internal distance metric doesn not represent meters!
 template <class EdgeDataT,
           class CoordinateListT = std::vector<Coordinate>,
-          bool UseSharedMemory = false,
+          storage::Ownership Ownership = storage::Ownership::Container,
           std::uint32_t BRANCHING_FACTOR = 128,
           std::uint32_t LEAF_PAGE_SIZE = 4096>
 class StaticRTree
@@ -152,12 +154,12 @@ class StaticRTree
         Coordinate fixed_projected_coordinate;
     };
 
-    typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
+    typename ShM<TreeNode, Ownership>::vector m_search_tree;
     const CoordinateListT &m_coordinate_list;
 
     boost::iostreams::mapped_file_source m_leaves_region;
     // read-only view of leaves
-    typename ShM<const LeafNode, true>::vector m_leaves;
+    typename ShM<const LeafNode, storage::Ownership::View>::vector m_leaves;
 
   public:
     StaticRTree(const StaticRTree &) = delete;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.7.0-latest.2",
+  "version": "5.7.0-latest.4",
   "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": {
@@ -19,7 +19,8 @@
     "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
     "clean": "rm -rf test/cache",
     "docs": "./scripts/build_api_docs.sh",
-    "install": "node-pre-gyp install --fallback-to-build=false"
+    "install": "node-pre-gyp install --fallback-to-build=false",
+    "nodejs-tests": "make -C test/data && ./lib/binding/osrm-datastore test/data/ch/monaco.osrm && node test/nodejs/index.js | faucet"
   },
   "repository": {
     "type": "git",
@@ -44,6 +45,7 @@
     "mkdirp": "^0.5.1",
     "aws-sdk": "~2.0.31",
     "tape": "^4.2.2",
+    "faucet": "^0.0.1",
     "node-timeout": "0.0.4",
     "polyline": "^0.2.0",
     "request": "^2.69.0",

src/benchmarks/static_rtree.cpp

@@ -28,12 +28,14 @@ constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
 
 using RTreeLeaf = extractor::EdgeBasedNode;
 using BenchStaticRTree =
-    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, false>::vector, false>;
+    util::StaticRTree<RTreeLeaf,
+                      util::ShM<util::Coordinate, storage::Ownership::Container>::vector,
+                      storage::Ownership::Container>;
 
 std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file)
 {
-    osrm::storage::io::FileReader nodes_path_file_reader(
-        nodes_file, osrm::storage::io::FileReader::HasNoFingerprint);
+    storage::io::FileReader nodes_path_file_reader(nodes_file,
+                                                   storage::io::FileReader::HasNoFingerprint);
 
     extractor::QueryNode current_node;
     unsigned coordinate_count = nodes_path_file_reader.ReadElementCount32();

src/customize/customizer.cpp

@@ -8,6 +8,8 @@
 #include "partition/io.hpp"
 #include "partition/multi_level_partition.hpp"
 
+#include "storage/shared_memory_ownership.hpp"
+
 #include "updater/updater.hpp"
 
 #include "util/log.hpp"
@@ -82,9 +84,9 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
     auto directed = partition::splitBidirectionalEdges(edge_based_edge_list);
     auto tidied =
         partition::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed));
-    auto edge_based_graph =
-        std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>>(
-            mlp, num_nodes, std::move(tidied));
+    auto edge_based_graph = std::make_unique<
+        partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>>(
+        mlp, num_nodes, std::move(tidied));
 
     util::Log() << "Loaded edge based graph for mapping partition ids: "
                 << edge_based_graph->GetNumberOfEdges() << " edges, "

src/nodejs/CMakeLists.txt

@@ -7,12 +7,14 @@ message(STATUS "Building node-osrm")
 set(BINDING_DIR "${PROJECT_SOURCE_DIR}/lib/binding")
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/nodejs")
-include(FindNodeJS)
 
 set(NodeJS_CXX_STANDARD 14 CACHE INTERNAL "Use C++14" FORCE)
 set(NodeJS_DOWNLOAD ON CACHE INTERNAL "Download node.js sources" FORCE)
 set(NodeJS_USE_CLANG_STDLIB OFF CACHE BOOL "Don't use libc++ by default" FORCE)
 
+# ^ Make sure to set NodeJs options before including and requiring the NodeJs module.
+# Otherwise the module will use defaults (which - among many bad choices - means libc++).
+include(FindNodeJS)
 find_package(NodeJS REQUIRED)
 add_nodejs_module(node-osrm node_osrm.cpp)
 target_link_libraries(node-osrm osrm)

src/storage/storage.cpp

@@ -16,6 +16,7 @@
 #include "storage/serialization.hpp"
 #include "storage/shared_datatype.hpp"
 #include "storage/shared_memory.hpp"
+#include "storage/shared_memory_ownership.hpp"
 #include "storage/shared_monitor.hpp"
 #include "engine/datafacade/datafacade_base.hpp"
 #include "util/coordinate.hpp"
@@ -55,8 +56,9 @@ namespace storage
 {
 
 using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf;
-using RTreeNode =
-    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>::TreeNode;
+using RTreeNode = util::StaticRTree<RTreeLeaf,
+                                    util::vector_view<util::Coordinate>,
+                                    storage::Ownership::View>::TreeNode;
 using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
 using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>;
 
@@ -364,12 +366,13 @@ void Storage::PopulateLayout(DataLayout &layout)
         intersection_file.Skip<std::uint32_t>(1); // sum_lengths
 
         layout.SetBlockSize<unsigned>(DataLayout::BEARING_OFFSETS, bearing_blocks);
-        layout.SetBlockSize<typename util::RangeTable<16, true>::BlockT>(DataLayout::BEARING_BLOCKS,
-                                                                         bearing_blocks);
+        layout.SetBlockSize<typename util::RangeTable<16, storage::Ownership::View>::BlockT>(
+            DataLayout::BEARING_BLOCKS, bearing_blocks);
 
         // No need to read the data
         intersection_file.Skip<unsigned>(bearing_blocks);
-        intersection_file.Skip<typename util::RangeTable<16, true>::BlockT>(bearing_blocks);
+        intersection_file.Skip<typename util::RangeTable<16, storage::Ownership::View>::BlockT>(
+            bearing_blocks);
 
         const auto num_bearings = intersection_file.ReadElementCount64();
 
@@ -694,7 +697,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
             layout.GetBlockPtr<util::Coordinate, true>(memory_ptr, DataLayout::COORDINATE_LIST);
         const auto osmnodeid_ptr =
             layout.GetBlockPtr<std::uint64_t, true>(memory_ptr, DataLayout::OSM_NODE_ID_LIST);
-        util::PackedVector<OSMNodeID, true> osmnodeid_list;
+        util::PackedVector<OSMNodeID, storage::Ownership::View> osmnodeid_list;
 
         osmnodeid_list.reset(osmnodeid_ptr, layout.num_entries[DataLayout::OSM_NODE_ID_LIST]);
 
@@ -803,8 +806,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
         intersection_file.Skip<std::uint32_t>(1); // sum_lengths
 
         std::vector<unsigned> bearing_offsets_data(bearing_blocks);
-        std::vector<typename util::RangeTable<16, true>::BlockT> bearing_blocks_data(
-            bearing_blocks);
+        std::vector<typename util::RangeTable<16, storage::Ownership::View>::BlockT>
+            bearing_blocks_data(bearing_blocks);
 
         intersection_file.ReadInto(bearing_offsets_data.data(), bearing_blocks);
         intersection_file.ReadInto(bearing_blocks_data.data(), bearing_blocks);
@@ -844,8 +847,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
         if (layout.GetBlockSize(DataLayout::BEARING_BLOCKS) > 0)
         {
             const auto bearing_blocks_ptr =
-                layout.GetBlockPtr<typename util::RangeTable<16, true>::BlockT, true>(
-                    memory_ptr, DataLayout::BEARING_BLOCKS);
+                layout.GetBlockPtr<typename util::RangeTable<16, storage::Ownership::View>::BlockT,
+                                   true>(memory_ptr, DataLayout::BEARING_BLOCKS);
             BOOST_ASSERT(
                 static_cast<std::size_t>(layout.GetBlockSize(DataLayout::BEARING_BLOCKS)) >=
                 std::distance(bearing_blocks_data.begin(), bearing_blocks_data.end()) *

src/tools/store.cpp

@@ -14,7 +14,7 @@
 
 using namespace osrm;
 
-void removeLocks() { osrm::storage::SharedMonitor<osrm::storage::SharedDataTimestamp>::remove(); }
+void removeLocks() { storage::SharedMonitor<storage::SharedDataTimestamp>::remove(); }
 
 void deleteRegion(const storage::SharedDataType region)
 {

src/updater/updater.cpp

@@ -81,7 +81,7 @@ void checkWeightsConsistency(
     const UpdaterConfig &config,
     const std::vector<osrm::extractor::EdgeBasedEdge> &edge_based_edge_list)
 {
-    using Reader = osrm::storage::io::FileReader;
+    using Reader = storage::io::FileReader;
     using OriginalEdgeData = osrm::extractor::OriginalEdgeData;
 
     extractor::SegmentDataContainer segment_data;

test/nodejs/constants.js

@@ -0,0 +1,26 @@
+var path = require('path');
+
+// Constants and fixtures for nodejs tests on our Monaco dataset.
+
+// Somewhere in Monaco
+// http://www.openstreetmap.org/#map=18/43.73185/7.41772
+exports.three_test_coordinates = [[7.41337, 43.72956],
+                                  [7.41546, 43.73077],
+                                  [7.41862, 43.73216]];
+
+exports.two_test_coordinates = exports.three_test_coordinates.slice(0, 2)
+
+exports.test_tile = {'at': [17059, 11948, 15], 'size': 114000};
+
+
+// Test files generated by the routing engine; check test/data
+if (process.env.OSRM_DATA_PATH !== undefined) {
+    exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/monaco.osrm");
+    exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/monaco.osrm");
+    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/monaco.osrm");
+    console.log('Setting custom data path to ' + exports.data_path);
+} else {
+    exports.data_path = path.resolve(path.join(__dirname, "../data/ch/monaco.osrm"));
+    exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/monaco.osrm"));
+    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/monaco.osrm"));
+}

test/nodejs/index.js

@@ -1,8 +1,8 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
-var berlin_mld_path = require('./osrm-data-path').mld_data_path;
-var berlin_corech_path = require('./osrm-data-path').corech_data_path;
+var monaco_path = require('./constants').data_path;
+var monaco_mld_path = require('./constants').mld_data_path;
+var monaco_corech_path = require('./constants').corech_data_path;
 
 test('constructor: throws if new keyword is not used', function(assert) {
     assert.plan(1);
@@ -30,7 +30,7 @@ test('constructor: throws if necessary files do not exist', function(assert) {
 
 test('constructor: takes a shared memory argument', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM({path: berlin_path, shared_memory: false});
+    var osrm = new OSRM({path: monaco_path, shared_memory: false});
     assert.ok(osrm);
 });
 
@@ -42,7 +42,7 @@ test('constructor: throws if shared_memory==false with no path defined', functio
 
 test('constructor: throws if given a non-bool shared_memory option', function(assert) {
     assert.plan(1);
-    assert.throws(function() { new OSRM({path: berlin_path, shared_memory: 'a'}); },
+    assert.throws(function() { new OSRM({path: monaco_path, shared_memory: 'a'}); },
         /Shared_memory option must be a boolean/);
 });
 
@@ -66,19 +66,19 @@ test('constructor: throws if given an invalid algorithm', function(assert) {
 
 test('constructor: loads MLD if given as algorithm', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM({algorithm: 'MLD', path: berlin_mld_path});
+    var osrm = new OSRM({algorithm: 'MLD', path: monaco_mld_path});
     assert.ok(osrm);
 });
 
 test('constructor: loads CH if given as algorithm', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CH', path: berlin_path});
+    var osrm = new OSRM({algorithm: 'CH', path: monaco_path});
     assert.ok(osrm);
 });
 
 test('constructor: loads CoreCH if given as algorithm', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CoreCH', path: berlin_corech_path});
+    var osrm = new OSRM({algorithm: 'CoreCH', path: monaco_corech_path});
     assert.ok(osrm);
 });
 

test/nodejs/match.js

@@ -1,12 +1,14 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
 
-test('match: match in Berlin', function(assert) {
+test('match: match in Monaco', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
         timestamps: [1424684612, 1424684616, 1424684620]
     };
     osrm.match(options, function(err, response) {
@@ -22,11 +24,11 @@ test('match: match in Berlin', function(assert) {
     });
 });
 
-test('match: match in Berlin without timestamps', function(assert) {
+test('match: match in Monaco without timestamps', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]]
+        coordinates: three_test_coordinates
     };
     osrm.match(options, function(err, response) {
         assert.ifError(err);
@@ -35,11 +37,11 @@ test('match: match in Berlin without timestamps', function(assert) {
     });
 });
 
-test('match: match in Berlin without geometry compression', function(assert) {
+test('match: match in Monaco without geometry compression', function(assert) {
     assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
         geometries: 'geojson'
     };
     osrm.match(options, function(err, response) {
@@ -50,11 +52,11 @@ test('match: match in Berlin without geometry compression', function(assert) {
     });
 });
 
-test('match: match in Berlin with geometry compression', function(assert) {
+test('match: match in Monaco with geometry compression', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]]
+        coordinates: three_test_coordinates,
     };
     osrm.match(options, function(err, response) {
         assert.ifError(err);
@@ -63,11 +65,11 @@ test('match: match in Berlin with geometry compression', function(assert) {
     });
 });
 
-test('match: match in Berlin with speed annotations options', function(assert) {
+test('match: match in Monaco with speed annotations options', function(assert) {
     assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
         timestamps: [1424684612, 1424684616, 1424684620],
         radiuses: [4.07, 4.07, 4.07],
         steps: true,
@@ -92,11 +94,12 @@ test('match: match in Berlin with speed annotations options', function(assert) {
 });
 
 
-test('match: match in Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('match: match in Monaco with several (duration, distance, nodes) annotations options', function(assert) {
     assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        timestamps: [1424684612, 1424684616, 1424684620],
+        coordinates: three_test_coordinates,
         timestamps: [1424684612, 1424684616, 1424684620],
         radiuses: [4.07, 4.07, 4.07],
         steps: true,
@@ -120,11 +123,11 @@ test('match: match in Berlin with several (duration, distance, nodes) annotation
     });
 });
 
-test('match: match in Berlin with all options', function(assert) {
+test('match: match in Monaco with all options', function(assert) {
     assert.plan(8);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
         timestamps: [1424684612, 1424684616, 1424684620],
         radiuses: [4.07, 4.07, 4.07],
         steps: true,
@@ -146,42 +149,42 @@ test('match: match in Berlin with all options', function(assert) {
 
 test('match: throws on missing arguments', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     assert.throws(function() { osrm.match({}) },
         /Two arguments required/);
 });
 
 test('match: throws on non-object arg', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     assert.throws(function() { osrm.match(null, function(err, response) {}) },
         /First arg must be an object/);
 });
 
 test('match: throws on invalid coordinates param', function(assert) {
     assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
         coordinates: ''
     };
     assert.throws(function() { osrm.match(options, function(err, response) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252,52.542648]];
+    options.coordinates = [three_test_coordinates[0]];
     assert.throws(function() { osrm.match(options, function(err, response) {}) },
         /At least two coordinates must be provided/);
-    options.coordinates = [13.393252,52.542648];
+    options.coordinates = three_test_coordinates[0]
     assert.throws(function() { osrm.match(options, function(err, response) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252],[52.542648]];
+    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
     assert.throws(function() { osrm.match(options, function(err, response) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
 });
 
 test('match: throws on invalid timestamps param', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
         timestamps: 'timestamps'
     };
     assert.throws(function() { osrm.match(options, function(err, response) {}) },

test/nodejs/nearest.js

@@ -1,12 +1,15 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
+
 
 test('nearest', function(assert) {
     assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     osrm.nearest({
-        coordinates: [[13.333086, 52.4224]]
+        coordinates: [three_test_coordinates[0]]
     }, function(err, result) {
         assert.ifError(err);
         assert.equal(result.waypoints.length, 1);
@@ -17,9 +20,9 @@ test('nearest', function(assert) {
 
 test('nearest: can ask for multiple nearest pts', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     osrm.nearest({
-        coordinates: [[13.333086, 52.4224]],
+        coordinates: [three_test_coordinates[0]],
         number: 3
     }, function(err, result) {
         assert.ifError(err);
@@ -29,19 +32,19 @@ test('nearest: can ask for multiple nearest pts', function(assert) {
 
 test('nearest: throws on invalid args', function(assert) {
     assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {};
     assert.throws(function() { osrm.nearest(options); },
         /Two arguments required/);
     assert.throws(function() { osrm.nearest(null, function(err, res) {}); },
         /First arg must be an object/);
-    options.coordinates = [52.4224];
+    options.coordinates = [43.73072];
     assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
         /Coordinates must be an array of /);
-    options.coordinates = [[13.333086, 52.4224],[13.333086, 52.5224]];
+    options.coordinates = [three_test_coordinates[0], three_test_coordinates[1]];
     assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
         /Exactly one coordinate pair must be provided/);
-    options.coordinates = [[13.333086, 52.4224]];
+    options.coordinates = [three_test_coordinates[0]];
     options.number = 3.14159;
     assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
         /Number must be an integer greater than or equal to 1/);

test/nodejs/osrm-data-path.js

@@ -1,12 +0,0 @@
-var path = require('path');
-
-if (process.env.OSRM_DATA_PATH !== undefined) {
-    exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/berlin.osrm");
-    exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/berlin.osrm");
-    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/berlin.osrm");
-    console.log('Setting custom data path to ' + exports.data_path);
-} else {
-    exports.data_path = path.resolve(path.join(__dirname, "../data/ch/berlin.osrm"));
-    exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/berlin.osrm"));
-    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/berlin.osrm"));
-}

test/nodejs/route.js

@@ -1,12 +1,27 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
-var berlin_mld_path = require('./osrm-data-path').mld_data_path;
-var berlin_corech_path = require('./osrm-data-path').corech_data_path;
+var monaco_path = require('./constants').data_path;
+var monaco_mld_path = require('./constants').mld_data_path;
+var monaco_corech_path = require('./constants').corech_data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
 
-test('route: routes Berlin', function(assert) {
+
+test('route: routes Monaco', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
+    osrm.route({coordinates: two_test_coordinates}, function(err, route) {
+        assert.ifError(err);
+        assert.ok(route.waypoints);
+        assert.ok(route.routes);
+        assert.ok(route.routes.length);
+        assert.ok(route.routes[0].geometry);
+    });
+});
+
+test('route: routes Monaco on MLD', function(assert) {
+    assert.plan(5);
+    var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
     osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
         assert.ifError(err);
         assert.ok(route.waypoints);
@@ -16,21 +31,9 @@ test('route: routes Berlin', function(assert) {
     });
 });
 
-test('route: routes Berlin on MLD', function(assert) {
+test('route: routes Monaco on CoreCH', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM({path: berlin_mld_path, algorithm: 'MLD'});
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
-        assert.ifError(err);
-        assert.ok(route.waypoints);
-        assert.ok(route.routes);
-        assert.ok(route.routes.length);
-        assert.ok(route.routes[0].geometry);
-    });
-});
-
-test('route: routes Berlin on CoreCH', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM({path: berlin_corech_path, algorithm: 'CoreCH'});
+    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
     osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
         assert.ifError(err);
         assert.ok(route.waypoints);
@@ -42,19 +45,19 @@ test('route: routes Berlin on CoreCH', function(assert) {
 
 test('route: throws with too few or invalid args', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}) },
+    var osrm = new OSRM(monaco_path);
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates}) },
         /Two arguments required/);
     assert.throws(function() { osrm.route(null, function(err, route) {}) },
         /First arg must be an object/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, true)},
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates}, true)},
         /last argument must be a callback function/);
 });
 
-test('route: provides no alternatives by default, but when requested', function(assert) {
+test('route: provides no alternatives by default, but when requested it may (not guaranteed)', function(assert) {
     assert.plan(6);
-    var osrm = new OSRM(berlin_path);
-    var options = {coordinates: [[13.302383,52.490516], [13.418427,52.522070]]};
+    var osrm = new OSRM(monaco_path);
+    var options = {coordinates: two_test_coordinates};
 
     osrm.route(options, function(err, route) {
         assert.ifError(err);
@@ -65,53 +68,53 @@ test('route: provides no alternatives by default, but when requested', function(
     osrm.route(options, function(err, route) {
         assert.ifError(err);
         assert.ok(route.routes);
-        assert.equal(route.routes.length, 2);
+        assert.ok(route.routes.length >= 1);
     });
 });
 
 test('route: throws with bad params', function(assert) {
     assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     assert.throws(function () { osrm.route({coordinates: []}, function(err) {}) });
     assert.throws(function() { osrm.route({}, function(err, route) {}) },
         /Must provide a coordinates property/);
     assert.throws(function() { osrm.route({coordinates: null}, function(err, route) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [13.438640, 52.519930]}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[three_test_coordinates[0]], [three_test_coordinates[1]]]}, function(err, route) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [[true, '52.519930'], [13.438640, 52.519930]]}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[true, 'stringish'], three_test_coordinates[1]]}, function(err, route) {}) },
         /Each member of a coordinate pair must be a number/);
     assert.throws(function() { osrm.route({coordinates: [[213.43864,252.51993],[413.415852,552.513191]]}, function(err, route) {}) },
         /Lng\/Lat coordinates must be within world bounds \(-180 < lng < 180, -90 < lat < 90\)/);
     assert.throws(function() { osrm.route({coordinates: [[13.438640], [52.519930]]}, function(err, route) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, hints: null}, function(err, route) {}) },
         /Hints must be an array of strings\/null/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], steps: null}, function(err, route) {}) });
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], annotations: null}, function(err, route) {}) });
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, steps: null}, function(err, route) {}) });
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, annotations: null}, function(err, route) {}) });
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         alternateRoute: false,
-        hints: [13.438640, 52.519930]
+        hints: three_test_coordinates[0]
     };
     assert.throws(function() { osrm.route(options, function(err, route) {}) },
         /Hint must be null or string/);
 });
 
-test('route: routes Berlin using shared memory', function(assert) {
+test('route: routes Monaco using shared memory', function(assert) {
     assert.plan(2);
     var osrm = new OSRM();
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
+    osrm.route({coordinates: two_test_coordinates}, function(err, route) {
         assert.ifError(err);
         assert.ok(Array.isArray(route.routes));
     });
 });
 
-test('route: routes Berlin with geometry compression', function(assert) {
+test('route: routes Monaco with geometry compression', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
     };
     osrm.route(options, function(err, route) {
         assert.ifError(err);
@@ -119,11 +122,11 @@ test('route: routes Berlin with geometry compression', function(assert) {
     });
 });
 
-test('route: routes Berlin without geometry compression', function(assert) {
+test('route: routes Monaco without geometry compression', function(assert) {
     assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         geometries: 'geojson'
     };
     osrm.route(options, function(err, route) {
@@ -136,9 +139,9 @@ test('route: routes Berlin without geometry compression', function(assert) {
 
 test('Test polyline6 geometries option', function(assert) {
     assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: false,
         overview: 'false',
         geometries: 'polyline6',
@@ -154,11 +157,11 @@ test('Test polyline6 geometries option', function(assert) {
     });
 });
 
-test('route: routes Berlin with speed annotations options', function(assert) {
+test('route: routes Monaco with speed annotations options', function(assert) {
     assert.plan(17);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: false,
         overview: 'false',
         geometries: 'polyline',
@@ -193,16 +196,16 @@ test('route: routes Berlin with speed annotations options', function(assert) {
     });
 });
 
-test('route: routes Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('route: routes Monaco with several (duration, distance, nodes) annotations options', function(assert) {
     assert.plan(17);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: false,
         overview: 'false',
         geometries: 'polyline',
         steps: true,
-        annotations: ['duration','distance','nodes']
+        annotations: ['duration', 'distance', 'nodes']
     };
     osrm.route(options, function(err, first) {
         assert.ifError(err);
@@ -232,11 +235,11 @@ test('route: routes Berlin with several (duration, distance, nodes) annotations
     });
 });
 
-test('route: routes Berlin with options', function(assert) {
+test('route: routes Monaco with options', function(assert) {
     assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: false,
         overview: 'false',
         geometries: 'polyline',
@@ -265,11 +268,11 @@ test('route: routes Berlin with options', function(assert) {
     });
 });
 
-test('route: routes Berlin with options', function(assert) {
+test('route: routes Monaco with options', function(assert) {
     assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: false,
         overview: 'false',
         geometries: 'polyline',
@@ -300,39 +303,39 @@ test('route: routes Berlin with options', function(assert) {
 
 test('route: invalid route options', function(assert) {
     assert.plan(8);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         continue_straight: []
     }, function(err, route) {}); },
         /must be boolean/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         alternatives: []
     }, function(err, route) {}); },
         /must be boolean/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         geometries: true
     }, function(err, route) {}); },
         /Geometries must be a string: \[polyline, polyline6, geojson\]/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         overview: false
     }, function(err, route) {}); },
         /Overview must be a string: \[simplified, full, false\]/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         overview: false
     }, function(err, route) {}); },
         /Overview must be a string: \[simplified, full, false\]/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         overview: 'maybe'
     }, function(err, route) {}); },
         /'overview' param must be one of \[simplified, full, false\]/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         geometries: 'maybe'
     }, function(err, route) {}); },
         /'geometries' param must be one of \[polyline, polyline6, geojson\]/);
@@ -344,9 +347,9 @@ test('route: invalid route options', function(assert) {
 
 test('route: integer bearing values no longer supported', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [200, 250],
     };
     assert.throws(function() { osrm.route(options, function(err, route) {}); },
@@ -355,9 +358,9 @@ test('route: integer bearing values no longer supported', function(assert) {
 
 test('route: valid bearing values', function(assert) {
     assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [[200, 180], [250, 180]],
     };
     osrm.route(options, function(err, route) {
@@ -373,44 +376,44 @@ test('route: valid bearing values', function(assert) {
 
 test('route: invalid bearing values', function(assert) {
     assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [[400, 180], [-250, 180]],
     }, function(err, route) {}) },
         /Bearing values need to be in range 0..360, 0..180/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [[200], [250, 180]],
     }, function(err, route) {}) },
         /Bearing must be an array of/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [[400, 109], [100, 720]],
     }, function(err, route) {}) },
         /Bearing values need to be in range 0..360, 0..180/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: 400,
     }, function(err, route) {}) },
         /Bearings must be an array of arrays of numbers/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [[100, 100]],
     }, function(err, route) {}) },
         /Bearings array must have the same length as coordinates array/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         bearings: [Infinity, Infinity],
     }, function(err, route) {}) },
         /Bearing must be an array of \[bearing, range\] or null/);
 });
 
-test('route: routes Berlin with hints', function(assert) {
+test('route: routes Monaco with hints', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: two_test_coordinates,
     };
     osrm.route(options, function(err, first) {
         assert.ifError(err);
@@ -427,11 +430,11 @@ test('route: routes Berlin with hints', function(assert) {
     });
 });
 
-test('route: routes Berlin with null hints', function(assert) {
+test('route: routes Monaco with null hints', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         hints: [null, null]
     };
     osrm.route(options, function(err, route) {
@@ -441,22 +444,22 @@ test('route: routes Berlin with null hints', function(assert) {
 
 test('route: throws on bad hints', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         hints: ['', '']
     }, function(err, route) {})}, /Hint cannot be an empty string/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         hints: [null]
     }, function(err, route) {})}, /Hints array must have the same length as coordinates array/);
 });
 
-test('route: routes Berlin with valid radius values', function(assert) {
+test('route: routes Monaco with valid radius values', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         radiuses: [100, 100]
     };
     osrm.route(options, function(err, route) {
@@ -474,23 +477,23 @@ test('route: routes Berlin with valid radius values', function(assert) {
 
 test('route: throws on bad radiuses', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         radiuses: [10, 10]
     };
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         radiuses: 10
     }, function(err, route) {}) },
         /Radiuses must be an array of non-negative doubles or null/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         radiuses: ['magic', 'numbers']
     }, function(err, route) {}) },
         /Radius must be non-negative double or null/);
     assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         radiuses: [10]
     }, function(err, route) {}) },
         /Radiuses array must have the same length as coordinates array/);

test/nodejs/table.js

@@ -1,12 +1,15 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
 
-test('table: distance table in Berlin', function(assert) {
-    assert.plan(9);
-    var osrm = new OSRM(berlin_path);
+
+test('table: distance table in Monaco', function(assert) {
+    assert.plan(11);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
     };
     osrm.table(options, function(err, table) {
         assert.ifError(err);
@@ -23,6 +26,8 @@ test('table: distance table in Berlin', function(assert) {
                 } else {
                     // everything else is non-zero
                     assert.notEqual(0, column[j], 'other entries must be non-zero');
+                    // and finite (not nan, inf etc.)
+                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
                 }
             }
         }
@@ -30,11 +35,11 @@ test('table: distance table in Berlin', function(assert) {
     });
 });
 
-test('table: distance table in Berlin with sources/destinations', function(assert) {
-    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+test('table: distance table in Monaco with sources/destinations', function(assert) {
+    assert.plan(7);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
         sources: [0],
         destinations: [0,1]
     };
@@ -53,6 +58,8 @@ test('table: distance table in Berlin with sources/destinations', function(asser
                 } else {
                     // everything else is non-zero
                     assert.notEqual(0, column[j], 'other entries must be non-zero');
+                    // and finite (not nan, inf etc.)
+                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
                 }
             }
         }
@@ -62,24 +69,24 @@ test('table: distance table in Berlin with sources/destinations', function(asser
 
 test('table: throws on invalid arguments', function(assert) {
     assert.plan(14);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {};
     assert.throws(function() { osrm.table(options); },
         /Two arguments required/);
     options.coordinates = null;
     assert.throws(function() { osrm.table(options, function() {}); },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252,52.542648]];
+    options.coordinates = [three_test_coordinates[0]];
     assert.throws(function() { osrm.table(options, function(err, response) {}) },
         /At least two coordinates must be provided/);
-    options.coordinates = [13.393252,52.542648];
+    options.coordinates = three_test_coordinates[0];
     assert.throws(function() { osrm.table(options, function(err, response) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252],[52.542648]];
+    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
     assert.throws(function() { osrm.table(options, function(err, response) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
 
-    options.coordinates = [[13.393252,52.542648],[13.393252,52.542648]];
+    options.coordinates = two_test_coordinates;
     options.sources = true;
     assert.throws(function() { osrm.table(options, function(err, response) {}) },
         /Sources must be an array of indices \(or undefined\)/);
@@ -110,22 +117,22 @@ test('table: throws on invalid arguments', function(assert) {
     assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
         /You can either specify sources and destinations, or coordinates/);
 
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], generate_hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, generate_hints: null}, function(err, route) {}) },
         /generate_hints must be of type Boolean/);
 });
 
 test('table: throws on invalid arguments', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     assert.throws(function() { osrm.table(null, function() {}); },
         /First arg must be an object/);
 });
 
-test('table: distance table in Berlin with hints', function(assert) {
+test('table: distance table in Monaco with hints', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         generate_hints: true  // true is default but be explicit here
     };
     osrm.table(options, function(err, table) {
@@ -141,11 +148,11 @@ test('table: distance table in Berlin with hints', function(assert) {
     });
 });
 
-test('table: distance table in Berlin without hints', function(assert) {
+test('table: distance table in Monaco without hints', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         generate_hints: false  // true is default
     };
     osrm.table(options, function(err, table) {

test/nodejs/tile.js

@@ -1,23 +1,25 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = "test/data/berlin-latest.osrm";
+var data_path = require('./constants').data_path;
+var tile = require('./constants').test_tile;
 
 test.test('tile check size coarse', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.tile([17603, 10747, 15], function(err, result) {
+    var osrm = new OSRM(data_path);
+    osrm.tile(tile.at, function(err, result) {
         assert.ifError(err);
-        assert.ok(result.length > 35000);
+        assert.ok(result.length > tile.size);
     });
 });
 
-// FIXME the size of the tile that is returned depends on the architecture
-// See issue #3343 in osrm-backend
-test.skip('tile', function(assert) {
-    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.tile([17603, 10747, 15], function(err, result) {
-        assert.ifError(err);
-        assert.equal(result.length, 35970);
-    });
+test.test('tile interface pre-conditions', function(assert) {
+    assert.plan(6);
+    var osrm = new OSRM(data_path);
+
+    assert.throws(function() { osrm.tile(null, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([], function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([[]], function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile(undefined, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile(17059, 11948, 15, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([17059, 11948, -15], function(err, result) {}) }, /must be unsigned/);
 });

test/nodejs/trip.js

@@ -1,11 +1,14 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
 
-test('trip: trip in Berlin', function(assert) {
+
+test('trip: trip in Monaco', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.trip({coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576]]}, function(err, trip) {
+    var osrm = new OSRM(data_path);
+    osrm.trip({coordinates: two_test_coordinates}, function(err, trip) {
         assert.ifError(err);
         for (t = 0; t < trip.trips.length; t++) {
             assert.ok(trip.trips[t].geometry);
@@ -13,28 +16,25 @@ test('trip: trip in Berlin', function(assert) {
     });
 });
 
-test('trip: trip with many locations in Berlin', function(assert) {
-    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
-    var opts = {coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576],[13.404693603515625,52.50535544522142],[13.388900756835938,52.50159371284434],[13.386840820312498,52.518727886767266],[13.4088134765625,52.528754547664185],[13.41156005859375,52.51705655410405],[13.420486450195312,52.512042174642346],[13.413619995117188,52.50368360390624],[13.36212158203125,52.504101570196205],[13.35113525390625,52.52248815280757],[13.36761474609375,52.53460237630516],[13.383407592773438,52.53710835019913],[13.392333984375,52.536690697815736],[13.42529296875,52.532931647583325],[13.399200439453125,52.52415927884915],[13.390960693359375,52.51956352925745],[13.375167846679688,52.533349335723294],[13.37860107421875,52.520399155853454],[13.355255126953125,52.52081696319122],[13.385467529296875,52.5143405029259],[13.398857116699219,52.513086884218325],[13.399200439453125,52.50744515744915],[13.409500122070312,52.49783165855699],[13.424949645996094,52.500339730516934],[13.440055847167969,52.50786308797268],[13.428382873535156,52.511624283857785],[13.437652587890625,52.50451953251202],[13.443145751953125,52.5199813445422],[13.431129455566406,52.52520370034151],[13.418426513671875,52.52896341209634],[13.429069519042969,52.517474393230245],[13.418083190917969,52.528127948407935],[13.405036926269531,52.52833681581998],[13.384437561035156,52.53084314728766],[13.374481201171875,52.53084314728766],[13.3978271484375,52.532305107923925],[13.418769836425781,52.526039219655445],[13.441085815429688,52.51642978796417],[13.448638916015625,52.51601193890388],[13.44623565673828,52.50535544522142],[13.430442810058594,52.502638670794546],[13.358688354492188,52.520190250694526],[13.358001708984375,52.531887409851336],[13.367271423339842,52.528545682238736],[13.387870788574219,52.52958999943304],[13.406410217285156,52.53961418106945],[13.399543762207031,52.50556442091497],[13.374824523925781,52.50389258754797],[13.386154174804688,52.51099744023003],[13.40229034423828,52.49657756892365]]
-};
+test('trip: trip with many locations in Monaco', function(assert) {
+    assert.plan(2);
+
+    var many = 5;
+
+    var osrm = new OSRM(data_path);
+    var opts = {coordinates: three_test_coordinates.slice(0, many)};
     osrm.trip(opts, function(err, trip) {
         assert.ifError(err);
         for (t = 0; t < trip.trips.length; t++) {
             assert.ok(trip.trips[t].geometry);
         }
-        assert.equal(opts.coordinates.length, trip.waypoints.length);
-        var indexMap = trip.waypoints.map(function(wp, i) {
-            return [i, wp.waypoint_index];
-        });
-        assert.ok(!indexMap.every(function(tuple) { return tuple[0] === tuple[1]; }));
     });
 });
 
 test('trip: throws with too few or invalid args', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    assert.throws(function() { osrm.trip({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}) },
+    var osrm = new OSRM(data_path);
+    assert.throws(function() { osrm.trip({coordinates: two_test_coordinates}) },
         /Two arguments required/);
     assert.throws(function() { osrm.trip(null, function(err, trip) {}) },
         /First arg must be an object/);
@@ -42,7 +42,7 @@ test('trip: throws with too few or invalid args', function(assert) {
 
 test('trip: throws with bad params', function(assert) {
     assert.plan(14);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     assert.throws(function () { osrm.trip({coordinates: []}, function(err) {}) });
     assert.throws(function() { osrm.trip({}, function(err, trip) {}) },
         /Must provide a coordinates property/);
@@ -51,22 +51,21 @@ test('trip: throws with bad params', function(assert) {
     }, function(err, trip) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
     assert.throws(function() { osrm.trip({
-        coordinates: [13.438640, 52.519930]
+        coordinates: three_test_coordinates[0]
     }, function(err, trip) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
     assert.throws(function() { osrm.trip({
-        coordinates: [[13.438640], [52.519930]]
+        coordinates: [three_test_coordinates[0][0], three_test_coordinates[0][1]]
     }, function(err, trip) {}) },
         /Coordinates must be an array of \(lon\/lat\) pairs/);
     assert.throws(function() { osrm.trip({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         hints: null
     }, function(err, trip) {}) },
         /Hints must be an array of strings\/null/);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
-        printInstructions: false,
-        hints: [13.438640, 52.519930]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+        hints: three_test_coordinates[0]
     };
     assert.throws(function() { osrm.trip(options, function(err, trip) {}); },
         /Hint must be null or string/);
@@ -96,10 +95,10 @@ test('trip: throws with bad params', function(assert) {
         /'roundtrip' param must be a boolean/);
 });
 
-test('trip: routes Berlin using shared memory', function(assert) {
+test('trip: routes Monaco using shared memory', function(assert) {
     assert.plan(2);
     var osrm = new OSRM();
-    osrm.trip({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, trip) {
+    osrm.trip({coordinates: two_test_coordinates}, function(err, trip) {
         assert.ifError(err);
             for (t = 0; t < trip.trips.length; t++) {
                 assert.ok(trip.trips[t].geometry);
@@ -107,11 +106,11 @@ test('trip: routes Berlin using shared memory', function(assert) {
     });
 });
 
-test('trip: routes Berlin with hints', function(assert) {
+test('trip: routes Monaco with hints', function(assert) {
     assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         steps: false
     };
     osrm.trip(options, function(err, first) {
@@ -130,11 +129,11 @@ test('trip: routes Berlin with hints', function(assert) {
     });
 });
 
-test('trip: trip through Berlin with geometry compression', function(assert) {
+test('trip: trip through Monaco with geometry compression', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
     };
     osrm.trip(options, function(err, trip) {
         assert.ifError(err);
@@ -144,11 +143,11 @@ test('trip: trip through Berlin with geometry compression', function(assert) {
     });
 });
 
-test('trip: trip through Berlin without geometry compression', function(assert) {
+test('trip: trip through Monaco without geometry compression', function(assert) {
     assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         geometries: 'geojson'
     };
     osrm.trip(options, function(err, trip) {
@@ -159,11 +158,11 @@ test('trip: trip through Berlin without geometry compression', function(assert)
     });
 });
 
-test('trip: trip through Berlin with speed annotations options', function(assert) {
+test('trip: trip through Monaco with speed annotations options', function(assert) {
     assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         steps: true,
         annotations: ['speed'],
         overview: 'false'
@@ -186,11 +185,11 @@ test('trip: trip through Berlin with speed annotations options', function(assert
     });
 });
 
-test('trip: trip through Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('trip: trip through Monaco with several (duration, distance, nodes) annotations options', function(assert) {
     assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         steps: true,
         annotations: ['duration', 'distance', 'nodes'],
         overview: 'false'
@@ -213,11 +212,11 @@ test('trip: trip through Berlin with several (duration, distance, nodes) annotat
     });
 });
 
-test('trip: trip through Berlin with options', function(assert) {
+test('trip: trip through Monaco with options', function(assert) {
     assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         steps: true,
         annotations: true,
         overview: 'false'
@@ -234,12 +233,11 @@ test('trip: trip through Berlin with options', function(assert) {
     });
 });
 
-test('trip: routes Berlin with null hints', function(assert) {
+test('trip: routes Monaco with null hints', function(assert) {
     assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
-        printInstructions: false,
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
         hints: [null, null]
     };
     osrm.trip(options, function(err, second) {
@@ -249,11 +247,11 @@ test('trip: routes Berlin with null hints', function(assert) {
 
 test('trip: service combinations that are not implemented', function(assert) {
     assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
 
     // fixed start, non-roundtrip
     var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
         source: 'first',
         roundtrip: false
     };
@@ -278,10 +276,10 @@ test('trip: service combinations that are not implemented', function(assert) {
 });
 
 test('trip: fixed start and end combinations', function(assert) {
-    var osrm = new OSRM(berlin_path);
-    
+    var osrm = new OSRM(data_path);
+
     var options = {
-        coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576]],
+        coordinates: two_test_coordinates,
         source: 'first',
         destination: 'last',
         roundtrip: false,
@@ -291,10 +289,8 @@ test('trip: fixed start and end combinations', function(assert) {
     // fixed start and end, non-roundtrip
     osrm.trip(options, function(err, fseTrip) {
         assert.ifError(err);
-        assert.equal(206.8, fseTrip.trips[0].duration);
         assert.equal(1, fseTrip.trips.length);
         var coordinates = fseTrip.trips[0].geometry.coordinates;
-        assert.equal(15, coordinates.length);
         assert.notEqual(JSON.stringify(coordinates[0]), JSON.stringify(coordinates[coordinates.length - 1]));
     });
 
@@ -304,9 +300,7 @@ test('trip: fixed start and end combinations', function(assert) {
         osrm.trip(options, function(err, trip) {
             assert.ifError(err);
             assert.equal(1, trip.trips.length);
-            assert.equal(422, Math.round(trip.trips[0].duration));
             var coordinates = trip.trips[0].geometry.coordinates;
-            assert.equal(29, coordinates.length);
             assert.equal(JSON.stringify(coordinates[0]), JSON.stringify(coordinates[coordinates.length - 1]));
         });
     }

unit_tests/customizer/cell_customization.cpp

@@ -38,7 +38,8 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
         edges.push_back(Edge{m.target, m.start, m.weight, false, true});
     }
     std::sort(edges.begin(), edges.end());
-    return partition::MultiLevelGraph<EdgeData, false>(mlp, max_id + 1, edges);
+    return partition::MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(
+        mlp, max_id + 1, edges);
 }
 }
 
@@ -58,6 +59,7 @@ BOOST_AUTO_TEST_CASE(two_level_test)
 
     CellStorage storage(mlp, graph);
     CellCustomizer customizer(mlp);
+    CellCustomizer::Heap heap(graph.GetNumberOfNodes());
 
     auto cell_1_0 = storage.GetCell(1, 0);
     auto cell_1_1 = storage.GetCell(1, 1);
@@ -79,8 +81,8 @@ BOOST_AUTO_TEST_CASE(two_level_test)
     REQUIRE_SIZE_RANGE(cell_1_1.GetOutWeight(2), 2);
     REQUIRE_SIZE_RANGE(cell_1_1.GetInWeight(3), 2);
 
-    customizer.Customize(graph, storage, 1, 0);
-    customizer.Customize(graph, storage, 1, 1);
+    customizer.Customize(graph, heap, storage, 1, 0);
+    customizer.Customize(graph, heap, storage, 1, 1);
 
     // cell 0
     // check row source -> destination
@@ -202,14 +204,15 @@ BOOST_AUTO_TEST_CASE(four_levels_test)
     REQUIRE_SIZE_RANGE(cell_3_0.GetDestinationNodes(), 0);
 
     CellCustomizer customizer(mlp);
+    CellCustomizer::Heap heap(graph.GetNumberOfNodes());
 
-    customizer.Customize(graph, storage, 1, 0);
-    customizer.Customize(graph, storage, 1, 1);
-    customizer.Customize(graph, storage, 1, 2);
-    customizer.Customize(graph, storage, 1, 3);
+    customizer.Customize(graph, heap, storage, 1, 0);
+    customizer.Customize(graph, heap, storage, 1, 1);
+    customizer.Customize(graph, heap, storage, 1, 2);
+    customizer.Customize(graph, heap, storage, 1, 3);
 
-    customizer.Customize(graph, storage, 2, 0);
-    customizer.Customize(graph, storage, 2, 1);
+    customizer.Customize(graph, heap, storage, 2, 0);
+    customizer.Customize(graph, heap, storage, 2, 1);
 
     // level 1
     // cell 0

unit_tests/partition/multi_level_graph.cpp

@@ -38,7 +38,7 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
         edges.push_back(Edge{m.target, m.source, false, true});
     }
     std::sort(edges.begin(), edges.end());
-    return MultiLevelGraph<EdgeData, false>(mlp, max_id + 1, edges);
+    return MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(mlp, max_id + 1, edges);
 }
 }
 

unit_tests/util/packed_vector.cpp

@@ -12,7 +12,7 @@ using namespace osrm::util;
 // Verify that the packed vector behaves as expected
 BOOST_AUTO_TEST_CASE(insert_and_retrieve_packed_test)
 {
-    PackedVector<OSMNodeID, false> packed_ids;
+    PackedVector<OSMNodeID, osrm::storage::Ownership::Container> packed_ids;
     std::vector<OSMNodeID> original_ids;
 
     const constexpr std::size_t num_test_cases = 399;
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(insert_and_retrieve_packed_test)
 
 BOOST_AUTO_TEST_CASE(packed_vector_capacity_test)
 {
-    PackedVector<OSMNodeID, false> packed_vec;
+    PackedVector<OSMNodeID, osrm::storage::Ownership::Container> packed_vec;
     const std::size_t original_size = packed_vec.capacity();
     std::vector<OSMNodeID> dummy_vec;
 

unit_tests/util/range_table.cpp

@@ -13,7 +13,7 @@ using namespace osrm;
 using namespace osrm::util;
 
 constexpr unsigned BLOCK_SIZE = 16;
-typedef RangeTable<BLOCK_SIZE, false> TestRangeTable;
+typedef RangeTable<BLOCK_SIZE, osrm::storage::Ownership::Container> TestRangeTable;
 
 void ConstructionTest(stxxl::vector<unsigned> lengths, std::vector<unsigned> offsets)
 {

unit_tests/util/static_graph.cpp

@@ -70,8 +70,8 @@ template <unsigned NUM_NODES, unsigned NUM_EDGES> struct RandomArrayEntryFixture
         std::shuffle(order.begin(), order.end(), g);
     }
 
-    typename ShM<TestNodeArrayEntry, false>::vector nodes;
-    typename ShM<TestEdgeArrayEntry, false>::vector edges;
+    std::vector<TestNodeArrayEntry> nodes;
+    std::vector<TestEdgeArrayEntry> edges;
     std::vector<unsigned> lengths;
     std::vector<unsigned> order;
 };

unit_tests/util/static_rtree.cpp

@@ -42,10 +42,11 @@ constexpr uint32_t TEST_LEAF_NODE_SIZE = 64;
 using TestData = extractor::EdgeBasedNode;
 using TestStaticRTree = StaticRTree<TestData,
                                     std::vector<Coordinate>,
-                                    false,
+                                    osrm::storage::Ownership::Container,
                                     TEST_BRANCHING_FACTOR,
                                     TEST_LEAF_NODE_SIZE>;
-using MiniStaticRTree = StaticRTree<TestData, std::vector<Coordinate>, false, 2, 128>;
+using MiniStaticRTree =
+    StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::Ownership::Container, 2, 128>;
 
 // Choosen by a fair W20 dice roll (this value is completely arbitrary)
 constexpr unsigned RANDOM_SEED = 42;
@@ -273,7 +274,8 @@ void construction_test(const std::string &prefix, FixtureT *fixture)
 
 BOOST_FIXTURE_TEST_CASE(construct_tiny, TestRandomGraphFixture_10_30)
 {
-    using TinyTestTree = StaticRTree<TestData, std::vector<Coordinate>, false, 2, 64>;
+    using TinyTestTree =
+        StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::Ownership::Container, 2, 64>;
     construction_test<TinyTestTree>("test_tiny", this);
 }