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

Remove canary to get a consistent interface for getting a block pointer

Browse Source
This commit is contained in:
Patrick Niklaus 2018-04-03 09:43:43 +00:00 committed by Patrick Niklaus
parent 39effb8f7e
commit 3af3e06e75
3 changed files with 123 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
include/storage/shared_datatype.hpp
View File

@ -7,7 +7,6 @@
#include "util/exception.hpp" #include "util/exception.hpp"
#include "util/exception_utils.hpp" #include "util/exception_utils.hpp"
#include "util/log.hpp" #include "util/log.hpp"
#include "util/vector_view.hpp"
#include <boost/assert.hpp> #include <boost/assert.hpp>
@ -55,9 +54,6 @@ inline std::string trimName(const std::string &name_prefix, const std::string &n
} }
} }
// Added at the start and end of each block as sanity check
const constexpr char CANARY[4] = {'O', 'S', 'R', 'M'};
class DataLayout class DataLayout
{ {
public: public:
@ -82,55 +78,17 @@ class DataLayout
uint64_t result = 0; uint64_t result = 0;
for (const auto &name_and_block : blocks) for (const auto &name_and_block : blocks)
{ {
result += 2 * sizeof(CANARY) + GetBlockSize(name_and_block.first) + BLOCK_ALIGNMENT; result += GetBlockSize(name_and_block.first) + BLOCK_ALIGNMENT;
} }
return result; return result;
} }
template <typename T> template <typename T> inline T *GetBlockPtr(char *shared_memory, const std::string &name) const
util::vector_view<T> GetVector(char *shared_memory, const std::string &name) const
{
return util::vector_view<T>(GetBlockPtr<T>(shared_memory, name), GetBlockEntries(name));
}
template <typename T>
util::vector_view<T> GetWritableVector(char *shared_memory, const std::string &name) const
{
return util::vector_view<T>(GetBlockPtr<T, true>(shared_memory, name),
GetBlockEntries(name));
}
template <typename T, bool WRITE_CANARY = false>
inline T *GetBlockPtr(char *shared_memory, const std::string &name) const
{ {
static_assert(BLOCK_ALIGNMENT % std::alignment_of<T>::value == 0, static_assert(BLOCK_ALIGNMENT % std::alignment_of<T>::value == 0,
"Datatype does not fit alignment constraints."); "Datatype does not fit alignment constraints.");
char *ptr = (char *)GetAlignedBlockPtr(shared_memory, name); char *ptr = (char *)GetAlignedBlockPtr(shared_memory, name);
if (WRITE_CANARY)
{
char *start_canary_ptr = ptr - sizeof(CANARY);
char *end_canary_ptr = ptr + GetBlockSize(name);
std::copy(CANARY, CANARY + sizeof(CANARY), start_canary_ptr);
std::copy(CANARY, CANARY + sizeof(CANARY), end_canary_ptr);
}
else
{
char *start_canary_ptr = ptr - sizeof(CANARY);
char *end_canary_ptr = ptr + GetBlockSize(name);
bool start_canary_alive = std::equal(CANARY, CANARY + sizeof(CANARY), start_canary_ptr);
bool end_canary_alive = std::equal(CANARY, CANARY + sizeof(CANARY), end_canary_ptr);
if (!start_canary_alive)
{
throw util::exception("Start canary of block corrupted. (" + name + ")" +
SOURCE_REF);
}
if (!end_canary_alive)
{
throw util::exception("End canary of block corrupted. (" + name + ")" + SOURCE_REF);
}
}
return (T *)ptr; return (T *)ptr;
} }
@ -190,13 +148,10 @@ class DataLayout
for (auto iter = blocks.begin(); iter != block_iter; ++iter) for (auto iter = blocks.begin(); iter != block_iter; ++iter)
{ {
ptr = static_cast<char *>(ptr) + sizeof(CANARY);
ptr = align(ptr); ptr = align(ptr);
ptr = static_cast<char *>(ptr) + iter->second.byte_size; ptr = static_cast<char *>(ptr) + iter->second.byte_size;
ptr = static_cast<char *>(ptr) + sizeof(CANARY);
} }
ptr = static_cast<char *>(ptr) + sizeof(CANARY);
ptr = align(ptr); ptr = align(ptr);
return ptr; return ptr;
} }
@ -205,15 +160,6 @@ class DataLayout
std::map<std::string, Block> blocks; std::map<std::string, Block> blocks;
}; };
template <>
inline util::vector_view<bool> DataLayout::GetWritableVector<bool>(char *shared_memory,
const std::string &name) const
{
return util::vector_view<bool>(
GetBlockPtr<util::vector_view<bool>::Word, true>(shared_memory, name),
GetBlockEntries(name));
}
enum SharedDataType enum SharedDataType
{ {
REGION_NONE, REGION_NONE,

31
include/storage/view_factory.hpp Normal file
View File

@ -0,0 +1,31 @@
#ifndef OSRM_STOARGE_VIEW_FACTORY_HPP
#define OSRM_STOARGE_VIEW_FACTORY_HPP
#include "storage/shared_datatype.hpp"
#include "util/vector_view.hpp"
namespace osrm
{
namespace storage
{
template <typename T>
util::vector_view<T> make_vector_view(char *memory_ptr, DataLayout layout, const std::string &name)
{
return util::vector_view<T>(layout.GetBlockPtr<T>(memory_ptr, name),
layout.GetBlockEntries(name));
}
template <>
inline util::vector_view<bool>
make_vector_view(char *memory_ptr, DataLayout layout, const std::string &name)
{
return util::vector_view<bool>(
layout.GetBlockPtr<util::vector_view<bool>::Word>(memory_ptr, name),
layout.GetBlockEntries(name));
}
}
}
#endif

179
src/storage/storage.cpp
View File

@ -5,6 +5,7 @@
#include "storage/shared_memory.hpp" #include "storage/shared_memory.hpp"
#include "storage/shared_memory_ownership.hpp" #include "storage/shared_memory_ownership.hpp"
#include "storage/shared_monitor.hpp" #include "storage/shared_monitor.hpp"
#include "storage/view_factory.hpp"
#include "contractor/files.hpp" #include "contractor/files.hpp"
#include "contractor/query_graph.hpp" #include "contractor/query_graph.hpp"
@ -296,7 +297,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// store the filename of the on-disk portion of the RTree // store the filename of the on-disk portion of the RTree
{ {
const auto file_index_path_ptr = const auto file_index_path_ptr =
layout.GetBlockPtr<char, true>(memory_ptr, "/common/rtree/file_index_path"); layout.GetBlockPtr<char>(memory_ptr, "/common/rtree/file_index_path");
// make sure we have 0 ending // make sure we have 0 ending
std::fill(file_index_path_ptr, std::fill(file_index_path_ptr,
file_index_path_ptr + layout.GetBlockSize("/common/rtree/file_index_path"), file_index_path_ptr + layout.GetBlockSize("/common/rtree/file_index_path"),
@ -311,11 +312,10 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Name data // Name data
{ {
auto blocks = auto blocks = make_vector_view<extractor::NameTableView::IndexedData::BlockReference>(
layout.GetWritableVector<extractor::NameTableView::IndexedData::BlockReference>( memory_ptr, layout, "/common/names/blocks");
memory_ptr, "/common/names/blocks"); auto values = make_vector_view<extractor::NameTableView::IndexedData::ValueType>(
auto values = layout.GetWritableVector<extractor::NameTableView::IndexedData::ValueType>( memory_ptr, layout, "/common/names/values");
memory_ptr, "/common/names/values");
extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)}; extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)};
extractor::NameTableView name_table{index_data_view}; extractor::NameTableView name_table{index_data_view};
@ -324,8 +324,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Turn lane data // Turn lane data
{ {
auto turn_lane_data = layout.GetWritableVector<util::guidance::LaneTupleIdPair>( auto turn_lane_data = make_vector_view<util::guidance::LaneTupleIdPair>(
memory_ptr, "/common/turn_lanes/data"); memory_ptr, layout, "/common/turn_lanes/data");
extractor::files::readTurnLaneData(config.GetPath(".osrm.tld"), turn_lane_data); extractor::files::readTurnLaneData(config.GetPath(".osrm.tld"), turn_lane_data);
} }
@ -333,19 +333,19 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Turn lane descriptions // Turn lane descriptions
{ {
auto offsets = auto offsets =
layout.GetWritableVector<std::uint32_t>(memory_ptr, "/common/turn_lanes/offsets"); make_vector_view<std::uint32_t>(memory_ptr, layout, "/common/turn_lanes/offsets");
auto masks = layout.GetWritableVector<extractor::TurnLaneType::Mask>( auto masks = make_vector_view<extractor::TurnLaneType::Mask>(
memory_ptr, "/common/turn_lanes/masks"); memory_ptr, layout, "/common/turn_lanes/masks");
extractor::files::readTurnLaneDescriptions(config.GetPath(".osrm.tls"), offsets, masks); extractor::files::readTurnLaneDescriptions(config.GetPath(".osrm.tls"), offsets, masks);
} }
// Load edge-based nodes data // Load edge-based nodes data
{ {
auto edge_based_node_data = layout.GetWritableVector<extractor::EdgeBasedNode>( auto edge_based_node_data = make_vector_view<extractor::EdgeBasedNode>(
memory_ptr, "/common/ebg_node_data/nodes"); memory_ptr, layout, "/common/ebg_node_data/nodes");
auto annotation_data = layout.GetWritableVector<extractor::NodeBasedEdgeAnnotation>( auto annotation_data = make_vector_view<extractor::NodeBasedEdgeAnnotation>(
memory_ptr, "/common/ebg_node_data/annotations"); memory_ptr, layout, "/common/ebg_node_data/annotations");
extractor::EdgeBasedNodeDataView node_data(std::move(edge_based_node_data), extractor::EdgeBasedNodeDataView node_data(std::move(edge_based_node_data),
std::move(annotation_data)); std::move(annotation_data));
@ -356,19 +356,19 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Load original edge data // Load original edge data
{ {
auto lane_data_ids = auto lane_data_ids =
layout.GetWritableVector<LaneDataID>(memory_ptr, "/common/turn_data/lane_data_ids"); make_vector_view<LaneDataID>(memory_ptr, layout, "/common/turn_data/lane_data_ids");
const auto turn_instructions = layout.GetWritableVector<guidance::TurnInstruction>( const auto turn_instructions = make_vector_view<guidance::TurnInstruction>(
memory_ptr, "/common/turn_data/turn_instructions"); memory_ptr, layout, "/common/turn_data/turn_instructions");
const auto entry_class_ids = const auto entry_class_ids =
layout.GetWritableVector<EntryClassID>(memory_ptr, "/common/turn_data/entry_class_ids"); make_vector_view<EntryClassID>(memory_ptr, layout, "/common/turn_data/entry_class_ids");
const auto pre_turn_bearings = layout.GetWritableVector<guidance::TurnBearing>( const auto pre_turn_bearings = make_vector_view<guidance::TurnBearing>(
memory_ptr, "/common/turn_data/pre_turn_bearings"); memory_ptr, layout, "/common/turn_data/pre_turn_bearings");
const auto post_turn_bearings = layout.GetWritableVector<guidance::TurnBearing>( const auto post_turn_bearings = make_vector_view<guidance::TurnBearing>(
memory_ptr, "/common/turn_data/post_turn_bearings"); memory_ptr, layout, "/common/turn_data/post_turn_bearings");
guidance::TurnDataView turn_data(std::move(turn_instructions), guidance::TurnDataView turn_data(std::move(turn_instructions),
std::move(lane_data_ids), std::move(lane_data_ids),
@ -376,7 +376,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
std::move(pre_turn_bearings), std::move(pre_turn_bearings),
std::move(post_turn_bearings)); std::move(post_turn_bearings));
auto connectivity_checksum_ptr = auto connectivity_checksum_ptr =
layout.GetBlockPtr<std::uint32_t, true>(memory_ptr, "/common/connectivity_checksum"); layout.GetBlockPtr<std::uint32_t>(memory_ptr, "/common/connectivity_checksum");
guidance::files::readTurnData( guidance::files::readTurnData(
config.GetPath(".osrm.edges"), turn_data, *connectivity_checksum_ptr); config.GetPath(".osrm.edges"), turn_data, *connectivity_checksum_ptr);
@ -387,37 +387,37 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// load compressed geometry // load compressed geometry
{ {
auto geometry_begin_indices = auto geometry_begin_indices =
layout.GetWritableVector<unsigned>(memory_ptr, "/common/segment_data/index"); make_vector_view<unsigned>(memory_ptr, layout, "/common/segment_data/index");
auto node_list = layout.GetWritableVector<NodeID>(memory_ptr, "/common/segment_data/nodes"); auto node_list = make_vector_view<NodeID>(memory_ptr, layout, "/common/segment_data/nodes");
auto num_entries = layout.GetBlockEntries("/common/segment_data/nodes"); auto num_entries = layout.GetBlockEntries("/common/segment_data/nodes");
extractor::SegmentDataView::SegmentWeightVector fwd_weight_list( extractor::SegmentDataView::SegmentWeightVector fwd_weight_list(
layout.GetWritableVector<extractor::SegmentDataView::SegmentWeightVector::block_type>( make_vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
memory_ptr, "/common/segment_data/forward_weights/packed"), memory_ptr, layout, "/common/segment_data/forward_weights/packed"),
num_entries); num_entries);
extractor::SegmentDataView::SegmentWeightVector rev_weight_list( extractor::SegmentDataView::SegmentWeightVector rev_weight_list(
layout.GetWritableVector<extractor::SegmentDataView::SegmentWeightVector::block_type>( make_vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
memory_ptr, "/common/segment_data/reverse_weights/packed"), memory_ptr, layout, "/common/segment_data/reverse_weights/packed"),
num_entries); num_entries);
extractor::SegmentDataView::SegmentDurationVector fwd_duration_list( extractor::SegmentDataView::SegmentDurationVector fwd_duration_list(
layout.GetWritableVector<extractor::SegmentDataView::SegmentDurationVector::block_type>( make_vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
memory_ptr, "/common/segment_data/forward_durations/packed"), memory_ptr, layout, "/common/segment_data/forward_durations/packed"),
num_entries); num_entries);
extractor::SegmentDataView::SegmentDurationVector rev_duration_list( extractor::SegmentDataView::SegmentDurationVector rev_duration_list(
layout.GetWritableVector<extractor::SegmentDataView::SegmentDurationVector::block_type>( make_vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
memory_ptr, "/common/segment_data/reverse_durations/packed"), memory_ptr, layout, "/common/segment_data/reverse_durations/packed"),
num_entries); num_entries);
auto fwd_datasources_list = layout.GetWritableVector<DatasourceID>( auto fwd_datasources_list = make_vector_view<DatasourceID>(
memory_ptr, "/common/segment_data/forward_data_sources"); memory_ptr, layout, "/common/segment_data/forward_data_sources");
auto rev_datasources_list = layout.GetWritableVector<DatasourceID>( auto rev_datasources_list = make_vector_view<DatasourceID>(
memory_ptr, "/common/segment_data/reverse_data_sources"); memory_ptr, layout, "/common/segment_data/reverse_data_sources");
extractor::SegmentDataView segment_data{std::move(geometry_begin_indices), extractor::SegmentDataView segment_data{std::move(geometry_begin_indices),
std::move(node_list), std::move(node_list),
@ -432,8 +432,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
} }
{ {
const auto datasources_names_ptr = layout.GetBlockPtr<extractor::Datasources, true>( const auto datasources_names_ptr =
memory_ptr, "/common/data_sources_names"); layout.GetBlockPtr<extractor::Datasources>(memory_ptr, "/common/data_sources_names");
extractor::files::readDatasources(config.GetPath(".osrm.datasource_names"), extractor::files::readDatasources(config.GetPath(".osrm.datasource_names"),
*datasources_names_ptr); *datasources_names_ptr);
} }
@ -441,11 +441,11 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Loading list of coordinates // Loading list of coordinates
{ {
auto coordinates = auto coordinates =
layout.GetWritableVector<util::Coordinate>(memory_ptr, "/common/coordinates"); make_vector_view<util::Coordinate>(memory_ptr, layout, "/common/coordinates");
auto osm_node_ids = extractor::PackedOSMIDsView{ auto osm_node_ids =
layout.GetWritableVector<extractor::PackedOSMIDsView::block_type>( extractor::PackedOSMIDsView{make_vector_view<extractor::PackedOSMIDsView::block_type>(
memory_ptr, "/common/osm_node_ids/packed"), memory_ptr, layout, "/common/osm_node_ids/packed"),
coordinates.size()}; coordinates.size()};
extractor::files::readNodes(config.GetPath(".osrm.nbg_nodes"), coordinates, osm_node_ids); extractor::files::readNodes(config.GetPath(".osrm.nbg_nodes"), coordinates, osm_node_ids);
@ -454,7 +454,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// load turn weight penalties // load turn weight penalties
{ {
auto turn_duration_penalties = auto turn_duration_penalties =
layout.GetWritableVector<TurnPenalty>(memory_ptr, "/common/turn_penalty/weight"); make_vector_view<TurnPenalty>(memory_ptr, layout, "/common/turn_penalty/weight");
extractor::files::readTurnWeightPenalty(config.GetPath(".osrm.turn_weight_penalties"), extractor::files::readTurnWeightPenalty(config.GetPath(".osrm.turn_weight_penalties"),
turn_duration_penalties); turn_duration_penalties);
} }
@ -462,7 +462,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// load turn duration penalties // load turn duration penalties
{ {
auto turn_duration_penalties = auto turn_duration_penalties =
layout.GetWritableVector<TurnPenalty>(memory_ptr, "/common/turn_penalty/duration"); make_vector_view<TurnPenalty>(memory_ptr, layout, "/common/turn_penalty/duration");
extractor::files::readTurnDurationPenalty(config.GetPath(".osrm.turn_duration_penalties"), extractor::files::readTurnDurationPenalty(config.GetPath(".osrm.turn_duration_penalties"),
turn_duration_penalties); turn_duration_penalties);
} }
@ -471,10 +471,10 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
{ {
const auto search_tree = const auto search_tree =
layout.GetWritableVector<RTreeNode>(memory_ptr, "/common/rtree/search_tree"); make_vector_view<RTreeNode>(memory_ptr, layout, "/common/rtree/search_tree");
const auto rtree_level_starts = layout.GetWritableVector<std::uint64_t>( const auto rtree_level_starts = make_vector_view<std::uint64_t>(
memory_ptr, "/common/rtree/search_tree_level_starts"); memory_ptr, layout, "/common/rtree/search_tree_level_starts");
// we need this purely for the interface // we need this purely for the interface
util::vector_view<util::Coordinate> empty_coords; util::vector_view<util::Coordinate> empty_coords;
@ -491,8 +491,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
std::string metric_name; std::string metric_name;
// load profile properties // load profile properties
{ {
const auto profile_properties_ptr = layout.GetBlockPtr<extractor::ProfileProperties, true>( const auto profile_properties_ptr =
memory_ptr, "/common/properties"); layout.GetBlockPtr<extractor::ProfileProperties>(memory_ptr, "/common/properties");
extractor::files::readProfileProperties(config.GetPath(".osrm.properties"), extractor::files::readProfileProperties(config.GetPath(".osrm.properties"),
*profile_properties_ptr); *profile_properties_ptr);
@ -501,25 +501,25 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// Load intersection data // Load intersection data
{ {
auto bearing_offsets = layout.GetWritableVector<unsigned>( auto bearing_offsets = make_vector_view<unsigned>(
memory_ptr, "/common/intersection_bearings/class_id_to_ranges/block_offsets"); memory_ptr, layout, "/common/intersection_bearings/class_id_to_ranges/block_offsets");
auto bearing_blocks = auto bearing_blocks =
layout.GetWritableVector<util::RangeTable<16, storage::Ownership::View>::BlockT>( make_vector_view<util::RangeTable<16, storage::Ownership::View>::BlockT>(
memory_ptr, "/common/intersection_bearings/class_id_to_ranges/diff_blocks"); memory_ptr, layout, "/common/intersection_bearings/class_id_to_ranges/diff_blocks");
auto bearing_values = layout.GetWritableVector<DiscreteBearing>( auto bearing_values = make_vector_view<DiscreteBearing>(
memory_ptr, "/common/intersection_bearings/bearing_values"); memory_ptr, layout, "/common/intersection_bearings/bearing_values");
util::RangeTable<16, storage::Ownership::View> bearing_range_table( util::RangeTable<16, storage::Ownership::View> bearing_range_table(
std::move(bearing_offsets), std::move(bearing_offsets),
std::move(bearing_blocks), std::move(bearing_blocks),
static_cast<unsigned>(bearing_values.size())); static_cast<unsigned>(bearing_values.size()));
auto bearing_class_id = layout.GetWritableVector<BearingClassID>( auto bearing_class_id = make_vector_view<BearingClassID>(
memory_ptr, "/common/intersection_bearings/node_to_class_id"); memory_ptr, layout, "/common/intersection_bearings/node_to_class_id");
extractor::IntersectionBearingsView intersection_bearings_view{ extractor::IntersectionBearingsView intersection_bearings_view{
std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)}; std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
auto entry_classes = layout.GetWritableVector<util::guidance::EntryClass>( auto entry_classes = make_vector_view<util::guidance::EntryClass>(
memory_ptr, "/common/entry_classes"); memory_ptr, layout, "/common/entry_classes");
extractor::files::readIntersections( extractor::files::readIntersections(
config.GetPath(".osrm.icd"), intersection_bearings_view, entry_classes); config.GetPath(".osrm.icd"), intersection_bearings_view, entry_classes);
} }
@ -528,15 +528,15 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
{ {
const std::string metric_prefix = "/ch/metrics/" + metric_name; const std::string metric_prefix = "/ch/metrics/" + metric_name;
auto node_list = layout.GetWritableVector<contractor::QueryGraphView::NodeArrayEntry>( auto node_list = make_vector_view<contractor::QueryGraphView::NodeArrayEntry>(
memory_ptr, metric_prefix + "/contracted_graph/node_array"); memory_ptr, layout, metric_prefix + "/contracted_graph/node_array");
auto edge_list = layout.GetWritableVector<contractor::QueryGraphView::EdgeArrayEntry>( auto edge_list = make_vector_view<contractor::QueryGraphView::EdgeArrayEntry>(
memory_ptr, metric_prefix + "/contracted_graph/edge_array"); memory_ptr, layout, metric_prefix + "/contracted_graph/edge_array");
std::vector<util::vector_view<bool>> edge_filter; std::vector<util::vector_view<bool>> edge_filter;
layout.List(metric_prefix + "/exclude", layout.List(metric_prefix + "/exclude",
boost::make_function_output_iterator([&](const auto &name) { boost::make_function_output_iterator([&](const auto &name) {
edge_filter.push_back(layout.GetWritableVector<bool>(memory_ptr, name)); edge_filter.push_back(make_vector_view<bool>(memory_ptr, layout, name));
})); }));
std::uint32_t graph_connectivity_checksum = 0; std::uint32_t graph_connectivity_checksum = 0;
@ -561,13 +561,12 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
BOOST_ASSERT(layout.GetBlockSize("/mld/multilevelpartition/cell_to_children") > 0); BOOST_ASSERT(layout.GetBlockSize("/mld/multilevelpartition/cell_to_children") > 0);
BOOST_ASSERT(layout.GetBlockSize("/mld/multilevelpartition/partition") > 0); BOOST_ASSERT(layout.GetBlockSize("/mld/multilevelpartition/partition") > 0);
auto level_data_ptr = auto level_data_ptr = layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData, true>(
memory_ptr, "/mld/multilevelpartition/level_data"); memory_ptr, "/mld/multilevelpartition/level_data");
auto partition = auto partition =
layout.GetWritableVector<PartitionID>(memory_ptr, "/mld/multilevelpartition/partition"); make_vector_view<PartitionID>(memory_ptr, layout, "/mld/multilevelpartition/partition");
auto cell_to_children = layout.GetWritableVector<CellID>( auto cell_to_children = make_vector_view<CellID>(
memory_ptr, "/mld/multilevelpartition/cell_to_children"); memory_ptr, layout, "/mld/multilevelpartition/cell_to_children");
partitioner::MultiLevelPartitionView mlp{ partitioner::MultiLevelPartitionView mlp{
level_data_ptr, std::move(partition), std::move(cell_to_children)}; level_data_ptr, std::move(partition), std::move(cell_to_children)};
@ -580,13 +579,13 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
BOOST_ASSERT(layout.GetBlockSize("/mld/cellstorage/level_to_cell_offset") > 0); BOOST_ASSERT(layout.GetBlockSize("/mld/cellstorage/level_to_cell_offset") > 0);
auto source_boundary = auto source_boundary =
layout.GetWritableVector<NodeID>(memory_ptr, "/mld/cellstorage/source_boundary"); make_vector_view<NodeID>(memory_ptr, layout, "/mld/cellstorage/source_boundary");
auto destination_boundary = auto destination_boundary =
layout.GetWritableVector<NodeID>(memory_ptr, "/mld/cellstorage/destination_boundary"); make_vector_view<NodeID>(memory_ptr, layout, "/mld/cellstorage/destination_boundary");
auto cells = layout.GetWritableVector<partitioner::CellStorageView::CellData>( auto cells = make_vector_view<partitioner::CellStorageView::CellData>(
memory_ptr, "/mld/cellstorage/cells"); memory_ptr, layout, "/mld/cellstorage/cells");
auto level_offsets = layout.GetWritableVector<std::uint64_t>( auto level_offsets = make_vector_view<std::uint64_t>(
memory_ptr, "/mld/cellstorage/level_to_cell_offset"); memory_ptr, layout, "/mld/cellstorage/level_to_cell_offset");
partitioner::CellStorageView storage{std::move(source_boundary), partitioner::CellStorageView storage{std::move(source_boundary),
std::move(destination_boundary), std::move(destination_boundary),
@ -612,8 +611,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
auto weights_block_id = prefix + "/weights"; auto weights_block_id = prefix + "/weights";
auto durations_block_id = prefix + "/durations"; auto durations_block_id = prefix + "/durations";
auto weights = layout.GetWritableVector<EdgeWeight>(memory_ptr, weights_block_id); auto weights = make_vector_view<EdgeWeight>(memory_ptr, layout, weights_block_id);
auto durations = layout.GetWritableVector<EdgeDuration>(memory_ptr, durations_block_id); auto durations = make_vector_view<EdgeDuration>(memory_ptr, layout, durations_block_id);
metrics[metric_name].push_back( metrics[metric_name].push_back(
customizer::CellMetricView{std::move(weights), std::move(durations)}); customizer::CellMetricView{std::move(weights), std::move(durations)});
@ -624,15 +623,13 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
if (boost::filesystem::exists(config.GetPath(".osrm.mldgr"))) if (boost::filesystem::exists(config.GetPath(".osrm.mldgr")))
{ {
auto node_list = auto node_list = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry>(
layout.GetWritableVector<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry>( memory_ptr, layout, "/mld/multilevelgraph/node_array");
memory_ptr, "/mld/multilevelgraph/node_array"); auto edge_list = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeArrayEntry>(
auto edge_list = memory_ptr, layout, "/mld/multilevelgraph/edge_array");
layout.GetWritableVector<customizer::MultiLevelEdgeBasedGraphView::EdgeArrayEntry>(
memory_ptr, "/mld/multilevelgraph/edge_array");
auto node_to_offset = auto node_to_offset =
layout.GetWritableVector<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset>( make_vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset>(
memory_ptr, "/mld/multilevelgraph/node_to_edge_offset"); memory_ptr, layout, "/mld/multilevelgraph/node_to_edge_offset");
std::uint32_t graph_connectivity_checksum = 0; std::uint32_t graph_connectivity_checksum = 0;
customizer::MultiLevelEdgeBasedGraphView graph_view( customizer::MultiLevelEdgeBasedGraphView graph_view(
@ -652,10 +649,10 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// load maneuver overrides // load maneuver overrides
{ {
auto maneuver_overrides = layout.GetWritableVector<extractor::StorageManeuverOverride>( auto maneuver_overrides = make_vector_view<extractor::StorageManeuverOverride>(
memory_ptr, "/common/maneuver_overrides/overrides"); memory_ptr, layout, "/common/maneuver_overrides/overrides");
auto maneuver_override_node_sequences = layout.GetWritableVector<NodeID>( auto maneuver_override_node_sequences = make_vector_view<NodeID>(
memory_ptr, "/common/maneuver_overrides/node_sequences"); memory_ptr, layout, "/common/maneuver_overrides/node_sequences");
extractor::files::readManeuverOverrides(config.GetPath(".osrm.maneuver_overrides"), extractor::files::readManeuverOverrides(config.GetPath(".osrm.maneuver_overrides"),
maneuver_overrides, maneuver_overrides,