Pull turn data up into server

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -15,6 +15,7 @@
 #include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/segment_data_container.hpp"
+#include "extractor/turn_data_container.hpp"
 
 #include "partition/cell_storage.hpp"
 #include "partition/multi_level_partition.hpp"
@@ -213,21 +214,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     unsigned m_check_sum;
     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::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;
+    extractor::TurnDataView turn_data;
 
     util::vector_view<char> m_datasource_name_data;
     util::vector_view<std::size_t> m_datasource_name_offsets;
@@ -303,8 +296,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
     }
 
-    void InitializeNodeAndEdgeInformationPointers(storage::DataLayout &data_layout,
+    void InitializeNodeInformationPointers(storage::DataLayout &data_layout, char *memory_block)
-                                                  char *memory_block)
     {
         const auto coordinate_list_ptr = data_layout.GetBlockPtr<util::Coordinate>(
             memory_block, storage::DataLayout::COORDINATE_LIST);
@@ -323,66 +315,59 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         // We (ab)use the number of coordinates here because we know we have the same amount of ids
         m_osmnodeid_list.set_number_of_entries(
             data_layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
-
-        const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
-            memory_block, storage::DataLayout::TRAVEL_MODE);
-        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::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::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::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::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::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::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::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);
     }
 
-    void InitializeViaNodeListPointer(storage::DataLayout &data_layout, char *memory_block)
+    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
     {
         auto via_geometry_list_ptr =
-            data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
+            layout.GetBlockPtr<GeometryID>(memory_ptr, storage::DataLayout::VIA_NODE_LIST);
-        util::vector_view<GeometryID> via_geometry_list(
+        util::vector_view<GeometryID> geometry_ids(
-            via_geometry_list_ptr, data_layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
+            via_geometry_list_ptr, layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
-        m_via_geometry_list = std::move(via_geometry_list);
+
+        const auto travel_mode_list_ptr =
+            layout.GetBlockPtr<extractor::TravelMode>(memory_ptr, storage::DataLayout::TRAVEL_MODE);
+        util::vector_view<extractor::TravelMode> travel_modes(
+            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
+
+        const auto lane_data_id_ptr =
+            layout.GetBlockPtr<LaneDataID>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
+        util::vector_view<LaneDataID> lane_data_ids(
+            lane_data_id_ptr, layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
+
+        const auto turn_instruction_list_ptr =
+            layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
+                memory_ptr, storage::DataLayout::TURN_INSTRUCTION);
+        util::vector_view<extractor::guidance::TurnInstruction> turn_instructions(
+            turn_instruction_list_ptr, layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
+
+        const auto name_id_list_ptr =
+            layout.GetBlockPtr<NameID>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
+        util::vector_view<NameID> name_ids(name_id_list_ptr,
+                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
+
+        const auto entry_class_id_list_ptr =
+            layout.GetBlockPtr<EntryClassID>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
+        util::vector_view<EntryClassID> entry_class_ids(
+            entry_class_id_list_ptr, layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
+
+        const auto pre_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
+            memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
+        util::vector_view<util::guidance::TurnBearing> pre_turn_bearings(
+            pre_turn_bearing_ptr, layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
+
+        const auto post_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
+            memory_ptr, storage::DataLayout::POST_TURN_BEARING);
+        util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
+            post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
+
+        turn_data = extractor::TurnDataView(std::move(geometry_ids),
+                                            std::move(name_ids),
+                                            std::move(turn_instructions),
+                                            std::move(lane_data_ids),
+                                            std::move(travel_modes),
+                                            std::move(entry_class_ids),
+                                            std::move(pre_turn_bearings),
+                                            std::move(post_turn_bearings));
     }
 
     void InitializeNamePointers(storage::DataLayout &data_layout, char *memory_block)
@@ -408,6 +393,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         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);
+
+        const auto lane_tupel_id_pair_ptr =
+            data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
+                memory_block, storage::DataLayout::TURN_LANE_DATA);
+        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);
     }
 
     void InitializeTurnPenalties(storage::DataLayout &data_layout, char *memory_block)
@@ -514,11 +506,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     void InitializeInternalPointers(storage::DataLayout &data_layout, char *memory_block)
     {
         InitializeChecksumPointer(data_layout, memory_block);
-        InitializeNodeAndEdgeInformationPointers(data_layout, memory_block);
+        InitializeNodeInformationPointers(data_layout, memory_block);
+        InitializeEdgeInformationPointers(data_layout, memory_block);
         InitializeTurnPenalties(data_layout, memory_block);
         InitializeGeometryPointers(data_layout, memory_block);
         InitializeTimestampPointer(data_layout, memory_block);
-        InitializeViaNodeListPointer(data_layout, memory_block);
         InitializeNamePointers(data_layout, memory_block);
         InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
         InitializeProfilePropertiesPointer(data_layout, memory_block);
@@ -607,7 +599,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     virtual GeometryID GetGeometryIndexForEdgeID(const EdgeID id) const override final
     {
-        return m_via_geometry_list.at(id);
+        return turn_data.GetGeometryID(id);
     }
 
     virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final
@@ -625,12 +617,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID id) const override final
     {
-        return m_turn_instruction_list.at(id);
+        return turn_data.GetTurnInstruction(id);
     }
 
     extractor::TravelMode GetTravelModeForEdgeID(const EdgeID id) const override final
     {
-        return m_travel_mode_list.at(id);
+        return turn_data.GetTravelMode(id);
     }
 
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate south_west,
@@ -752,7 +744,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     NameID GetNameIndexFromEdgeID(const EdgeID id) const override final
     {
-        return m_name_ID_list.at(id);
+        return turn_data.GetNameID(id);
     }
 
     StringView GetNameForID(const NameID id) const override final
@@ -824,16 +816,16 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     EntryClassID GetEntryClassID(const EdgeID eid) const override final
     {
-        return m_entry_class_id_list.at(eid);
+        return turn_data.GetEntryClassID(eid);
     }
 
     util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
     {
-        return m_pre_turn_bearing.at(eid);
+        return turn_data.GetPreTurnBearing(eid);
     }
     util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
     {
-        return m_post_turn_bearing.at(eid);
+        return turn_data.GetPostTurnBearing(eid);
     }
 
     util::guidance::EntryClass GetEntryClass(const EntryClassID entry_class_id) const override final
@@ -841,15 +833,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_entry_class_table.at(entry_class_id);
     }
 
-    bool HasLaneData(const EdgeID id) const override final
+    bool HasLaneData(const EdgeID id) const override final { return turn_data.HasLaneData(id); }
-    {
-        return INVALID_LANE_DATAID != m_lane_data_id.at(id);
-    }
 
     util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const override final
     {
         BOOST_ASSERT(HasLaneData(id));
-        return m_lane_tupel_id_pairs.at(m_lane_data_id.at(id));
+        return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(id));
     }
 
     extractor::guidance::TurnLaneDescription

include/extractor/files.hpp

@@ -22,7 +22,8 @@ inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGT
 }
 
 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const boost::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+inline void writeNBGMapping(const boost::filesystem::path &path,
+                            const std::vector<NBGToEBG> &mapping)
 {
     const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
     storage::io::FileWriter writer{path, fingerprint};
@@ -58,7 +59,8 @@ inline void readSegmentData(const boost::filesystem::path &path, SegmentDataCont
 }
 
 // writes .osrm.geometry
-inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataContainer &segment_data)
+inline void writeSegmentData(const boost::filesystem::path &path,
+                             const SegmentDataContainer &segment_data)
 {
     const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
     storage::io::FileWriter writer{path, fingerprint};
@@ -67,8 +69,9 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD
 }
 
 // reads .osrm.edges
-template<storage::Ownership Ownership>
+template <storage::Ownership Ownership>
-inline void readTurnData(const boost::filesystem::path &path, detail::TurnDataContainerImpl<Ownership> &turn_data)
+inline void readTurnData(const boost::filesystem::path &path,
+                         detail::TurnDataContainerImpl<Ownership> &turn_data)
 {
     const auto fingerprint = storage::io::FileReader::HasNoFingerprint;
     storage::io::FileReader reader{path, fingerprint};
@@ -77,15 +80,15 @@ inline void readTurnData(const boost::filesystem::path &path, detail::TurnDataCo
 }
 
 // writes .osrm.edges
-template<storage::Ownership Ownership>
+template <storage::Ownership Ownership>
-inline void writeTurnData(const boost::filesystem::path &path, const detail::TurnDataContainerImpl<Ownership> &turn_data)
+inline void writeTurnData(const boost::filesystem::path &path,
+                          const detail::TurnDataContainerImpl<Ownership> &turn_data)
 {
     const auto fingerprint = storage::io::FileWriter::HasNoFingerprint;
     storage::io::FileWriter writer{path, fingerprint};
 
     serialization::write(writer, turn_data);
 }
-
 }
 }
 }

include/extractor/turn_data_container.hpp

@@ -69,6 +69,8 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
 
     EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
 
+    extractor::TravelMode GetTravelMode(const EdgeID id) const { return travel_modes[id]; }
+
     util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
     {
         return pre_turn_bearings[id];
@@ -79,6 +81,8 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
         return post_turn_bearings[id];
     }
 
+    LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
+
     bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
 
     NameID GetNameID(const EdgeID id) const { return name_ids[id]; }

include/partition/cell_storage.hpp

@@ -97,9 +97,10 @@ template <storage::Ownership Ownership> class CellStorageImpl
                                                              WeightValueT,
                                                              boost::random_access_traversal_tag>
         {
-            typedef boost::
+            typedef boost::iterator_facade<ColumnIterator,
-                iterator_facade<ColumnIterator, WeightValueT, boost::random_access_traversal_tag>
+                                           WeightValueT,
-                    base_t;
+                                           boost::random_access_traversal_tag>
+                base_t;
 
           public:
             typedef typename base_t::value_type value_type;

include/util/shared_memory_vector_wrapper.hpp

@@ -1,8 +1,8 @@
 #ifndef SHARED_MEMORY_VECTOR_WRAPPER_HPP
 #define SHARED_MEMORY_VECTOR_WRAPPER_HPP
 
-#include "util/log.hpp"
 #include "util/exception.hpp"
+#include "util/log.hpp"
 
 #include "storage/shared_memory_ownership.hpp"
 
@@ -86,7 +86,7 @@ template <typename DataT> class vector_view
     // for a vector-like interface
     void resize(std::size_t size) const
     {
-        if(m_size != size)
+        if (m_size != size)
         {
             throw util::exception("Invalid resize on immutable shared memory vector.");
         }
@@ -138,8 +138,7 @@ template <typename DataT> class vector_view
 
     auto data() const { return m_ptr; }
 
-    template <typename T>
+    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
-    friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
 };
 
 template <> class vector_view<bool>
@@ -163,15 +162,12 @@ template <> class vector_view<bool>
         return m_ptr[bucket] & (1u << offset);
     }
 
-    void reset(unsigned *, std::size_t size)
+    void reset(unsigned *, std::size_t size) { m_size = size; }
-    {
-        m_size = size;
-    }
 
     // for ensuring a vector compatible interface
     void resize(std::size_t size) const
     {
-        if(m_size != size)
+        if (m_size != size)
         {
             throw util::exception("Invalid resize on immutable shared memory vector.");
         }
@@ -199,7 +195,6 @@ template <typename DataT, storage::Ownership Ownership> struct ShM
                                              vector_view<DataT>,
                                              std::vector<DataT>>::type;
 };
-
 }
 }
 

src/extractor/edge_based_graph_factory.cpp

@@ -1,8 +1,8 @@
 #include "extractor/edge_based_graph_factory.hpp"
 #include "extractor/edge_based_edge.hpp"
+#include "extractor/files.hpp"
 #include "extractor/guidance/turn_analysis.hpp"
 #include "extractor/guidance/turn_lane_handler.hpp"
-#include "extractor/files.hpp"
 #include "extractor/scripting_environment.hpp"
 #include "extractor/suffix_table.hpp"
 

src/extractor/extractor.cpp

@@ -512,7 +512,8 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
     });
 
     WriteTurnLaneData(config.turn_lane_descriptions_file_name);
-    files::writeSegmentData(config.geometry_output_path, *compressed_edge_container.ToSegmentData());
+    files::writeSegmentData(config.geometry_output_path,
+                            *compressed_edge_container.ToSegmentData());
 
     edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
     edge_based_graph_factory.GetEdgeBasedNodes(node_based_edge_list);

src/updater/updater.cpp

@@ -2,11 +2,11 @@
 
 #include "updater/csv_source.hpp"
 
-#include "extractor/files.hpp"
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/edge_based_graph_factory.hpp"
-#include "extractor/seralization.hpp"
+#include "extractor/files.hpp"
 #include "extractor/node_based_edge.hpp"
+#include "extractor/seralization.hpp"
 
 #include "storage/io.hpp"
 
@@ -515,12 +515,11 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
         updated_segments.resize(offset + updated_turn_penalties.size());
         // we need to re-compute all edges that have updated turn penalties.
         // this marks it for re-computation
-        std::transform(updated_turn_penalties.begin(),
+        std::transform(
-                       updated_turn_penalties.end(),
+            updated_turn_penalties.begin(),
-                       updated_segments.begin() + offset,
+            updated_turn_penalties.end(),
-                       [&turn_data](const std::uint64_t turn_id) {
+            updated_segments.begin() + offset,
-                           return turn_data.GetGeometryID(turn_id);
+            [&turn_data](const std::uint64_t turn_id) { return turn_data.GetGeometryID(turn_id); });
-                       });
     }
 
     tbb::parallel_sort(updated_segments.begin(),