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

clang-format

Browse Source
This commit is contained in:
Pepijn Schoen 2017-03-29 14:07:03 +02:00 committed by Patrick Niklaus
parent 266e65e6d2
commit 157ca9161f
19 changed files with 1786 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/customizer/edge_based_graph.hpp
View File

@ -18,16 +18,21 @@ namespace customizer
using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData; using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;
struct MultiLevelEdgeBasedGraph : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, osrm::storage::MemorySetting::InternalMemory> struct MultiLevelEdgeBasedGraph
: public partition::MultiLevelGraph<EdgeBasedGraphEdgeData,
osrm::storage::MemorySetting::InternalMemory>
{ {
using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, osrm::storage::MemorySetting::InternalMemory>; using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData,
osrm::storage::MemorySetting::InternalMemory>;
using Base::Base; using Base::Base;
}; };
struct MultiLevelEdgeBasedGraphView struct MultiLevelEdgeBasedGraphView
: public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, osrm::storage::MemorySetting::SharedMemory> : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData,
osrm::storage::MemorySetting::SharedMemory>
{ {
using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, osrm::storage::MemorySetting::SharedMemory>; using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData,
osrm::storage::MemorySetting::SharedMemory>;
using Base::Base; using Base::Base;
}; };

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

@ -202,8 +202,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
using super = BaseDataFacade; using super = BaseDataFacade;
using IndexBlock = util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT; using IndexBlock = util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT;
using RTreeLeaf = super::RTreeLeaf; using RTreeLeaf = super::RTreeLeaf;
using SharedRTree = using SharedRTree = util::StaticRTree<
util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector, osrm::storage::MemorySetting::SharedMemory>; RTreeLeaf,
util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector,
osrm::storage::MemorySetting::SharedMemory>;
using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>; using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
using RTreeNode = SharedRTree::TreeNode; using RTreeNode = SharedRTree::TreeNode;
@ -212,28 +214,40 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
extractor::Datasources *m_datasources; extractor::Datasources *m_datasources;
unsigned m_check_sum; unsigned m_check_sum;
util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector m_coordinate_list; util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector
m_coordinate_list;
util::PackedVector<OSMNodeID, osrm::storage::MemorySetting::SharedMemory> m_osmnodeid_list; util::PackedVector<OSMNodeID, osrm::storage::MemorySetting::SharedMemory> m_osmnodeid_list;
util::ShM<GeometryID, osrm::storage::MemorySetting::SharedMemory>::vector m_via_geometry_list; util::ShM<GeometryID, osrm::storage::MemorySetting::SharedMemory>::vector m_via_geometry_list;
util::ShM<NameID, osrm::storage::MemorySetting::SharedMemory>::vector m_name_ID_list; util::ShM<NameID, osrm::storage::MemorySetting::SharedMemory>::vector m_name_ID_list;
util::ShM<LaneDataID, osrm::storage::MemorySetting::SharedMemory>::vector m_lane_data_id; util::ShM<LaneDataID, osrm::storage::MemorySetting::SharedMemory>::vector m_lane_data_id;
util::ShM<extractor::guidance::TurnInstruction, osrm::storage::MemorySetting::SharedMemory>::vector m_turn_instruction_list; util::ShM<extractor::guidance::TurnInstruction,
util::ShM<extractor::TravelMode, osrm::storage::MemorySetting::SharedMemory>::vector m_travel_mode_list; osrm::storage::MemorySetting::SharedMemory>::vector m_turn_instruction_list;
util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector m_pre_turn_bearing; util::ShM<extractor::TravelMode, osrm::storage::MemorySetting::SharedMemory>::vector
util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector m_post_turn_bearing; m_travel_mode_list;
util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector
m_pre_turn_bearing;
util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector
m_post_turn_bearing;
util::NameTable m_names_table; util::NameTable m_names_table;
util::ShM<unsigned, osrm::storage::MemorySetting::SharedMemory>::vector m_name_begin_indices; util::ShM<unsigned, osrm::storage::MemorySetting::SharedMemory>::vector m_name_begin_indices;
util::ShM<bool, osrm::storage::MemorySetting::SharedMemory>::vector m_is_core_node; util::ShM<bool, osrm::storage::MemorySetting::SharedMemory>::vector m_is_core_node;
util::ShM<std::uint32_t, osrm::storage::MemorySetting::SharedMemory>::vector m_lane_description_offsets; util::ShM<std::uint32_t, osrm::storage::MemorySetting::SharedMemory>::vector
util::ShM<extractor::guidance::TurnLaneType::Mask, osrm::storage::MemorySetting::SharedMemory>::vector m_lane_description_masks; m_lane_description_offsets;
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector m_turn_weight_penalties; util::ShM<extractor::guidance::TurnLaneType::Mask,
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector m_turn_duration_penalties; osrm::storage::MemorySetting::SharedMemory>::vector m_lane_description_masks;
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector
m_turn_weight_penalties;
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector
m_turn_duration_penalties;
extractor::SegmentDataView segment_data; extractor::SegmentDataView segment_data;
util::ShM<char, osrm::storage::MemorySetting::SharedMemory>::vector m_datasource_name_data; util::ShM<char, osrm::storage::MemorySetting::SharedMemory>::vector m_datasource_name_data;
util::ShM<std::size_t, osrm::storage::MemorySetting::SharedMemory>::vector m_datasource_name_offsets; util::ShM<std::size_t, osrm::storage::MemorySetting::SharedMemory>::vector
util::ShM<std::size_t, osrm::storage::MemorySetting::SharedMemory>::vector m_datasource_name_lengths; m_datasource_name_offsets;
util::ShM<util::guidance::LaneTupleIdPair, osrm::storage::MemorySetting::SharedMemory>::vector m_lane_tupel_id_pairs; util::ShM<std::size_t, osrm::storage::MemorySetting::SharedMemory>::vector
m_datasource_name_lengths;
util::ShM<util::guidance::LaneTupleIdPair, osrm::storage::MemorySetting::SharedMemory>::vector
m_lane_tupel_id_pairs;
std::unique_ptr<SharedRTree> m_static_rtree; std::unique_ptr<SharedRTree> m_static_rtree;
std::unique_ptr<SharedGeospatialQuery> m_geospatial_query; std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
@ -241,17 +255,22 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
util::NameTable m_name_table; util::NameTable m_name_table;
// bearing classes by node based node // bearing classes by node based node
util::ShM<BearingClassID, osrm::storage::MemorySetting::SharedMemory>::vector m_bearing_class_id_table; util::ShM<BearingClassID, osrm::storage::MemorySetting::SharedMemory>::vector
m_bearing_class_id_table;
// entry class IDs // entry class IDs
util::ShM<EntryClassID, osrm::storage::MemorySetting::SharedMemory>::vector m_entry_class_id_list; util::ShM<EntryClassID, osrm::storage::MemorySetting::SharedMemory>::vector
m_entry_class_id_list;
// the look-up table for entry classes. An entry class lists the possibility of entry for all // 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. // available turns. Such a class id is stored with every edge.
util::ShM<util::guidance::EntryClass, osrm::storage::MemorySetting::SharedMemory>::vector m_entry_class_table; util::ShM<util::guidance::EntryClass, osrm::storage::MemorySetting::SharedMemory>::vector
m_entry_class_table;
// the look-up table for distinct bearing classes. A bearing class lists the available bearings // the look-up table for distinct bearing classes. A bearing class lists the available bearings
// at an intersection // at an intersection
std::shared_ptr<util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>> m_bearing_ranges_table; std::shared_ptr<util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>>
util::ShM<DiscreteBearing, osrm::storage::MemorySetting::SharedMemory>::vector m_bearing_values_table; m_bearing_ranges_table;
util::ShM<DiscreteBearing, osrm::storage::MemorySetting::SharedMemory>::vector
m_bearing_values_table;
// allocator that keeps the allocation data // allocator that keeps the allocation data
std::shared_ptr<ContiguousBlockAllocator> allocator; std::shared_ptr<ContiguousBlockAllocator> allocator;
@ -327,8 +346,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>( const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
memory_block, storage::DataLayout::TRAVEL_MODE); memory_block, storage::DataLayout::TRAVEL_MODE);
util::ShM<extractor::TravelMode, osrm::storage::MemorySetting::SharedMemory>::vector travel_mode_list( util::ShM<extractor::TravelMode, osrm::storage::MemorySetting::SharedMemory>::vector
travel_mode_list_ptr, data_layout.num_entries[storage::DataLayout::TRAVEL_MODE]); travel_mode_list(travel_mode_list_ptr,
data_layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
m_travel_mode_list = std::move(travel_mode_list); m_travel_mode_list = std::move(travel_mode_list);
const auto lane_data_id_ptr = const auto lane_data_id_ptr =
@ -340,15 +360,18 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
const auto lane_tupel_id_pair_ptr = const auto lane_tupel_id_pair_ptr =
data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>( data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
memory_block, storage::DataLayout::TURN_LANE_DATA); memory_block, storage::DataLayout::TURN_LANE_DATA);
util::ShM<util::guidance::LaneTupleIdPair, osrm::storage::MemorySetting::SharedMemory>::vector lane_tupel_id_pair( util::ShM<util::guidance::LaneTupleIdPair,
lane_tupel_id_pair_ptr, data_layout.num_entries[storage::DataLayout::TURN_LANE_DATA]); osrm::storage::MemorySetting::SharedMemory>::vector
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); m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
const auto turn_instruction_list_ptr = const auto turn_instruction_list_ptr =
data_layout.GetBlockPtr<extractor::guidance::TurnInstruction>( data_layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
memory_block, storage::DataLayout::TURN_INSTRUCTION); memory_block, storage::DataLayout::TURN_INSTRUCTION);
util::ShM<extractor::guidance::TurnInstruction, osrm::storage::MemorySetting::SharedMemory>::vector turn_instruction_list( util::ShM<extractor::guidance::TurnInstruction,
turn_instruction_list_ptr, osrm::storage::MemorySetting::SharedMemory>::vector
turn_instruction_list(turn_instruction_list_ptr,
data_layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]); data_layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
m_turn_instruction_list = std::move(turn_instruction_list); m_turn_instruction_list = std::move(turn_instruction_list);
@ -360,20 +383,25 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
const auto entry_class_id_list_ptr = const auto entry_class_id_list_ptr =
data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID); data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID);
typename util::ShM<EntryClassID, osrm::storage::MemorySetting::SharedMemory>::vector entry_class_id_list( typename util::ShM<EntryClassID, osrm::storage::MemorySetting::SharedMemory>::vector
entry_class_id_list_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASSID]); 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); m_entry_class_id_list = std::move(entry_class_id_list);
const auto pre_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>( const auto pre_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
memory_block, storage::DataLayout::PRE_TURN_BEARING); memory_block, storage::DataLayout::PRE_TURN_BEARING);
typename util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector pre_turn_bearing( typename util::ShM<util::guidance::TurnBearing,
pre_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]); osrm::storage::MemorySetting::SharedMemory>::vector
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); m_pre_turn_bearing = std::move(pre_turn_bearing);
const auto post_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>( const auto post_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
memory_block, storage::DataLayout::POST_TURN_BEARING); memory_block, storage::DataLayout::POST_TURN_BEARING);
typename util::ShM<util::guidance::TurnBearing, osrm::storage::MemorySetting::SharedMemory>::vector post_turn_bearing( typename util::ShM<util::guidance::TurnBearing,
post_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::POST_TURN_BEARING]); osrm::storage::MemorySetting::SharedMemory>::vector
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); m_post_turn_bearing = std::move(post_turn_bearing);
} }
@ -406,8 +434,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>( auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>(
memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS); memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);
util::ShM<extractor::guidance::TurnLaneType::Mask, osrm::storage::MemorySetting::SharedMemory>::vector masks( util::ShM<extractor::guidance::TurnLaneType::Mask,
masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]); osrm::storage::MemorySetting::SharedMemory>::vector
masks(masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
m_lane_description_masks = std::move(masks); m_lane_description_masks = std::move(masks);
} }
@ -415,12 +444,14 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
{ {
auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>( auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES); memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES);
m_turn_weight_penalties = util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector( m_turn_weight_penalties =
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector(
turn_weight_penalties_ptr, turn_weight_penalties_ptr,
data_layout.num_entries[storage::DataLayout::TURN_WEIGHT_PENALTIES]); data_layout.num_entries[storage::DataLayout::TURN_WEIGHT_PENALTIES]);
auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>( auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
memory_block, storage::DataLayout::TURN_DURATION_PENALTIES); memory_block, storage::DataLayout::TURN_DURATION_PENALTIES);
m_turn_duration_penalties = util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector( m_turn_duration_penalties =
util::ShM<TurnPenalty, osrm::storage::MemorySetting::SharedMemory>::vector(
turn_duration_penalties_ptr, turn_duration_penalties_ptr,
data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]); data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
} }
@ -429,8 +460,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
{ {
auto geometries_index_ptr = auto geometries_index_ptr =
data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX); data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
util::ShM<unsigned, osrm::storage::MemorySetting::SharedMemory>::vector geometry_begin_indices( util::ShM<unsigned, osrm::storage::MemorySetting::SharedMemory>::vector
geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]); geometry_begin_indices(geometries_index_ptr,
data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);
auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>( auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST); memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
@ -440,32 +472,37 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
auto geometries_fwd_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>( auto geometries_fwd_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST); memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector geometry_fwd_weight_list( util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector
geometry_fwd_weight_list(
geometries_fwd_weight_list_ptr, geometries_fwd_weight_list_ptr,
data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]); data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]);
auto geometries_rev_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>( auto geometries_rev_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST); memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector geometry_rev_weight_list( util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector
geometry_rev_weight_list(
geometries_rev_weight_list_ptr, geometries_rev_weight_list_ptr,
data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]); data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]);
auto geometries_fwd_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>( auto geometries_fwd_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST); memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector geometry_fwd_duration_list( util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector
geometry_fwd_duration_list(
geometries_fwd_duration_list_ptr, geometries_fwd_duration_list_ptr,
data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]); data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]);
auto geometries_rev_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>( auto geometries_rev_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST); memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector geometry_rev_duration_list( util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector
geometry_rev_duration_list(
geometries_rev_duration_list_ptr, geometries_rev_duration_list_ptr,
data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]); data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]);
auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>( auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
memory_block, storage::DataLayout::DATASOURCES_LIST); memory_block, storage::DataLayout::DATASOURCES_LIST);
util::ShM<DatasourceID, osrm::storage::MemorySetting::SharedMemory>::vector datasources_list( util::ShM<DatasourceID, osrm::storage::MemorySetting::SharedMemory>::vector
datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]); datasources_list(datasources_list_ptr,
data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);
segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices), segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
std::move(geometry_node_list), std::move(geometry_node_list),
@ -483,14 +520,16 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
{ {
auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>( auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
memory_block, storage::DataLayout::BEARING_CLASSID); memory_block, storage::DataLayout::BEARING_CLASSID);
typename util::ShM<BearingClassID, osrm::storage::MemorySetting::SharedMemory>::vector bearing_class_id_table( typename util::ShM<BearingClassID, osrm::storage::MemorySetting::SharedMemory>::vector
bearing_class_id_ptr, data_layout.num_entries[storage::DataLayout::BEARING_CLASSID]); 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); m_bearing_class_id_table = std::move(bearing_class_id_table);
auto bearing_class_ptr = data_layout.GetBlockPtr<DiscreteBearing>( auto bearing_class_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
memory_block, storage::DataLayout::BEARING_VALUES); memory_block, storage::DataLayout::BEARING_VALUES);
typename util::ShM<DiscreteBearing, osrm::storage::MemorySetting::SharedMemory>::vector bearing_class_table( typename util::ShM<DiscreteBearing, osrm::storage::MemorySetting::SharedMemory>::vector
bearing_class_ptr, data_layout.num_entries[storage::DataLayout::BEARING_VALUES]); bearing_class_table(bearing_class_ptr,
data_layout.num_entries[storage::DataLayout::BEARING_VALUES]);
m_bearing_values_table = std::move(bearing_class_table); m_bearing_values_table = std::move(bearing_class_table);
auto offsets_ptr = auto offsets_ptr =
@ -502,13 +541,18 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
util::ShM<IndexBlock, osrm::storage::MemorySetting::SharedMemory>::vector bearing_blocks( util::ShM<IndexBlock, osrm::storage::MemorySetting::SharedMemory>::vector bearing_blocks(
blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]); blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);
m_bearing_ranges_table = std::make_unique<util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>>( m_bearing_ranges_table =
bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size())); std::make_unique<util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>>(
bearing_offsets,
bearing_blocks,
static_cast<unsigned>(m_bearing_values_table.size()));
auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>( auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
memory_block, storage::DataLayout::ENTRY_CLASS); memory_block, storage::DataLayout::ENTRY_CLASS);
typename util::ShM<util::guidance::EntryClass, osrm::storage::MemorySetting::SharedMemory>::vector entry_class_table( typename util::ShM<util::guidance::EntryClass,
entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]); osrm::storage::MemorySetting::SharedMemory>::vector
entry_class_table(entry_class_ptr,
data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
m_entry_class_table = std::move(entry_class_table); m_entry_class_table = std::move(entry_class_table);
} }
@ -930,15 +974,15 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
memory_block, storage::DataLayout::MLD_PARTITION); memory_block, storage::DataLayout::MLD_PARTITION);
auto partition_entries_count = auto partition_entries_count =
data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION); data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
util::ShM<PartitionID, osrm::storage::MemorySetting::SharedMemory>::vector partition(mld_partition_ptr, util::ShM<PartitionID, osrm::storage::MemorySetting::SharedMemory>::vector partition(
partition_entries_count); mld_partition_ptr, partition_entries_count);
auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>( auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN); memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN);
auto children_entries_count = auto children_entries_count =
data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN); data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
util::ShM<CellID, osrm::storage::MemorySetting::SharedMemory>::vector cell_to_children(mld_chilren_ptr, util::ShM<CellID, osrm::storage::MemorySetting::SharedMemory>::vector cell_to_children(
children_entries_count); mld_chilren_ptr, children_entries_count);
mld_partition = mld_partition =
partition::MultiLevelPartitionView{level_data, partition, cell_to_children}; partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
@ -970,15 +1014,18 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
auto cell_level_offsets_entries_count = auto cell_level_offsets_entries_count =
data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS); data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector weights(mld_cell_weights_ptr, weight_entries_count); util::ShM<EdgeWeight, osrm::storage::MemorySetting::SharedMemory>::vector weights(
util::ShM<NodeID, osrm::storage::MemorySetting::SharedMemory>::vector source_boundary(mld_source_boundary_ptr, mld_cell_weights_ptr, weight_entries_count);
source_boundary_entries_count); util::ShM<NodeID, osrm::storage::MemorySetting::SharedMemory>::vector source_boundary(
util::ShM<NodeID, osrm::storage::MemorySetting::SharedMemory>::vector destination_boundary( mld_source_boundary_ptr, source_boundary_entries_count);
mld_destination_boundary_ptr, destination_boundary_entries_count); util::ShM<NodeID, osrm::storage::MemorySetting::SharedMemory>::vector
util::ShM<partition::CellStorageView::CellData, osrm::storage::MemorySetting::SharedMemory>::vector cells( destination_boundary(mld_destination_boundary_ptr,
mld_cells_ptr, cells_entries_counts); destination_boundary_entries_count);
util::ShM<std::uint64_t, osrm::storage::MemorySetting::SharedMemory>::vector level_offsets(mld_cell_level_offsets_ptr, util::ShM<partition::CellStorageView::CellData,
cell_level_offsets_entries_count); osrm::storage::MemorySetting::SharedMemory>::vector
cells(mld_cells_ptr, cells_entries_counts);
util::ShM<std::uint64_t, osrm::storage::MemorySetting::SharedMemory>::vector
level_offsets(mld_cell_level_offsets_ptr, cell_level_offsets_entries_count);
mld_cell_storage = partition::CellStorageView{std::move(weights), mld_cell_storage = partition::CellStorageView{std::move(weights),
std::move(source_boundary), std::move(source_boundary),
@ -1002,8 +1049,8 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]); graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
util::ShM<GraphEdge, osrm::storage::MemorySetting::SharedMemory>::vector edge_list( util::ShM<GraphEdge, osrm::storage::MemorySetting::SharedMemory>::vector edge_list(
graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]); graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
util::ShM<QueryGraph::EdgeOffset, osrm::storage::MemorySetting::SharedMemory>::vector node_to_offset( util::ShM<QueryGraph::EdgeOffset, osrm::storage::MemorySetting::SharedMemory>::vector
graph_node_to_offset_ptr, node_to_offset(graph_node_to_offset_ptr,
data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]); data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);
query_graph = query_graph =

1087
include/engine/datafacade/contiguous_internalmem_datafacade.hpp~RF1bba25.TMP Normal file
View File

File diff suppressed because it is too large Load Diff

6
include/extractor/segment_data_container.hpp
View File

@ -208,8 +208,10 @@ template <osrm::storage::MemorySetting MemorySetting> class SegmentDataContainer
}; };
} }
using SegmentDataView = detail::SegmentDataContainerImpl<osrm::storage::MemorySetting::SharedMemory>; using SegmentDataView =
using SegmentDataContainer = detail::SegmentDataContainerImpl<osrm::storage::MemorySetting::InternalMemory>; detail::SegmentDataContainerImpl<osrm::storage::MemorySetting::SharedMemory>;
using SegmentDataContainer =
detail::SegmentDataContainerImpl<osrm::storage::MemorySetting::InternalMemory>;
} }
} }

11
include/partition/cell_storage.hpp
View File

@ -186,7 +186,9 @@ template <osrm::storage::MemorySetting MemorySetting> class CellStorageImpl
CellStorageImpl() {} CellStorageImpl() {}
template <typename GraphT, typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::InternalMemory>> template <
typename GraphT,
typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::InternalMemory>>
CellStorageImpl(const partition::MultiLevelPartition &partition, const GraphT &base_graph) 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 // pre-allocate storge for CellData so we can have random access to it by cell id
@ -315,7 +317,8 @@ template <osrm::storage::MemorySetting MemorySetting> class CellStorageImpl
weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT); weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT);
} }
template <typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::SharedMemory>> template <
typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::SharedMemory>>
CellStorageImpl(Vector<EdgeWeight> weights_, CellStorageImpl(Vector<EdgeWeight> weights_,
Vector<NodeID> source_boundary_, Vector<NodeID> source_boundary_,
Vector<NodeID> destination_boundary_, Vector<NodeID> destination_boundary_,
@ -340,7 +343,9 @@ template <osrm::storage::MemorySetting MemorySetting> class CellStorageImpl
destination_boundary.empty() ? nullptr : destination_boundary.data()}; destination_boundary.empty() ? nullptr : destination_boundary.data()};
} }
template <typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::InternalMemory>> Cell GetCell(LevelID level, CellID id) template <
typename = std::enable_if<MemorySetting == osrm::storage::MemorySetting::InternalMemory>>
Cell GetCell(LevelID level, CellID id)
{ {
const auto level_index = LevelIDToIndex(level); const auto level_index = LevelIDToIndex(level);
BOOST_ASSERT(level_index < level_to_cell_offset.size()); BOOST_ASSERT(level_index < level_to_cell_offset.size());

15
include/partition/multi_level_partition.hpp
View File

@ -28,14 +28,15 @@ namespace detail
{ {
template <osrm::storage::MemorySetting MemorySetting> class MultiLevelPartitionImpl; template <osrm::storage::MemorySetting MemorySetting> class MultiLevelPartitionImpl;
} }
using MultiLevelPartition = detail::MultiLevelPartitionImpl<osrm::storage::MemorySetting::InternalMemory>; using MultiLevelPartition =
using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<osrm::storage::MemorySetting::SharedMemory>; detail::MultiLevelPartitionImpl<osrm::storage::MemorySetting::InternalMemory>;
using MultiLevelPartitionView =
detail::MultiLevelPartitionImpl<osrm::storage::MemorySetting::SharedMemory>;
namespace io namespace io
{ {
template <osrm::storage::MemorySetting MemorySetting> template <osrm::storage::MemorySetting MemorySetting>
void read(const boost::filesystem::path &file, void read(const boost::filesystem::path &file, detail::MultiLevelPartitionImpl<MemorySetting> &mlp);
detail::MultiLevelPartitionImpl<MemorySetting> &mlp);
template <osrm::storage::MemorySetting MemorySetting> template <osrm::storage::MemorySetting MemorySetting>
void write(const boost::filesystem::path &file, void write(const boost::filesystem::path &file,
const detail::MultiLevelPartitionImpl<MemorySetting> &mlp); const detail::MultiLevelPartitionImpl<MemorySetting> &mlp);
@ -69,7 +70,8 @@ template <osrm::storage::MemorySetting MemorySetting> class MultiLevelPartitionI
// cell_sizes is index by level (starting at 0, the base graph). // 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 // However level 0 always needs to have cell size 1, since it is the
// basegraph. // basegraph.
template <typename = typename std::enable_if<MemorySetting == osrm::storage::MemorySetting::InternalMemory>> template <typename = typename std::enable_if<MemorySetting ==
osrm::storage::MemorySetting::InternalMemory>>
MultiLevelPartitionImpl(const std::vector<std::vector<CellID>> &partitions, MultiLevelPartitionImpl(const std::vector<std::vector<CellID>> &partitions,
const std::vector<std::uint32_t> &lidx_to_num_cells) const std::vector<std::uint32_t> &lidx_to_num_cells)
: level_data(MakeLevelData(lidx_to_num_cells)) : level_data(MakeLevelData(lidx_to_num_cells))
@ -77,7 +79,8 @@ template <osrm::storage::MemorySetting MemorySetting> class MultiLevelPartitionI
InitializePartitionIDs(partitions); InitializePartitionIDs(partitions);
} }
template <typename = typename std::enable_if<MemorySetting == osrm::storage::MemorySetting::SharedMemory>> template <typename = typename std::enable_if<MemorySetting ==
osrm::storage::MemorySetting::SharedMemory>>
MultiLevelPartitionImpl(LevelData level_data, MultiLevelPartitionImpl(LevelData level_data,
Vector<PartitionID> partition_, Vector<PartitionID> partition_,
Vector<CellID> cell_to_children_) Vector<CellID> cell_to_children_)

4
include/util/packed_vector.hpp
View File

@ -22,7 +22,9 @@ namespace util
* NOTE: this type is templated for future use, but will require a slight refactor to * NOTE: this type is templated for future use, but will require a slight refactor to
* configure BITSIZE and ELEMSIZE * configure BITSIZE and ELEMSIZE
*/ */
template <typename T, osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory> class PackedVector template <typename T,
osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory>
class PackedVector
{ {
static const constexpr std::size_t BITSIZE = 33; static const constexpr std::size_t BITSIZE = 33;
static const constexpr std::size_t ELEMSIZE = 64; static const constexpr std::size_t ELEMSIZE = 64;

6
include/util/range_table.hpp
View File

@ -2,8 +2,8 @@
#define RANGE_TABLE_HPP #define RANGE_TABLE_HPP
#include "storage/io.hpp" #include "storage/io.hpp"
#include "util/integer_range.hpp"
#include "storage/shared_memory.hpp" #include "storage/shared_memory.hpp"
#include "util/integer_range.hpp"
#include "util/shared_memory_vector_wrapper.hpp" #include "util/shared_memory_vector_wrapper.hpp"
#include <array> #include <array>
@ -19,7 +19,9 @@ namespace util
* and otherwise the compiler gets confused. * and otherwise the compiler gets confused.
*/ */
template <unsigned BLOCK_SIZE = 16, osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory> class RangeTable; template <unsigned BLOCK_SIZE = 16,
osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory>
class RangeTable;
template <unsigned BLOCK_SIZE, osrm::storage::MemorySetting MemorySetting> template <unsigned BLOCK_SIZE, osrm::storage::MemorySetting MemorySetting>
std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, MemorySetting> &table); std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, MemorySetting> &table);

3
include/util/shared_memory_vector_wrapper.hpp
View File

@ -177,7 +177,8 @@ void swap(SharedMemoryWrapper<DataT> &lhs, SharedMemoryWrapper<DataT> &rhs) noex
template <typename DataT, osrm::storage::MemorySetting MemorySetting> struct ShM template <typename DataT, osrm::storage::MemorySetting MemorySetting> struct ShM
{ {
using vector = typename std::conditional<MemorySetting == osrm::storage::MemorySetting::SharedMemory, using vector =
typename std::conditional<MemorySetting == osrm::storage::MemorySetting::SharedMemory,
SharedMemoryWrapper<DataT>, SharedMemoryWrapper<DataT>,
std::vector<DataT>>::type; std::vector<DataT>>::type;
}; };

4
include/util/static_graph.hpp
View File

@ -99,7 +99,9 @@ EntryT edgeToEntry(const OtherEdge &from, std::false_type)
} // namespace static_graph_details } // namespace static_graph_details
template <typename EdgeDataT, osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory> class StaticGraph template <typename EdgeDataT,
osrm::storage::MemorySetting MemorySetting = osrm::storage::MemorySetting::InternalMemory>
class StaticGraph
{ {
public: public:
using InputEdge = static_graph_details::SortableEdgeWithData<EdgeDataT>; using InputEdge = static_graph_details::SortableEdgeWithData<EdgeDataT>;

6
src/benchmarks/static_rtree.cpp
View File

@ -27,8 +27,10 @@ constexpr int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION;
constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION; constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
using RTreeLeaf = extractor::EdgeBasedNode; using RTreeLeaf = extractor::EdgeBasedNode;
using BenchStaticRTree = using BenchStaticRTree = util::StaticRTree<
util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, osrm::storage::MemorySetting::InternalMemory>::vector, osrm::storage::MemorySetting::InternalMemory>; RTreeLeaf,
util::ShM<util::Coordinate, osrm::storage::MemorySetting::InternalMemory>::vector,
osrm::storage::MemorySetting::InternalMemory>;
std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file) std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file)
{ {

3
src/customize/customizer.cpp
View File

@ -85,7 +85,8 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
auto tidied = auto tidied =
partition::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed)); partition::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed));
auto edge_based_graph = auto edge_based_graph =
std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData, osrm::storage::MemorySetting::InternalMemory>>( std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData,
osrm::storage::MemorySetting::InternalMemory>>(
mlp, num_nodes, std::move(tidied)); mlp, num_nodes, std::move(tidied));
util::Log() << "Loaded edge based graph for mapping partition ids: " util::Log() << "Loaded edge based graph for mapping partition ids: "

26
src/storage/storage.cpp
View File

@ -55,8 +55,10 @@ namespace storage
{ {
using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf; using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf;
using RTreeNode = using RTreeNode = util::StaticRTree<
util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector, osrm::storage::MemorySetting::SharedMemory>::TreeNode; RTreeLeaf,
util::ShM<util::Coordinate, osrm::storage::MemorySetting::SharedMemory>::vector,
osrm::storage::MemorySetting::SharedMemory>::TreeNode;
using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>; using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>; using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>;
@ -364,12 +366,15 @@ void Storage::PopulateLayout(DataLayout &layout)
intersection_file.Skip<std::uint32_t>(1); // sum_lengths intersection_file.Skip<std::uint32_t>(1); // sum_lengths
layout.SetBlockSize<unsigned>(DataLayout::BEARING_OFFSETS, bearing_blocks); layout.SetBlockSize<unsigned>(DataLayout::BEARING_OFFSETS, bearing_blocks);
layout.SetBlockSize<typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT>(DataLayout::BEARING_BLOCKS, layout.SetBlockSize<
bearing_blocks); typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT>(
DataLayout::BEARING_BLOCKS, bearing_blocks);
// No need to read the data // No need to read the data
intersection_file.Skip<unsigned>(bearing_blocks); intersection_file.Skip<unsigned>(bearing_blocks);
intersection_file.Skip<typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT>(bearing_blocks); intersection_file.Skip<
typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT>(
bearing_blocks);
const auto num_bearings = intersection_file.ReadElementCount64(); const auto num_bearings = intersection_file.ReadElementCount64();
@ -803,8 +808,9 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
intersection_file.Skip<std::uint32_t>(1); // sum_lengths intersection_file.Skip<std::uint32_t>(1); // sum_lengths
std::vector<unsigned> bearing_offsets_data(bearing_blocks); std::vector<unsigned> bearing_offsets_data(bearing_blocks);
std::vector<typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT> bearing_blocks_data( std::vector<
bearing_blocks); typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT>
bearing_blocks_data(bearing_blocks);
intersection_file.ReadInto(bearing_offsets_data.data(), bearing_blocks); intersection_file.ReadInto(bearing_offsets_data.data(), bearing_blocks);
intersection_file.ReadInto(bearing_blocks_data.data(), bearing_blocks); intersection_file.ReadInto(bearing_blocks_data.data(), bearing_blocks);
@ -843,9 +849,9 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
if (layout.GetBlockSize(DataLayout::BEARING_BLOCKS) > 0) if (layout.GetBlockSize(DataLayout::BEARING_BLOCKS) > 0)
{ {
const auto bearing_blocks_ptr = const auto bearing_blocks_ptr = layout.GetBlockPtr<
layout.GetBlockPtr<typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT, true>( typename util::RangeTable<16, osrm::storage::MemorySetting::SharedMemory>::BlockT,
memory_ptr, DataLayout::BEARING_BLOCKS); true>(memory_ptr, DataLayout::BEARING_BLOCKS);
BOOST_ASSERT( BOOST_ASSERT(
static_cast<std::size_t>(layout.GetBlockSize(DataLayout::BEARING_BLOCKS)) >= static_cast<std::size_t>(layout.GetBlockSize(DataLayout::BEARING_BLOCKS)) >=
std::distance(bearing_blocks_data.begin(), bearing_blocks_data.end()) * std::distance(bearing_blocks_data.begin(), bearing_blocks_data.end()) *

3
unit_tests/customizer/cell_customization.cpp
View File

@ -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}); edges.push_back(Edge{m.target, m.start, m.weight, false, true});
} }
std::sort(edges.begin(), edges.end()); std::sort(edges.begin(), edges.end());
return partition::MultiLevelGraph<EdgeData, osrm::storage::MemorySetting::InternalMemory>(mlp, max_id + 1, edges); return partition::MultiLevelGraph<EdgeData, osrm::storage::MemorySetting::InternalMemory>(
mlp, max_id + 1, edges);
} }
} }

3
unit_tests/partition/multi_level_graph.cpp
View File

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

12
unit_tests/util/static_rtree.cpp
View File

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

481
unit_tests/util/static_rtree.cpp~RF1bf682.TMP Normal file
View File

@ -0,0 +1,481 @@
#include "util/static_rtree.hpp"
#include "extractor/edge_based_node.hpp"
#include "engine/geospatial_query.hpp"
#include "util/coordinate.hpp"
#include "util/coordinate_calculation.hpp"
#include "util/exception.hpp"
#include "util/rectangle.hpp"
#include "util/typedefs.hpp"
#include "mocks/mock_datafacade.hpp"
#include <boost/functional/hash.hpp>
#include <boost/test/auto_unit_test.hpp>
#include <boost/test/test_case_template.hpp>
#include <boost/test/unit_test.hpp>
#include <cmath>
#include <cstdint>
#include <algorithm>
#include <memory>
#include <random>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
#include <tbb/task_scheduler_init.h>
// explicit TBB scheduler init to register resources cleanup at exit
tbb::task_scheduler_init init(2);
BOOST_AUTO_TEST_SUITE(static_rtree)
using namespace osrm;
using namespace osrm::util;
using namespace osrm::test;
constexpr uint32_t TEST_BRANCHING_FACTOR = 8;
constexpr uint32_t TEST_LEAF_NODE_SIZE = 64;
using TestData = extractor::EdgeBasedNode;
using TestStaticRTree = StaticRTree<TestData,
std::vector<Coordinate>,
osrm::storage::MemorySetting::InternalMemory,
TEST_BRANCHING_FACTOR,
TEST_LEAF_NODE_SIZE>;
using MiniStaticRTree = StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::MemorySetting::InternalMemory, 2, 128>;
// Choosen by a fair W20 dice roll (this value is completely arbitrary)
constexpr unsigned RANDOM_SEED = 42;
static const int32_t WORLD_MIN_LAT = -85 * COORDINATE_PRECISION;
static const int32_t WORLD_MAX_LAT = 85 * COORDINATE_PRECISION;
static const int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION;
static const int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
template <typename DataT> class LinearSearchNN
{
public:
LinearSearchNN(const std::vector<Coordinate> &coords, const std::vector<DataT> &edges)
: coords(coords), edges(edges)
{
}
std::vector<DataT> Nearest(const Coordinate &input_coordinate, const unsigned num_results)
{
std::vector<DataT> local_edges(edges);
auto projected_input = web_mercator::fromWGS84(input_coordinate);
const auto segment_comparator = [this, &projected_input](const DataT &lhs,
const DataT &rhs) {
using web_mercator::fromWGS84;
const auto lhs_result = coordinate_calculation::projectPointOnSegment(
fromWGS84(coords[lhs.u]), fromWGS84(coords[lhs.v]), projected_input);
const auto rhs_result = coordinate_calculation::projectPointOnSegment(
fromWGS84(coords[rhs.u]), fromWGS84(coords[rhs.v]), projected_input);
const auto lhs_squared_dist = coordinate_calculation::squaredEuclideanDistance(
lhs_result.second, projected_input);
const auto rhs_squared_dist = coordinate_calculation::squaredEuclideanDistance(
rhs_result.second, projected_input);
return lhs_squared_dist < rhs_squared_dist;
};
std::nth_element(local_edges.begin(),
local_edges.begin() + num_results,
local_edges.end(),
segment_comparator);
local_edges.resize(num_results);
return local_edges;
}
private:
const std::vector<Coordinate> &coords;
const std::vector<TestData> &edges;
};
template <unsigned NUM_NODES, unsigned NUM_EDGES> struct RandomGraphFixture
{
struct TupleHash
{
typedef std::pair<unsigned, unsigned> argument_type;
typedef std::size_t result_type;
result_type operator()(const argument_type &t) const
{
std::size_t val{0};
boost::hash_combine(val, t.first);
boost::hash_combine(val, t.second);
return val;
}
};
RandomGraphFixture()
{
std::mt19937 g(RANDOM_SEED);
std::uniform_int_distribution<> lat_udist(WORLD_MIN_LAT, WORLD_MAX_LAT);
std::uniform_int_distribution<> lon_udist(WORLD_MIN_LON, WORLD_MAX_LON);
for (unsigned i = 0; i < NUM_NODES; i++)
{
int lon = lon_udist(g);
int lat = lat_udist(g);
coords.emplace_back(Coordinate(FixedLongitude{lon}, FixedLatitude{lat}));
}
std::uniform_int_distribution<> edge_udist(0, coords.size() - 1);
std::unordered_set<std::pair<unsigned, unsigned>, TupleHash> used_edges;
while (edges.size() < NUM_EDGES)
{
TestData data;
data.u = edge_udist(g);
data.v = edge_udist(g);
if (used_edges.find(std::pair<unsigned, unsigned>(
std::min(data.u, data.v), std::max(data.u, data.v))) == used_edges.end())
{
data.component.id = 0;
edges.emplace_back(data);
used_edges.emplace(std::min(data.u, data.v), std::max(data.u, data.v));
}
}
}
std::vector<Coordinate> coords;
std::vector<TestData> edges;
};
struct GraphFixture
{
GraphFixture(const std::vector<std::pair<FloatLongitude, FloatLatitude>> &input_coords,
const std::vector<std::pair<unsigned, unsigned>> &input_edges)
{
for (unsigned i = 0; i < input_coords.size(); i++)
{
coords.emplace_back(input_coords[i].first, input_coords[i].second);
}
for (const auto &pair : input_edges)
{
TestData d;
d.u = pair.first;
d.v = pair.second;
// We set the forward nodes to the target node-based-node IDs, just
// so we have something to test against. Because this isn't a real
// graph, the actual values aren't important, we just need something
// to examine during tests.
d.forward_segment_id = {pair.second, true};
d.reverse_segment_id = {pair.first, true};
d.fwd_segment_position = 0;
d.packed_geometry_id = 0;
edges.emplace_back(d);
}
}
std::vector<Coordinate> coords;
std::vector<TestData> edges;
};
typedef RandomGraphFixture<TEST_LEAF_NODE_SIZE * 3, TEST_LEAF_NODE_SIZE / 2>
TestRandomGraphFixture_LeafHalfFull;
typedef RandomGraphFixture<TEST_LEAF_NODE_SIZE * 5, TEST_LEAF_NODE_SIZE>
TestRandomGraphFixture_LeafFull;
typedef RandomGraphFixture<TEST_LEAF_NODE_SIZE * 10, TEST_LEAF_NODE_SIZE * 2>
TestRandomGraphFixture_TwoLeaves;
typedef RandomGraphFixture<TEST_LEAF_NODE_SIZE * TEST_BRANCHING_FACTOR * 3,
TEST_LEAF_NODE_SIZE * TEST_BRANCHING_FACTOR>
TestRandomGraphFixture_Branch;
typedef RandomGraphFixture<TEST_LEAF_NODE_SIZE * TEST_BRANCHING_FACTOR * 3,
TEST_LEAF_NODE_SIZE * TEST_BRANCHING_FACTOR * 2>
TestRandomGraphFixture_MultipleLevels;
typedef RandomGraphFixture<10, 30> TestRandomGraphFixture_10_30;
template <typename RTreeT>
void simple_verify_rtree(RTreeT &rtree,
const std::vector<Coordinate> &coords,
const std::vector<TestData> &edges)
{
for (const auto &e : edges)
{
const Coordinate &pu = coords[e.u];
const Coordinate &pv = coords[e.v];
auto result_u = rtree.Nearest(pu, 1);
auto result_v = rtree.Nearest(pv, 1);
BOOST_CHECK(result_u.size() == 1 && result_v.size() == 1);
BOOST_CHECK(result_u.front().u == e.u || result_u.front().v == e.u);
BOOST_CHECK(result_v.front().u == e.v || result_v.front().v == e.v);
}
}
template <typename RTreeT>
void sampling_verify_rtree(RTreeT &rtree,
LinearSearchNN<TestData> &lsnn,
const std::vector<Coordinate> &coords,
unsigned num_samples)
{
std::mt19937 g(RANDOM_SEED);
std::uniform_int_distribution<> lat_udist(WORLD_MIN_LAT, WORLD_MAX_LAT);
std::uniform_int_distribution<> lon_udist(WORLD_MIN_LON, WORLD_MAX_LON);
std::vector<Coordinate> queries;
for (unsigned i = 0; i < num_samples; i++)
{
queries.emplace_back(FixedLongitude{lon_udist(g)}, FixedLatitude{lat_udist(g)});
}
for (const auto &q : queries)
{
auto result_rtree = rtree.Nearest(q, 1);
auto result_lsnn = lsnn.Nearest(q, 1);
BOOST_CHECK(result_rtree.size() == 1);
BOOST_CHECK(result_lsnn.size() == 1);
auto rtree_u = result_rtree.back().u;
auto rtree_v = result_rtree.back().v;
auto lsnn_u = result_lsnn.back().u;
auto lsnn_v = result_lsnn.back().v;
const double rtree_dist =
coordinate_calculation::perpendicularDistance(coords[rtree_u], coords[rtree_v], q);
const double lsnn_dist =
coordinate_calculation::perpendicularDistance(coords[lsnn_u], coords[lsnn_v], q);
BOOST_CHECK_CLOSE(rtree_dist, lsnn_dist, 0.0001);
}
}
template <typename FixtureT, typename RTreeT = TestStaticRTree>
void build_rtree(const std::string &prefix,
FixtureT *fixture,
std::string &leaves_path,
std::string &nodes_path)
{
nodes_path = prefix + ".ramIndex";
leaves_path = prefix + ".fileIndex";
RTreeT r(fixture->edges, nodes_path, leaves_path, fixture->coords);
}
template <typename RTreeT = TestStaticRTree, typename FixtureT>
void construction_test(const std::string &prefix, FixtureT *fixture)
{
std::string leaves_path;
std::string nodes_path;
build_rtree<FixtureT, RTreeT>(prefix, fixture, leaves_path, nodes_path);
RTreeT rtree(nodes_path, leaves_path, fixture->coords);
LinearSearchNN<TestData> lsnn(fixture->coords, fixture->edges);
simple_verify_rtree(rtree, fixture->coords, fixture->edges);
sampling_verify_rtree(rtree, lsnn, fixture->coords, 100);
}
BOOST_FIXTURE_TEST_CASE(construct_tiny, TestRandomGraphFixture_10_30)
{
using TinyTestTree = StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::MemorySetting::InternalMemory, 2, 64>;
construction_test<TinyTestTree>("test_tiny", this);
}
BOOST_FIXTURE_TEST_CASE(construct_half_leaf_test, TestRandomGraphFixture_LeafHalfFull)
{
construction_test("test_1", this);
}
BOOST_FIXTURE_TEST_CASE(construct_full_leaf_test, TestRandomGraphFixture_LeafFull)
{
construction_test("test_2", this);
}
BOOST_FIXTURE_TEST_CASE(construct_two_leaves_test, TestRandomGraphFixture_TwoLeaves)
{
construction_test("test_3", this);
}
BOOST_FIXTURE_TEST_CASE(construct_branch_test, TestRandomGraphFixture_Branch)
{
construction_test("test_4", this);
}
BOOST_FIXTURE_TEST_CASE(construct_multiple_levels_test, TestRandomGraphFixture_MultipleLevels)
{
construction_test("test_5", this);
}
// Bug: If you querry a point that lies between two BBs that have a gap,
// one BB will be pruned, even if it could contain a nearer match.
BOOST_AUTO_TEST_CASE(regression_test)
{
using Coord = std::pair<FloatLongitude, FloatLatitude>;
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord{FloatLongitude{0.0}, FloatLatitude{40.0}}, //
Coord{FloatLongitude{5.0}, FloatLatitude{35.0}}, //
Coord{FloatLongitude{5.0}, FloatLatitude{5.0}}, //
Coord{FloatLongitude{10.0}, FloatLatitude{0.0}}, //
Coord{FloatLongitude{10.0}, FloatLatitude{20.0}}, //
Coord{FloatLongitude{5.0}, FloatLatitude{20.0}}, //
Coord{FloatLongitude{100.0}, FloatLatitude{40.0}}, //
Coord{FloatLongitude{105.0}, FloatLatitude{35.0}}, //
Coord{FloatLongitude{105.0}, FloatLatitude{5.0}}, //
Coord{FloatLongitude{110.0}, FloatLatitude{0.0}}, //
},
{Edge(0, 1), Edge(2, 3), Edge(4, 5), Edge(6, 7), Edge(8, 9)});
std::string leaves_path;
std::string nodes_path;
build_rtree<GraphFixture, MiniStaticRTree>(
"test_regression", &fixture, leaves_path, nodes_path);
MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
LinearSearchNN<TestData> lsnn(fixture.coords, fixture.edges);
// query a node just right of the center of the gap
Coordinate input(FloatLongitude{55.1}, FloatLatitude{20.0});
auto result_rtree = rtree.Nearest(input, 1);
auto result_ls = lsnn.Nearest(input, 1);
BOOST_CHECK(result_rtree.size() == 1);
BOOST_CHECK(result_ls.size() == 1);
BOOST_CHECK_EQUAL(result_ls.front().u, result_rtree.front().u);
BOOST_CHECK_EQUAL(result_ls.front().v, result_rtree.front().v);
}
// Bug: If you querry a point with a narrow radius, no result should be returned
BOOST_AUTO_TEST_CASE(radius_regression_test)
{
using Coord = std::pair<FloatLongitude, FloatLatitude>;
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{10.0}, FloatLatitude{10.0}),
},
{Edge(0, 1), Edge(1, 0)});
std::string leaves_path;
std::string nodes_path;
build_rtree<GraphFixture, MiniStaticRTree>("test_angle", &fixture, leaves_path, nodes_path);
MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
MockDataFacade<engine::algorithm::CH> mockfacade;
engine::GeospatialQuery<MiniStaticRTree, MockDataFacade<engine::algorithm::CH>> query(
rtree, fixture.coords, mockfacade);
Coordinate input(FloatLongitude{5.2}, FloatLatitude{5.0});
{
auto results = query.NearestPhantomNodesInRange(input, 0.01);
BOOST_CHECK_EQUAL(results.size(), 0);
}
}
BOOST_AUTO_TEST_CASE(bearing_tests)
{
using Coord = std::pair<FloatLongitude, FloatLatitude>;
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{10.0}, FloatLatitude{10.0}),
},
{Edge(0, 1), Edge(1, 0)});
std::string leaves_path;
std::string nodes_path;
build_rtree<GraphFixture, MiniStaticRTree>("test_bearing", &fixture, leaves_path, nodes_path);
MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
MockDataFacade<engine::algorithm::CH> mockfacade;
engine::GeospatialQuery<MiniStaticRTree, MockDataFacade<engine::algorithm::CH>> query(
rtree, fixture.coords, mockfacade);
Coordinate input(FloatLongitude{5.1}, FloatLatitude{5.0});
{
auto results = query.NearestPhantomNodes(input, 5);
BOOST_CHECK_EQUAL(results.size(), 2);
BOOST_CHECK_EQUAL(results.back().phantom_node.forward_segment_id.id, 0);
BOOST_CHECK_EQUAL(results.back().phantom_node.reverse_segment_id.id, 1);
}
{
auto results = query.NearestPhantomNodes(input, 5, 270, 10);
BOOST_CHECK_EQUAL(results.size(), 0);
}
{
auto results = query.NearestPhantomNodes(input, 5, 45, 10);
BOOST_CHECK_EQUAL(results.size(), 2);
BOOST_CHECK(results[0].phantom_node.forward_segment_id.enabled);
BOOST_CHECK(!results[0].phantom_node.reverse_segment_id.enabled);
BOOST_CHECK_EQUAL(results[0].phantom_node.forward_segment_id.id, 1);
BOOST_CHECK(!results[1].phantom_node.forward_segment_id.enabled);
BOOST_CHECK(results[1].phantom_node.reverse_segment_id.enabled);
BOOST_CHECK_EQUAL(results[1].phantom_node.reverse_segment_id.id, 1);
}
{
auto results = query.NearestPhantomNodesInRange(input, 11000);
BOOST_CHECK_EQUAL(results.size(), 2);
}
{
auto results = query.NearestPhantomNodesInRange(input, 11000, 270, 10);
BOOST_CHECK_EQUAL(results.size(), 0);
}
{
auto results = query.NearestPhantomNodesInRange(input, 11000, 45, 10);
BOOST_CHECK_EQUAL(results.size(), 2);
BOOST_CHECK(results[0].phantom_node.forward_segment_id.enabled);
BOOST_CHECK(!results[0].phantom_node.reverse_segment_id.enabled);
BOOST_CHECK_EQUAL(results[0].phantom_node.forward_segment_id.id, 1);
BOOST_CHECK(!results[1].phantom_node.forward_segment_id.enabled);
BOOST_CHECK(results[1].phantom_node.reverse_segment_id.enabled);
BOOST_CHECK_EQUAL(results[1].phantom_node.reverse_segment_id.id, 1);
}
}
BOOST_AUTO_TEST_CASE(bbox_search_tests)
{
using Coord = std::pair<FloatLongitude, FloatLatitude>;
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{1.0}, FloatLatitude{1.0}),
Coord(FloatLongitude{2.0}, FloatLatitude{2.0}),
Coord(FloatLongitude{3.0}, FloatLatitude{3.0}),
Coord(FloatLongitude{4.0}, FloatLatitude{4.0}),
},
{Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4)});
std::string leaves_path;
std::string nodes_path;
build_rtree<GraphFixture, MiniStaticRTree>("test_bbox", &fixture, leaves_path, nodes_path);
MiniStaticRTree rtree(nodes_path, leaves_path, fixture.coords);
MockDataFacade<engine::algorithm::CH> mockfacade;
engine::GeospatialQuery<MiniStaticRTree, MockDataFacade<engine::algorithm::CH>> query(
rtree, fixture.coords, mockfacade);
{
RectangleInt2D bbox = {
FloatLongitude{0.5}, FloatLongitude{1.5}, FloatLatitude{0.5}, FloatLatitude{1.5}};
auto results = query.Search(bbox);
BOOST_CHECK_EQUAL(results.size(), 2);
}
{
RectangleInt2D bbox = {
FloatLongitude{1.5}, FloatLongitude{3.5}, FloatLatitude{1.5}, FloatLatitude{3.5}};
auto results = query.Search(bbox);
BOOST_CHECK_EQUAL(results.size(), 3);
}
}
BOOST_AUTO_TEST_SUITE_END()