Make use of the view factory in the data facade
This commit is contained in:
Patrick Niklaus
Patrick Niklaus
parent
44924b4bb4
commit
cb4586ebee
@ -9,44 +9,13 @@
|
||||
#include "engine/approach.hpp"
|
||||
#include "engine/geospatial_query.hpp"
|
||||
|
||||
#include "customizer/edge_based_graph.hpp"
|
||||
|
||||
#include "extractor/datasources.hpp"
|
||||
#include "extractor/edge_based_node.hpp"
|
||||
#include "extractor/intersection_bearings_container.hpp"
|
||||
#include "extractor/maneuver_override.hpp"
|
||||
#include "extractor/name_table.hpp"
|
||||
#include "extractor/node_data_container.hpp"
|
||||
#include "extractor/packed_osm_ids.hpp"
|
||||
#include "extractor/profile_properties.hpp"
|
||||
#include "extractor/segment_data_container.hpp"
|
||||
#include "extractor/turn_lane_types.hpp"
|
||||
|
||||
#include "guidance/turn_bearing.hpp"
|
||||
#include "guidance/turn_data_container.hpp"
|
||||
#include "guidance/turn_instruction.hpp"
|
||||
|
||||
#include "contractor/query_graph.hpp"
|
||||
|
||||
#include "partitioner/cell_storage.hpp"
|
||||
#include "partitioner/multi_level_partition.hpp"
|
||||
|
||||
#include "storage/shared_datatype.hpp"
|
||||
#include "storage/shared_memory_ownership.hpp"
|
||||
#include "storage/view_factory.hpp"
|
||||
|
||||
#include "util/exception.hpp"
|
||||
#include "util/exception_utils.hpp"
|
||||
#include "util/filtered_graph.hpp"
|
||||
#include "util/guidance/bearing_class.hpp"
|
||||
#include "util/guidance/entry_class.hpp"
|
||||
#include "util/guidance/turn_lanes.hpp"
|
||||
#include "util/log.hpp"
|
||||
#include "util/packed_vector.hpp"
|
||||
#include "util/range_table.hpp"
|
||||
#include "util/rectangle.hpp"
|
||||
#include "util/static_graph.hpp"
|
||||
#include "util/static_rtree.hpp"
|
||||
#include "util/typedefs.hpp"
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
@ -81,36 +50,6 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
|
||||
// allocator that keeps the allocation data
|
||||
std::shared_ptr<ContiguousBlockAllocator> allocator;
|
||||
|
||||
void InitializeGraphPointer(const storage::DataLayout &data_layout,
|
||||
char *memory_block,
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
const std::string metric_prefix = "/ch/metrics/" + metric_name;
|
||||
auto graph_nodes_ptr = data_layout.GetBlockPtr<GraphNode>(
|
||||
memory_block, metric_prefix + "/contracted_graph/node_array");
|
||||
|
||||
auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
|
||||
memory_block, metric_prefix + "/contracted_graph/edge_array");
|
||||
|
||||
auto exclude_prefix = metric_prefix + "/exclude/" + std::to_string(exclude_index);
|
||||
auto filter_block_id = exclude_prefix + "/edge_filter";
|
||||
|
||||
auto edge_filter_ptr =
|
||||
data_layout.GetBlockPtr<util::vector_view<bool>::Word>(memory_block, filter_block_id);
|
||||
|
||||
util::vector_view<GraphNode> node_list(
|
||||
graph_nodes_ptr,
|
||||
data_layout.GetBlockEntries(metric_prefix + "/contracted_graph/node_array"));
|
||||
util::vector_view<GraphEdge> edge_list(
|
||||
graph_edges_ptr,
|
||||
data_layout.GetBlockEntries(metric_prefix + "/contracted_graph/edge_array"));
|
||||
|
||||
util::vector_view<bool> edge_filter(edge_filter_ptr,
|
||||
data_layout.GetBlockEntries(filter_block_id));
|
||||
m_query_graph = QueryGraph({node_list, edge_list}, edge_filter);
|
||||
}
|
||||
|
||||
public:
|
||||
ContiguousInternalMemoryAlgorithmDataFacade(
|
||||
std::shared_ptr<ContiguousBlockAllocator> allocator_,
|
||||
@ -127,7 +66,8 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
InitializeGraphPointer(data_layout, memory_block, metric_name, exclude_index);
|
||||
m_query_graph = make_filtered_graph_view(
|
||||
memory_block, data_layout, "/ch/metrics/" + metric_name, exclude_index);
|
||||
}
|
||||
|
||||
// search graph access
|
||||
@ -218,7 +158,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
|
||||
util::vector_view<extractor::StorageManeuverOverride> m_maneuver_overrides;
|
||||
util::vector_view<NodeID> m_maneuver_override_node_sequences;
|
||||
|
||||
std::unique_ptr<SharedRTree> m_static_rtree;
|
||||
SharedRTree m_static_rtree;
|
||||
std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
|
||||
boost::filesystem::path file_index_path;
|
||||
|
||||
@ -232,330 +172,55 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
|
||||
// allocator that keeps the allocation data
|
||||
std::shared_ptr<ContiguousBlockAllocator> allocator;
|
||||
|
||||
void InitializeProfilePropertiesPointer(const storage::DataLayout &data_layout,
|
||||
char *memory_block,
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
// TODO: For multi-metric support we need to have separate exclude classes per metric
|
||||
(void)metric_name;
|
||||
m_profile_properties = data_layout.GetBlockPtr<extractor::ProfileProperties>(
|
||||
memory_block, "/common/properties");
|
||||
|
||||
exclude_mask = m_profile_properties->excludable_classes[exclude_index];
|
||||
}
|
||||
|
||||
void InitializeChecksumPointer(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
m_check_sum =
|
||||
*data_layout.GetBlockPtr<std::uint32_t>(memory_block, "/common/connectivity_checksum");
|
||||
util::Log() << "set checksum: " << m_check_sum;
|
||||
}
|
||||
|
||||
void InitializeRTreePointers(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
BOOST_ASSERT_MSG(!m_coordinate_list.empty(), "coordinates must be loaded before r-tree");
|
||||
|
||||
const auto file_index_ptr =
|
||||
data_layout.GetBlockPtr<char>(memory_block, "/common/rtree/file_index_path");
|
||||
file_index_path = boost::filesystem::path(file_index_ptr);
|
||||
if (!boost::filesystem::exists(file_index_path))
|
||||
{
|
||||
util::Log(logDEBUG) << "Leaf file name " << file_index_path.string();
|
||||
throw util::exception("Could not load " + file_index_path.string() +
|
||||
"Is any data loaded into shared memory?" + SOURCE_REF);
|
||||
}
|
||||
|
||||
const auto rtree_ptr =
|
||||
data_layout.GetBlockPtr<RTreeNode>(memory_block, "/common/rtree/search_tree");
|
||||
util::vector_view<RTreeNode> search_tree(
|
||||
rtree_ptr, data_layout.GetBlockEntries("/common/rtree/search_tree"));
|
||||
|
||||
const auto rtree_levelstarts_ptr = data_layout.GetBlockPtr<std::uint64_t>(
|
||||
memory_block, "/common/rtree/search_tree_level_starts");
|
||||
util::vector_view<std::uint64_t> rtree_level_starts(
|
||||
rtree_levelstarts_ptr,
|
||||
data_layout.GetBlockEntries("/common/rtree/search_tree_level_starts"));
|
||||
|
||||
m_static_rtree.reset(new SharedRTree{std::move(search_tree),
|
||||
std::move(rtree_level_starts),
|
||||
file_index_path,
|
||||
m_coordinate_list});
|
||||
m_geospatial_query.reset(
|
||||
new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
|
||||
}
|
||||
|
||||
void InitializeNodeInformationPointers(const storage::DataLayout &layout, char *memory_ptr)
|
||||
{
|
||||
const auto coordinate_list_ptr =
|
||||
layout.GetBlockPtr<util::Coordinate>(memory_ptr, "/common/coordinates");
|
||||
m_coordinate_list.reset(coordinate_list_ptr, layout.GetBlockEntries("/common/coordinates"));
|
||||
|
||||
const auto osmnodeid_ptr = layout.GetBlockPtr<extractor::PackedOSMIDsView::block_type>(
|
||||
memory_ptr, "/common/osm_node_ids/packed");
|
||||
m_osmnodeid_list = extractor::PackedOSMIDsView(
|
||||
util::vector_view<extractor::PackedOSMIDsView::block_type>(
|
||||
osmnodeid_ptr, layout.GetBlockEntries("/common/osm_node_ids/packed")),
|
||||
// We (ab)use the number of coordinates here because we know we have the same amount of
|
||||
// ids
|
||||
layout.GetBlockEntries("/common/coordinates"));
|
||||
}
|
||||
|
||||
void InitializeEdgeBasedNodeDataInformationPointers(const storage::DataLayout &layout,
|
||||
char *memory_ptr)
|
||||
{
|
||||
const auto edge_based_node_list_ptr =
|
||||
layout.GetBlockPtr<extractor::EdgeBasedNode>(memory_ptr, "/common/ebg_node_data/nodes");
|
||||
util::vector_view<extractor::EdgeBasedNode> edge_based_node_data_list(
|
||||
edge_based_node_list_ptr, layout.GetBlockEntries("/common/ebg_node_data/nodes"));
|
||||
|
||||
const auto annotation_data_list_ptr =
|
||||
layout.GetBlockPtr<extractor::NodeBasedEdgeAnnotation>(
|
||||
memory_ptr, "/common/ebg_node_data/annotations");
|
||||
util::vector_view<extractor::NodeBasedEdgeAnnotation> annotation_data(
|
||||
annotation_data_list_ptr, layout.GetBlockEntries("/common/ebg_node_data/annotations"));
|
||||
|
||||
edge_based_node_data = extractor::EdgeBasedNodeDataView(
|
||||
std::move(edge_based_node_data_list), std::move(annotation_data));
|
||||
}
|
||||
|
||||
void InitializeEdgeInformationPointers(const storage::DataLayout &layout, char *memory_ptr)
|
||||
{
|
||||
const auto lane_data_id_ptr =
|
||||
layout.GetBlockPtr<LaneDataID>(memory_ptr, "/common/turn_data/lane_data_ids");
|
||||
util::vector_view<LaneDataID> lane_data_ids(
|
||||
lane_data_id_ptr, layout.GetBlockEntries("/common/turn_data/lane_data_ids"));
|
||||
|
||||
const auto turn_instruction_list_ptr = layout.GetBlockPtr<guidance::TurnInstruction>(
|
||||
memory_ptr, "/common/turn_data/turn_instructions");
|
||||
util::vector_view<guidance::TurnInstruction> turn_instructions(
|
||||
turn_instruction_list_ptr,
|
||||
layout.GetBlockEntries("/common/turn_data/turn_instructions"));
|
||||
|
||||
const auto entry_class_id_list_ptr =
|
||||
layout.GetBlockPtr<EntryClassID>(memory_ptr, "/common/turn_data/entry_class_ids");
|
||||
util::vector_view<EntryClassID> entry_class_ids(
|
||||
entry_class_id_list_ptr, layout.GetBlockEntries("/common/turn_data/entry_class_ids"));
|
||||
|
||||
const auto pre_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
|
||||
memory_ptr, "/common/turn_data/pre_turn_bearings");
|
||||
util::vector_view<guidance::TurnBearing> pre_turn_bearings(
|
||||
pre_turn_bearing_ptr, layout.GetBlockEntries("/common/turn_data/pre_turn_bearings"));
|
||||
|
||||
const auto post_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
|
||||
memory_ptr, "/common/turn_data/post_turn_bearings");
|
||||
util::vector_view<guidance::TurnBearing> post_turn_bearings(
|
||||
post_turn_bearing_ptr, layout.GetBlockEntries("/common/turn_data/post_turn_bearings"));
|
||||
|
||||
turn_data = guidance::TurnDataView(std::move(turn_instructions),
|
||||
std::move(lane_data_ids),
|
||||
std::move(entry_class_ids),
|
||||
std::move(pre_turn_bearings),
|
||||
std::move(post_turn_bearings));
|
||||
}
|
||||
|
||||
void InitializeNamePointers(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
const auto name_blocks_ptr =
|
||||
data_layout.GetBlockPtr<extractor::NameTableView::IndexedData::BlockReference>(
|
||||
memory_block, "/common/names/blocks");
|
||||
const auto name_values_ptr =
|
||||
data_layout.GetBlockPtr<extractor::NameTableView::IndexedData::ValueType>(
|
||||
memory_block, "/common/names/values");
|
||||
|
||||
util::vector_view<extractor::NameTableView::IndexedData::BlockReference> blocks(
|
||||
name_blocks_ptr, data_layout.GetBlockEntries("/common/names/blocks"));
|
||||
util::vector_view<extractor::NameTableView::IndexedData::ValueType> values(
|
||||
name_values_ptr, data_layout.GetBlockEntries("/common/names/values"));
|
||||
|
||||
extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)};
|
||||
m_name_table = extractor::NameTableView{std::move(index_data_view)};
|
||||
}
|
||||
|
||||
void InitializeTurnLaneDescriptionsPointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block)
|
||||
{
|
||||
auto offsets_ptr =
|
||||
data_layout.GetBlockPtr<std::uint32_t>(memory_block, "/common/turn_lanes/offsets");
|
||||
util::vector_view<std::uint32_t> offsets(
|
||||
offsets_ptr, data_layout.GetBlockEntries("/common/turn_lanes/offsets"));
|
||||
m_lane_description_offsets = std::move(offsets);
|
||||
|
||||
auto masks_ptr = data_layout.GetBlockPtr<extractor::TurnLaneType::Mask>(
|
||||
memory_block, "/common/turn_lanes/masks");
|
||||
|
||||
util::vector_view<extractor::TurnLaneType::Mask> masks(
|
||||
masks_ptr, data_layout.GetBlockEntries("/common/turn_lanes/masks"));
|
||||
m_lane_description_masks = std::move(masks);
|
||||
|
||||
const auto lane_tupel_id_pair_ptr =
|
||||
data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(memory_block,
|
||||
"/common/turn_lanes/data");
|
||||
util::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
|
||||
lane_tupel_id_pair_ptr, data_layout.GetBlockEntries("/common/turn_lanes/data"));
|
||||
m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
|
||||
}
|
||||
|
||||
void InitializeTurnPenalties(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
auto turn_weight_penalties_ptr =
|
||||
data_layout.GetBlockPtr<TurnPenalty>(memory_block, "/common/turn_penalty/weight");
|
||||
m_turn_weight_penalties = util::vector_view<TurnPenalty>(
|
||||
turn_weight_penalties_ptr, data_layout.GetBlockEntries("/common/turn_penalty/weight"));
|
||||
auto turn_duration_penalties_ptr =
|
||||
data_layout.GetBlockPtr<TurnPenalty>(memory_block, "/common/turn_penalty/duration");
|
||||
m_turn_duration_penalties = util::vector_view<TurnPenalty>(
|
||||
turn_duration_penalties_ptr,
|
||||
data_layout.GetBlockEntries("/common/turn_penalty/duration"));
|
||||
}
|
||||
|
||||
void InitializeGeometryPointers(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
auto geometries_index_ptr =
|
||||
data_layout.GetBlockPtr<unsigned>(memory_block, "/common/segment_data/index");
|
||||
util::vector_view<unsigned> geometry_begin_indices(
|
||||
geometries_index_ptr, data_layout.GetBlockEntries("/common/segment_data/index"));
|
||||
|
||||
auto num_entries = data_layout.GetBlockEntries("/common/segment_data/nodes");
|
||||
auto geometries_node_list_ptr =
|
||||
data_layout.GetBlockPtr<NodeID>(memory_block, "/common/segment_data/nodes");
|
||||
util::vector_view<NodeID> geometry_node_list(geometries_node_list_ptr, num_entries);
|
||||
|
||||
auto geometries_fwd_weight_list_ptr =
|
||||
data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
|
||||
memory_block, "/common/segment_data/forward_weights/packed");
|
||||
extractor::SegmentDataView::SegmentWeightVector geometry_fwd_weight_list(
|
||||
util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
|
||||
geometries_fwd_weight_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/forward_weights/packed")),
|
||||
num_entries);
|
||||
|
||||
auto geometries_rev_weight_list_ptr =
|
||||
data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
|
||||
memory_block, "/common/segment_data/reverse_weights/packed");
|
||||
extractor::SegmentDataView::SegmentWeightVector geometry_rev_weight_list(
|
||||
util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
|
||||
geometries_rev_weight_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/reverse_weights/packed")),
|
||||
num_entries);
|
||||
|
||||
auto geometries_fwd_duration_list_ptr =
|
||||
data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
|
||||
memory_block, "/common/segment_data/forward_durations/packed");
|
||||
extractor::SegmentDataView::SegmentDurationVector geometry_fwd_duration_list(
|
||||
util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
|
||||
geometries_fwd_duration_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/forward_durations/packed")),
|
||||
num_entries);
|
||||
|
||||
auto geometries_rev_duration_list_ptr =
|
||||
data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
|
||||
memory_block, "/common/segment_data/reverse_durations/packed");
|
||||
extractor::SegmentDataView::SegmentDurationVector geometry_rev_duration_list(
|
||||
util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
|
||||
geometries_rev_duration_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/reverse_durations/packed")),
|
||||
num_entries);
|
||||
|
||||
auto geometries_fwd_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
|
||||
memory_block, "/common/segment_data/forward_data_sources");
|
||||
util::vector_view<DatasourceID> geometry_fwd_datasources_list(
|
||||
geometries_fwd_datasources_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/forward_data_sources"));
|
||||
|
||||
auto geometries_rev_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
|
||||
memory_block, "/common/segment_data/reverse_data_sources");
|
||||
util::vector_view<DatasourceID> geometry_rev_datasources_list(
|
||||
geometries_rev_datasources_list_ptr,
|
||||
data_layout.GetBlockEntries("/common/segment_data/reverse_data_sources"));
|
||||
|
||||
segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
|
||||
std::move(geometry_node_list),
|
||||
std::move(geometry_fwd_weight_list),
|
||||
std::move(geometry_rev_weight_list),
|
||||
std::move(geometry_fwd_duration_list),
|
||||
std::move(geometry_rev_duration_list),
|
||||
std::move(geometry_fwd_datasources_list),
|
||||
std::move(geometry_rev_datasources_list)};
|
||||
|
||||
m_datasources = data_layout.GetBlockPtr<extractor::Datasources>(
|
||||
memory_block, "/common/data_sources_names");
|
||||
}
|
||||
|
||||
void InitializeIntersectionClassPointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block)
|
||||
{
|
||||
auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
|
||||
memory_block, "/common/intersection_bearings/node_to_class_id");
|
||||
util::vector_view<BearingClassID> bearing_class_id(
|
||||
bearing_class_id_ptr,
|
||||
data_layout.GetBlockEntries("/common/intersection_bearings/node_to_class_id"));
|
||||
|
||||
auto bearing_values_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
|
||||
memory_block, "/common/intersection_bearings/bearing_values");
|
||||
util::vector_view<DiscreteBearing> bearing_values(
|
||||
bearing_values_ptr,
|
||||
data_layout.GetBlockEntries("/common/intersection_bearings/bearing_values"));
|
||||
|
||||
auto offsets_ptr = data_layout.GetBlockPtr<unsigned>(
|
||||
memory_block, "/common/intersection_bearings/class_id_to_ranges/block_offsets");
|
||||
auto blocks_ptr = data_layout.GetBlockPtr<IndexBlock>(
|
||||
memory_block, "/common/intersection_bearings/class_id_to_ranges/diff_blocks");
|
||||
util::vector_view<unsigned> bearing_offsets(
|
||||
offsets_ptr,
|
||||
data_layout.GetBlockEntries(
|
||||
"/common/intersection_bearings/class_id_to_ranges/block_offsets"));
|
||||
util::vector_view<IndexBlock> bearing_blocks(
|
||||
blocks_ptr,
|
||||
data_layout.GetBlockEntries(
|
||||
"/common/intersection_bearings/class_id_to_ranges/diff_blocks"));
|
||||
|
||||
util::RangeTable<16, storage::Ownership::View> bearing_range_table(
|
||||
bearing_offsets, bearing_blocks, static_cast<unsigned>(bearing_values.size()));
|
||||
|
||||
intersection_bearings_view = extractor::IntersectionBearingsView{
|
||||
std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
|
||||
|
||||
auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
|
||||
memory_block, "/common/entry_classes");
|
||||
util::vector_view<util::guidance::EntryClass> entry_class_table(
|
||||
entry_class_ptr, data_layout.GetBlockEntries("/common/entry_classes"));
|
||||
m_entry_class_table = std::move(entry_class_table);
|
||||
}
|
||||
|
||||
void InitializeManeuverOverridePointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block)
|
||||
{
|
||||
auto maneuver_overrides_ptr = data_layout.GetBlockPtr<extractor::StorageManeuverOverride>(
|
||||
memory_block, "/common/maneuver_overrides/overrides");
|
||||
m_maneuver_overrides = util::vector_view<extractor::StorageManeuverOverride>(
|
||||
maneuver_overrides_ptr,
|
||||
data_layout.GetBlockEntries("/common/maneuver_overrides/overrides"));
|
||||
|
||||
auto maneuver_override_node_sequences_ptr = data_layout.GetBlockPtr<NodeID>(
|
||||
memory_block, "/common/maneuver_overrides/node_sequences");
|
||||
m_maneuver_override_node_sequences = util::vector_view<NodeID>(
|
||||
maneuver_override_node_sequences_ptr,
|
||||
data_layout.GetBlockEntries("/common/maneuver_overrides/node_sequences"));
|
||||
}
|
||||
|
||||
void InitializeInternalPointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block,
|
||||
void InitializeInternalPointers(const storage::DataLayout &layout,
|
||||
char *memory_ptr,
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
InitializeChecksumPointer(data_layout, memory_block);
|
||||
InitializeNodeInformationPointers(data_layout, memory_block);
|
||||
InitializeEdgeBasedNodeDataInformationPointers(data_layout, memory_block);
|
||||
InitializeEdgeInformationPointers(data_layout, memory_block);
|
||||
InitializeTurnPenalties(data_layout, memory_block);
|
||||
InitializeGeometryPointers(data_layout, memory_block);
|
||||
InitializeNamePointers(data_layout, memory_block);
|
||||
InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
|
||||
InitializeProfilePropertiesPointer(data_layout, memory_block, metric_name, exclude_index);
|
||||
InitializeRTreePointers(data_layout, memory_block);
|
||||
InitializeIntersectionClassPointers(data_layout, memory_block);
|
||||
InitializeManeuverOverridePointers(data_layout, memory_block);
|
||||
// TODO: For multi-metric support we need to have separate exclude classes per metric
|
||||
(void)metric_name;
|
||||
|
||||
m_profile_properties =
|
||||
layout.GetBlockPtr<extractor::ProfileProperties>(memory_ptr, "/common/properties");
|
||||
|
||||
exclude_mask = m_profile_properties->excludable_classes[exclude_index];
|
||||
|
||||
m_check_sum =
|
||||
*layout.GetBlockPtr<std::uint32_t>(memory_ptr, "/common/connectivity_checksum");
|
||||
|
||||
std::tie(m_coordinate_list, m_osmnodeid_list) =
|
||||
make_nbn_data_view(memory_ptr, layout, "/common/nbn_data");
|
||||
|
||||
m_static_rtree = make_search_tree_view(memory_ptr, layout, "/common/rtree");
|
||||
m_geospatial_query.reset(
|
||||
new SharedGeospatialQuery(m_static_rtree, m_coordinate_list, *this));
|
||||
|
||||
edge_based_node_data = make_ebn_data_view(memory_ptr, layout, "/common/ebg_node_data");
|
||||
|
||||
turn_data = make_turn_data_view(memory_ptr, layout, "/common/turn_data");
|
||||
|
||||
m_name_table = make_name_table_view(memory_ptr, layout, "/common/names");
|
||||
|
||||
std::tie(m_lane_description_offsets, m_lane_description_masks) =
|
||||
make_turn_lane_description_views(memory_ptr, layout, "/common/turn_lanes");
|
||||
m_lane_tupel_id_pairs = make_lane_data_view(memory_ptr, layout, "/common/turn_lanes");
|
||||
|
||||
m_turn_weight_penalties = make_turn_weight_view(memory_ptr, layout, "/common/turn_penalty");
|
||||
m_turn_duration_penalties =
|
||||
make_turn_duration_view(memory_ptr, layout, "/common/turn_penalty");
|
||||
|
||||
segment_data = make_segment_data_view(memory_ptr, layout, "/common/segment_data");
|
||||
|
||||
m_datasources =
|
||||
layout.GetBlockPtr<extractor::Datasources>(memory_ptr, "/common/data_sources_names");
|
||||
|
||||
intersection_bearings_view =
|
||||
make_intersection_bearings_view(memory_ptr, layout, "/common/intersection_bearings");
|
||||
|
||||
m_entry_class_table = make_entry_classes_view(memory_ptr, layout, "/common/entry_classes");
|
||||
|
||||
std::tie(m_maneuver_overrides, m_maneuver_override_node_sequences) =
|
||||
make_maneuver_overrides_views(memory_ptr, layout, "/common/maneuver_overrides");
|
||||
}
|
||||
|
||||
public:
|
||||
@ -996,122 +661,16 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
|
||||
|
||||
QueryGraph query_graph;
|
||||
|
||||
void InitializeInternalPointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block,
|
||||
void InitializeInternalPointers(const storage::DataLayout &layout,
|
||||
char *memory_ptr,
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
InitializeMLDDataPointers(data_layout, memory_block, metric_name, exclude_index);
|
||||
InitializeGraphPointer(data_layout, memory_block);
|
||||
}
|
||||
|
||||
void InitializeMLDDataPointers(const storage::DataLayout &data_layout,
|
||||
char *memory_block,
|
||||
const std::string &metric_name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
if (data_layout.GetBlockSize("/mld/multilevelpartition/partition") > 0)
|
||||
{
|
||||
BOOST_ASSERT(data_layout.GetBlockSize("/mld/multilevelpartition/level_data") > 0);
|
||||
BOOST_ASSERT(data_layout.GetBlockSize("/mld/multilevelpartition/cell_to_children") > 0);
|
||||
|
||||
auto level_data =
|
||||
data_layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
|
||||
memory_block, "/mld/multilevelpartition/level_data");
|
||||
|
||||
auto mld_partition_ptr = data_layout.GetBlockPtr<PartitionID>(
|
||||
memory_block, "/mld/multilevelpartition/partition");
|
||||
auto partition_entries_count =
|
||||
data_layout.GetBlockEntries("/mld/multilevelpartition/partition");
|
||||
util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
|
||||
|
||||
auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
|
||||
memory_block, "/mld/multilevelpartition/cell_to_children");
|
||||
auto children_entries_count =
|
||||
data_layout.GetBlockEntries("/mld/multilevelpartition/cell_to_children");
|
||||
util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
|
||||
|
||||
mld_partition =
|
||||
partitioner::MultiLevelPartitionView{level_data, partition, cell_to_children};
|
||||
}
|
||||
|
||||
const auto exclude_prefix =
|
||||
"/mld/metrics/" + metric_name + "/exclude/" + std::to_string(exclude_index);
|
||||
const auto weights_block_id = exclude_prefix + "/weights";
|
||||
const auto durations_block_id = exclude_prefix + "/durations";
|
||||
|
||||
if (data_layout.GetBlockSize(weights_block_id) > 0)
|
||||
{
|
||||
auto mld_cell_weights_ptr =
|
||||
data_layout.GetBlockPtr<EdgeWeight>(memory_block, weights_block_id);
|
||||
auto mld_cell_durations_ptr =
|
||||
data_layout.GetBlockPtr<EdgeDuration>(memory_block, durations_block_id);
|
||||
auto weight_entries_count = data_layout.GetBlockEntries(weights_block_id);
|
||||
auto duration_entries_count = data_layout.GetBlockEntries(durations_block_id);
|
||||
BOOST_ASSERT(weight_entries_count == duration_entries_count);
|
||||
util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
|
||||
util::vector_view<EdgeDuration> durations(mld_cell_durations_ptr,
|
||||
duration_entries_count);
|
||||
|
||||
mld_cell_metric = customizer::CellMetricView{std::move(weights), std::move(durations)};
|
||||
}
|
||||
|
||||
if (data_layout.GetBlockSize("/mld/cellstorage/cells") > 0)
|
||||
{
|
||||
|
||||
auto mld_source_boundary_ptr =
|
||||
data_layout.GetBlockPtr<NodeID>(memory_block, "/mld/cellstorage/source_boundary");
|
||||
auto mld_destination_boundary_ptr = data_layout.GetBlockPtr<NodeID>(
|
||||
memory_block, "/mld/cellstorage/destination_boundary");
|
||||
auto mld_cells_ptr = data_layout.GetBlockPtr<partitioner::CellStorageView::CellData>(
|
||||
memory_block, "/mld/cellstorage/cells");
|
||||
auto mld_cell_level_offsets_ptr = data_layout.GetBlockPtr<std::uint64_t>(
|
||||
memory_block, "/mld/cellstorage/level_to_cell_offset");
|
||||
|
||||
auto source_boundary_entries_count =
|
||||
data_layout.GetBlockEntries("/mld/cellstorage/source_boundary");
|
||||
auto destination_boundary_entries_count =
|
||||
data_layout.GetBlockEntries("/mld/cellstorage/destination_boundary");
|
||||
auto cells_entries_counts = data_layout.GetBlockEntries("/mld/cellstorage/cells");
|
||||
auto cell_level_offsets_entries_count =
|
||||
data_layout.GetBlockEntries("/mld/cellstorage/level_to_cell_offset");
|
||||
|
||||
util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
|
||||
source_boundary_entries_count);
|
||||
util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
|
||||
destination_boundary_entries_count);
|
||||
util::vector_view<partitioner::CellStorageView::CellData> cells(mld_cells_ptr,
|
||||
cells_entries_counts);
|
||||
util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
|
||||
cell_level_offsets_entries_count);
|
||||
|
||||
mld_cell_storage = partitioner::CellStorageView{std::move(source_boundary),
|
||||
std::move(destination_boundary),
|
||||
std::move(cells),
|
||||
std::move(level_offsets)};
|
||||
}
|
||||
}
|
||||
void InitializeGraphPointer(const storage::DataLayout &data_layout, char *memory_block)
|
||||
{
|
||||
auto graph_nodes_ptr =
|
||||
data_layout.GetBlockPtr<GraphNode>(memory_block, "/mld/multilevelgraph/node_array");
|
||||
|
||||
auto graph_edges_ptr =
|
||||
data_layout.GetBlockPtr<GraphEdge>(memory_block, "/mld/multilevelgraph/edge_array");
|
||||
|
||||
auto graph_node_to_offset_ptr = data_layout.GetBlockPtr<QueryGraph::EdgeOffset>(
|
||||
memory_block, "/mld/multilevelgraph/node_to_edge_offset");
|
||||
|
||||
util::vector_view<GraphNode> node_list(
|
||||
graph_nodes_ptr, data_layout.GetBlockEntries("/mld/multilevelgraph/node_array"));
|
||||
util::vector_view<GraphEdge> edge_list(
|
||||
graph_edges_ptr, data_layout.GetBlockEntries("/mld/multilevelgraph/edge_array"));
|
||||
util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
|
||||
graph_node_to_offset_ptr,
|
||||
data_layout.GetBlockEntries("/mld/multilevelgraph/node_to_edge_offset"));
|
||||
|
||||
query_graph =
|
||||
QueryGraph(std::move(node_list), std::move(edge_list), std::move(node_to_offset));
|
||||
mld_partition = make_partition_view(memory_ptr, layout, "/mld/multilevelpartition");
|
||||
mld_cell_metric = make_filtered_cell_metric_view(
|
||||
memory_ptr, layout, "/mld/metrics/" + metric_name, exclude_index);
|
||||
mld_cell_storage = make_cell_storage_view(memory_ptr, layout, "/mld/cellstorage");
|
||||
query_graph = make_multi_level_graph_view(memory_ptr, layout, "/mld/multilevelgraph");
|
||||
}
|
||||
|
||||
// allocator that keeps the allocation data
|
||||
|
||||
@ -122,8 +122,8 @@ inline void readNodes(const boost::filesystem::path &path,
|
||||
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
|
||||
storage::tar::FileReader reader{path, fingerprint};
|
||||
|
||||
storage::serialization::read(reader, "/common/coordinates", coordinates);
|
||||
util::serialization::read(reader, "/common/osm_node_ids", osm_node_ids);
|
||||
storage::serialization::read(reader, "/common/nbn_data/coordinates", coordinates);
|
||||
util::serialization::read(reader, "/common/nbn_data/osm_node_ids", osm_node_ids);
|
||||
}
|
||||
|
||||
// reads only coordinates from .osrm.nbg_nodes
|
||||
@ -135,7 +135,7 @@ inline void readNodeCoordinates(const boost::filesystem::path &path, Coordinates
|
||||
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
|
||||
storage::tar::FileReader reader{path, fingerprint};
|
||||
|
||||
storage::serialization::read(reader, "/common/coordinates", coordinates);
|
||||
storage::serialization::read(reader, "/common/nbn_data/coordinates", coordinates);
|
||||
}
|
||||
|
||||
// writes .osrm.nbg_nodes
|
||||
@ -150,8 +150,8 @@ inline void writeNodes(const boost::filesystem::path &path,
|
||||
const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
|
||||
storage::tar::FileWriter writer{path, fingerprint};
|
||||
|
||||
storage::serialization::write(writer, "/common/coordinates", coordinates);
|
||||
util::serialization::write(writer, "/common/osm_node_ids", osm_node_ids);
|
||||
storage::serialization::write(writer, "/common/nbn_data/coordinates", coordinates);
|
||||
util::serialization::write(writer, "/common/nbn_data/osm_node_ids", osm_node_ids);
|
||||
}
|
||||
|
||||
// reads .osrm.cnbg_to_ebg
|
||||
|
||||
@ -35,6 +35,7 @@
|
||||
#include "util/typedefs.hpp"
|
||||
#include "util/vector_view.hpp"
|
||||
|
||||
#include "util/filtered_graph.hpp"
|
||||
#include "util/packed_vector.hpp"
|
||||
#include "util/vector_view.hpp"
|
||||
|
||||
@ -72,7 +73,8 @@ make_packed_vector_view(char *memory_ptr, const DataLayout &layout, const std::s
|
||||
return V{packed_internal, std::numeric_limits<std::size_t>::max()};
|
||||
}
|
||||
|
||||
auto make_name_table_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_name_table_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto blocks = make_vector_view<extractor::NameTableView::IndexedData::BlockReference>(
|
||||
memory_ptr, layout, name + "/blocks");
|
||||
@ -83,14 +85,14 @@ auto make_name_table_view(char *memory_ptr, const DataLayout &layout, const std:
|
||||
return extractor::NameTableView{index_data_view};
|
||||
}
|
||||
|
||||
auto make_lane_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_lane_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_vector_view<util::guidance::LaneTupleIdPair>(memory_ptr, layout, name + "/data");
|
||||
}
|
||||
|
||||
auto make_turn_lane_description_views(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
inline auto make_turn_lane_description_views(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
{
|
||||
auto offsets = make_vector_view<std::uint32_t>(memory_ptr, layout, name + "/offsets");
|
||||
auto masks =
|
||||
@ -99,7 +101,7 @@ auto make_turn_lane_description_views(char *memory_ptr,
|
||||
return std::make_tuple(offsets, masks);
|
||||
}
|
||||
|
||||
auto make_ebn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_ebn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto edge_based_node_data =
|
||||
make_vector_view<extractor::EdgeBasedNode>(memory_ptr, layout, name + "/nodes");
|
||||
@ -110,7 +112,7 @@ auto make_ebn_data_view(char *memory_ptr, const DataLayout &layout, const std::s
|
||||
std::move(annotation_data));
|
||||
}
|
||||
|
||||
auto make_turn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_turn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto lane_data_ids = make_vector_view<LaneDataID>(memory_ptr, layout, name + "/lane_data_ids");
|
||||
|
||||
@ -133,7 +135,8 @@ auto make_turn_data_view(char *memory_ptr, const DataLayout &layout, const std::
|
||||
std::move(post_turn_bearings));
|
||||
}
|
||||
|
||||
auto make_segment_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_segment_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto geometry_begin_indices = make_vector_view<unsigned>(memory_ptr, layout, name + "/index");
|
||||
|
||||
@ -177,29 +180,39 @@ auto make_segment_data_view(char *memory_ptr, const DataLayout &layout, const st
|
||||
std::move(rev_datasources_list)};
|
||||
}
|
||||
|
||||
auto make_coordinates_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_coordinates_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_vector_view<util::Coordinate>(memory_ptr, layout, name);
|
||||
}
|
||||
|
||||
auto make_osm_ids_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_osm_ids_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_packed_vector_view<extractor::PackedOSMIDsView::value_type,
|
||||
extractor::PackedOSMIDsView::value_size>(
|
||||
memory_ptr, layout, name);
|
||||
}
|
||||
|
||||
auto make_turn_duration_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_nbn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return std::make_tuple(make_coordinates_view(memory_ptr, layout, name + "/coordinates"),
|
||||
make_osm_ids_view(memory_ptr, layout, name + "/osm_node_ids"));
|
||||
}
|
||||
|
||||
inline auto
|
||||
make_turn_weight_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_vector_view<TurnPenalty>(memory_ptr, layout, name + "/weight");
|
||||
}
|
||||
|
||||
auto make_turn_penalties_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_turn_duration_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_vector_view<TurnPenalty>(memory_ptr, layout, name + "/duration");
|
||||
}
|
||||
|
||||
auto make_search_tree_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_search_tree_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
using RTreeLeaf = extractor::EdgeBasedNodeSegment;
|
||||
using RTreeNode = util::StaticRTree<RTreeLeaf, storage::Ownership::View>::TreeNode;
|
||||
@ -209,17 +222,23 @@ auto make_search_tree_view(char *memory_ptr, const DataLayout &layout, const std
|
||||
const auto rtree_level_starts =
|
||||
make_vector_view<std::uint64_t>(memory_ptr, layout, name + "/search_tree_level_starts");
|
||||
|
||||
const auto coordinates = make_coordinates_view(memory_ptr, layout, "/common/coordinates");
|
||||
const auto coordinates =
|
||||
make_coordinates_view(memory_ptr, layout, "/common/nbn_data/coordinates");
|
||||
|
||||
const char *path = layout.GetBlockPtr<char>(memory_ptr, name + "/file_index_path");
|
||||
|
||||
if (!boost::filesystem::exists(boost::filesystem::path{path}))
|
||||
{
|
||||
throw util::exception("Could not load " + std::string(path) + "Does the leaf file exist?" +
|
||||
SOURCE_REF);
|
||||
}
|
||||
|
||||
return util::StaticRTree<RTreeLeaf, storage::Ownership::View>{
|
||||
std::move(search_tree), std::move(rtree_level_starts), path, std::move(coordinates)};
|
||||
}
|
||||
|
||||
auto make_intersection_bearings_view(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
inline auto
|
||||
make_intersection_bearings_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto bearing_offsets =
|
||||
make_vector_view<unsigned>(memory_ptr, layout, name + "/class_id_to_ranges/block_offsets");
|
||||
@ -238,14 +257,14 @@ auto make_intersection_bearings_view(char *memory_ptr,
|
||||
std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
|
||||
}
|
||||
|
||||
auto make_entry_classes_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_entry_classes_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
return make_vector_view<util::guidance::EntryClass>(memory_ptr, layout, name);
|
||||
}
|
||||
|
||||
auto make_contracted_metric_view(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
inline auto
|
||||
make_contracted_metric_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto node_list = make_vector_view<contractor::QueryGraphView::NodeArrayEntry>(
|
||||
memory_ptr, layout, name + "/contracted_graph/node_array");
|
||||
@ -262,7 +281,7 @@ auto make_contracted_metric_view(char *memory_ptr,
|
||||
std::move(edge_filter)};
|
||||
}
|
||||
|
||||
auto make_partition_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_partition_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto level_data_ptr = layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
|
||||
memory_ptr, name + "/level_data");
|
||||
@ -274,7 +293,8 @@ auto make_partition_view(char *memory_ptr, const DataLayout &layout, const std::
|
||||
level_data_ptr, std::move(partition), std::move(cell_to_children)};
|
||||
}
|
||||
|
||||
auto make_cell_storage_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto
|
||||
make_cell_storage_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto source_boundary = make_vector_view<NodeID>(memory_ptr, layout, name + "/source_boundary");
|
||||
auto destination_boundary =
|
||||
@ -290,7 +310,25 @@ auto make_cell_storage_view(char *memory_ptr, const DataLayout &layout, const st
|
||||
std::move(level_offsets)};
|
||||
}
|
||||
|
||||
auto make_cell_metric_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
inline auto make_filtered_cell_metric_view(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
customizer::CellMetricView cell_metric;
|
||||
|
||||
auto prefix = name + "/exclude/" + std::to_string(exclude_index);
|
||||
auto weights_block_id = prefix + "/weights";
|
||||
auto durations_block_id = prefix + "/durations";
|
||||
|
||||
auto weights = make_vector_view<EdgeWeight>(memory_ptr, layout, weights_block_id);
|
||||
auto durations = make_vector_view<EdgeDuration>(memory_ptr, layout, durations_block_id);
|
||||
|
||||
return customizer::CellMetricView{std::move(weights), std::move(durations)};
|
||||
}
|
||||
|
||||
inline auto
|
||||
make_cell_metric_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
std::vector<customizer::CellMetricView> cell_metric_excludes;
|
||||
|
||||
@ -311,9 +349,8 @@ auto make_cell_metric_view(char *memory_ptr, const DataLayout &layout, const std
|
||||
return cell_metric_excludes;
|
||||
}
|
||||
|
||||
auto make_multi_level_graph_view(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
inline auto
|
||||
make_multi_level_graph_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto node_list = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry>(
|
||||
memory_ptr, layout, name + "/node_array");
|
||||
@ -326,9 +363,8 @@ auto make_multi_level_graph_view(char *memory_ptr,
|
||||
std::move(node_list), std::move(edge_list), std::move(node_to_offset));
|
||||
}
|
||||
|
||||
auto make_maneuver_overrides_views(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name)
|
||||
inline auto
|
||||
make_maneuver_overrides_views(char *memory_ptr, const DataLayout &layout, const std::string &name)
|
||||
{
|
||||
auto maneuver_overrides = make_vector_view<extractor::StorageManeuverOverride>(
|
||||
memory_ptr, layout, name + "/overrides");
|
||||
@ -337,6 +373,21 @@ auto make_maneuver_overrides_views(char *memory_ptr,
|
||||
|
||||
return std::make_tuple(maneuver_overrides, maneuver_override_node_sequences);
|
||||
}
|
||||
|
||||
inline auto make_filtered_graph_view(char *memory_ptr,
|
||||
const DataLayout &layout,
|
||||
const std::string &name,
|
||||
const std::size_t exclude_index)
|
||||
{
|
||||
auto exclude_prefix = name + "/exclude/" + std::to_string(exclude_index);
|
||||
auto edge_filter = make_vector_view<bool>(memory_ptr, layout, exclude_prefix + "/edge_filter");
|
||||
auto node_list = make_vector_view<contractor::QueryGraphView::NodeArrayEntry>(
|
||||
memory_ptr, layout, name + "/contracted_graph/node_array");
|
||||
auto edge_list = make_vector_view<contractor::QueryGraphView::EdgeArrayEntry>(
|
||||
memory_ptr, layout, name + "/contracted_graph/edge_array");
|
||||
|
||||
return util::FilteredGraphView<contractor::QueryGraphView>({node_list, edge_list}, edge_filter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -255,7 +255,7 @@ class StaticRTree
|
||||
// Representation of the in-memory search tree
|
||||
Vector<TreeNode> m_search_tree;
|
||||
// Reference to the actual lon/lat data we need for doing math
|
||||
const Vector<Coordinate> &m_coordinate_list;
|
||||
util::vector_view<const Coordinate> m_coordinate_list;
|
||||
// Holds the start indexes of each level in m_search_tree
|
||||
Vector<std::uint64_t> m_tree_level_starts;
|
||||
// mmap'd .fileIndex file
|
||||
@ -264,6 +264,7 @@ class StaticRTree
|
||||
util::vector_view<const EdgeDataT> m_objects;
|
||||
|
||||
public:
|
||||
StaticRTree() = default;
|
||||
StaticRTree(const StaticRTree &) = delete;
|
||||
StaticRTree &operator=(const StaticRTree &) = delete;
|
||||
StaticRTree(StaticRTree &&) = default;
|
||||
@ -273,7 +274,7 @@ class StaticRTree
|
||||
explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
|
||||
const Vector<Coordinate> &coordinate_list,
|
||||
const boost::filesystem::path &on_disk_file_name)
|
||||
: m_coordinate_list(coordinate_list)
|
||||
: m_coordinate_list(coordinate_list.data(), coordinate_list.size())
|
||||
{
|
||||
const auto element_count = input_data_vector.size();
|
||||
std::vector<WrappedInputElement> input_wrapper_vector(element_count);
|
||||
@ -460,7 +461,7 @@ class StaticRTree
|
||||
template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
|
||||
explicit StaticRTree(const boost::filesystem::path &on_disk_file_name,
|
||||
const Vector<Coordinate> &coordinate_list)
|
||||
: m_coordinate_list(coordinate_list)
|
||||
: m_coordinate_list(coordinate_list.data(), coordinate_list.size())
|
||||
{
|
||||
m_objects = mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region);
|
||||
}
|
||||
@ -475,7 +476,8 @@ class StaticRTree
|
||||
Vector<std::uint64_t> tree_level_starts,
|
||||
const boost::filesystem::path &on_disk_file_name,
|
||||
const Vector<Coordinate> &coordinate_list)
|
||||
: m_search_tree(std::move(search_tree_)), m_coordinate_list(coordinate_list),
|
||||
: m_search_tree(std::move(search_tree_)),
|
||||
m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
|
||||
m_tree_level_starts(std::move(tree_level_starts))
|
||||
{
|
||||
BOOST_ASSERT(m_tree_level_starts.size() >= 2);
|
||||
|
||||
@ -329,21 +329,15 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
|
||||
|
||||
// Loading list of coordinates
|
||||
{
|
||||
auto coordinates =
|
||||
make_vector_view<util::Coordinate>(memory_ptr, layout, "/common/coordinates");
|
||||
|
||||
auto osm_node_ids =
|
||||
extractor::PackedOSMIDsView{make_vector_view<extractor::PackedOSMIDsView::block_type>(
|
||||
memory_ptr, layout, "/common/osm_node_ids/packed"),
|
||||
coordinates.size()};
|
||||
|
||||
extractor::files::readNodes(config.GetPath(".osrm.nbg_nodes"), coordinates, osm_node_ids);
|
||||
auto views = make_nbn_data_view(memory_ptr, layout, "/common/nbn_data");
|
||||
extractor::files::readNodes(
|
||||
config.GetPath(".osrm.nbg_nodes"), std::get<0>(views), std::get<1>(views));
|
||||
}
|
||||
|
||||
// load turn weight penalties
|
||||
{
|
||||
auto turn_duration_penalties =
|
||||
make_vector_view<TurnPenalty>(memory_ptr, layout, "/common/turn_penalty/weight");
|
||||
make_turn_weight_view(memory_ptr, layout, "/common/turn_penalty");
|
||||
extractor::files::readTurnWeightPenalty(config.GetPath(".osrm.turn_weight_penalties"),
|
||||
turn_duration_penalties);
|
||||
}
|
||||
@ -351,7 +345,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
|
||||
// load turn duration penalties
|
||||
{
|
||||
auto turn_duration_penalties =
|
||||
make_vector_view<TurnPenalty>(memory_ptr, layout, "/common/turn_penalty/duration");
|
||||
make_turn_duration_view(memory_ptr, layout, "/common/turn_penalty");
|
||||
extractor::files::readTurnDurationPenalty(config.GetPath(".osrm.turn_duration_penalties"),
|
||||
turn_duration_penalties);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user