Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Pull turn data up into server

Browse Source
This commit is contained in:
Patrick Niklaus 2017-04-02 01:25:55 +00:00 committed by Patrick Niklaus
parent d7e1c9c09c
commit 97d1de1beb
8 changed files with 103 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
include/engine/datafacade/contiguous_internalmem_datafacade.hpp
View File

@ -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,
char *memory_block)
void InitializeNodeInformationPointers(storage::DataLayout &data_layout, 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);
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);
layout.GetBlockPtr<GeometryID>(memory_ptr, storage::DataLayout::VIA_NODE_LIST);
util::vector_view<GeometryID> geometry_ids(
via_geometry_list_ptr, layout.num_entries[storage::DataLayout::VIA_NODE_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
{
return INVALID_LANE_DATAID != m_lane_data_id.at(id);
}
bool HasLaneData(const EdgeID id) const override final { return turn_data.HasLaneData(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

17
include/extractor/files.hpp
View File

@ -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>
inline void readTurnData(const boost::filesystem::path &path, detail::TurnDataContainerImpl<Ownership> &turn_data)
template <storage::Ownership Ownership>
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>
inline void writeTurnData(const boost::filesystem::path &path, const detail::TurnDataContainerImpl<Ownership> &turn_data)
template <storage::Ownership Ownership>
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);
}
}
}
}

4
include/extractor/turn_data_container.hpp
View File

@ -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]; }

7
include/partition/cell_storage.hpp
View File

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

15
include/util/shared_memory_vector_wrapper.hpp
View File

@ -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>
friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
template <typename T> 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)
{
m_size = size;
}
void reset(unsigned *, std::size_t 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;
};
}
}

2
src/extractor/edge_based_graph_factory.cpp
View File

@ -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"

3
src/extractor/extractor.cpp
View File

@ -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);

15
src/updater/updater.cpp
View File

@ -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(),
updated_turn_penalties.end(),
updated_segments.begin() + offset,
[&turn_data](const std::uint64_t turn_id) {
return turn_data.GetGeometryID(turn_id);
});
std::transform(
updated_turn_penalties.begin(),
updated_turn_penalties.end(),
updated_segments.begin() + offset,
[&turn_data](const std::uint64_t turn_id) { return turn_data.GetGeometryID(turn_id); });
}
tbb::parallel_sort(updated_segments.begin(),