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

Fix naming convention, and pass-by-reference for data layout.

Browse Source
This commit is contained in:
Daniel Patterson 2016-11-14 23:41:44 -08:00
parent 49f960064c
commit 1fc969e6c8
3 changed files with 104 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
include/engine/datafacade/contiguous_internalmem_datafacade_base.hpp
View File

@ -121,35 +121,35 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table; std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
util::ShM<DiscreteBearing, true>::vector m_bearing_values_table; util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;
void InitChecksum(storage::DataLayout *data_layout, char *memory_block) void InitializeChecksumPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
m_check_sum = m_check_sum =
*data_layout->GetBlockPtr<unsigned>(memory_block, storage::DataLayout::HSGR_CHECKSUM); *data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::HSGR_CHECKSUM);
util::SimpleLogger().Write() << "set checksum: " << m_check_sum; util::SimpleLogger().Write() << "set checksum: " << m_check_sum;
} }
void InitProfileProperties(storage::DataLayout *data_layout, char *memory_block) void InitializeProfilePropertiesPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
m_profile_properties = data_layout->GetBlockPtr<extractor::ProfileProperties>( m_profile_properties = data_layout.GetBlockPtr<extractor::ProfileProperties>(
memory_block, storage::DataLayout::PROPERTIES); memory_block, storage::DataLayout::PROPERTIES);
} }
void InitTimestamp(storage::DataLayout *data_layout, char *memory_block) void InitializeTimestampPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
auto timestamp_ptr = auto timestamp_ptr =
data_layout->GetBlockPtr<char>(memory_block, storage::DataLayout::TIMESTAMP); data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::TIMESTAMP);
m_timestamp.resize(data_layout->GetBlockSize(storage::DataLayout::TIMESTAMP)); m_timestamp.resize(data_layout.GetBlockSize(storage::DataLayout::TIMESTAMP));
std::copy(timestamp_ptr, std::copy(timestamp_ptr,
timestamp_ptr + data_layout->GetBlockSize(storage::DataLayout::TIMESTAMP), timestamp_ptr + data_layout.GetBlockSize(storage::DataLayout::TIMESTAMP),
m_timestamp.begin()); m_timestamp.begin());
} }
void InitRTree(storage::DataLayout *data_layout, char *memory_block) void InitializeRTreePointers(storage::DataLayout &data_layout, char *memory_block)
{ {
BOOST_ASSERT_MSG(!m_coordinate_list.empty(), "coordinates must be loaded before r-tree"); BOOST_ASSERT_MSG(!m_coordinate_list.empty(), "coordinates must be loaded before r-tree");
const auto file_index_ptr = const auto file_index_ptr =
data_layout->GetBlockPtr<char>(memory_block, storage::DataLayout::FILE_INDEX_PATH); data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::FILE_INDEX_PATH);
file_index_path = boost::filesystem::path(file_index_ptr); file_index_path = boost::filesystem::path(file_index_ptr);
if (!boost::filesystem::exists(file_index_path)) if (!boost::filesystem::exists(file_index_path))
{ {
@ -159,266 +159,267 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
} }
auto tree_ptr = auto tree_ptr =
data_layout->GetBlockPtr<RTreeNode>(memory_block, storage::DataLayout::R_SEARCH_TREE); data_layout.GetBlockPtr<RTreeNode>(memory_block, storage::DataLayout::R_SEARCH_TREE);
m_static_rtree.reset( m_static_rtree.reset(
new SharedRTree(tree_ptr, new SharedRTree(tree_ptr,
data_layout->num_entries[storage::DataLayout::R_SEARCH_TREE], data_layout.num_entries[storage::DataLayout::R_SEARCH_TREE],
file_index_path, file_index_path,
m_coordinate_list)); m_coordinate_list));
m_geospatial_query.reset( m_geospatial_query.reset(
new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this)); new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
} }
void InitGraph(storage::DataLayout *data_layout, char *memory_block) void InitializeGraphPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
auto graph_nodes_ptr = auto graph_nodes_ptr =
data_layout->GetBlockPtr<GraphNode>(memory_block, storage::DataLayout::GRAPH_NODE_LIST); data_layout.GetBlockPtr<GraphNode>(memory_block, storage::DataLayout::GRAPH_NODE_LIST);
auto graph_edges_ptr = auto graph_edges_ptr =
data_layout->GetBlockPtr<GraphEdge>(memory_block, storage::DataLayout::GRAPH_EDGE_LIST); data_layout.GetBlockPtr<GraphEdge>(memory_block, storage::DataLayout::GRAPH_EDGE_LIST);
util::ShM<GraphNode, true>::vector node_list( util::ShM<GraphNode, true>::vector node_list(
graph_nodes_ptr, data_layout->num_entries[storage::DataLayout::GRAPH_NODE_LIST]); graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::GRAPH_NODE_LIST]);
util::ShM<GraphEdge, true>::vector edge_list( util::ShM<GraphEdge, true>::vector edge_list(
graph_edges_ptr, data_layout->num_entries[storage::DataLayout::GRAPH_EDGE_LIST]); graph_edges_ptr, data_layout.num_entries[storage::DataLayout::GRAPH_EDGE_LIST]);
m_query_graph.reset(new QueryGraph(node_list, edge_list)); m_query_graph.reset(new QueryGraph(node_list, edge_list));
} }
void InitNodeAndEdgeInformation(storage::DataLayout *data_layout, char *memory_block) void InitializeNodeAndEdgeInformationPointers(storage::DataLayout &data_layout,
char *memory_block)
{ {
const auto coordinate_list_ptr = data_layout->GetBlockPtr<util::Coordinate>( const auto coordinate_list_ptr = data_layout.GetBlockPtr<util::Coordinate>(
memory_block, storage::DataLayout::COORDINATE_LIST); memory_block, storage::DataLayout::COORDINATE_LIST);
m_coordinate_list = CoordinateArrayRef( m_coordinate_list = CoordinateArrayRef(
coordinate_list_ptr, coordinate_list_ptr,
coordinate_list_ptr + data_layout->num_entries[storage::DataLayout::COORDINATE_LIST]); coordinate_list_ptr + data_layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
for (unsigned i = 0; i < m_coordinate_list.size(); ++i) for (unsigned i = 0; i < m_coordinate_list.size(); ++i)
{ {
BOOST_ASSERT(GetCoordinateOfNode(i).IsValid()); BOOST_ASSERT(GetCoordinateOfNode(i).IsValid());
} }
const auto osmnodeid_list_ptr = data_layout->GetBlockPtr<std::uint64_t>( const auto osmnodeid_list_ptr = data_layout.GetBlockPtr<std::uint64_t>(
memory_block, storage::DataLayout::OSM_NODE_ID_LIST); memory_block, storage::DataLayout::OSM_NODE_ID_LIST);
m_osmnodeid_list.reset(osmnodeid_list_ptr, m_osmnodeid_list.reset(osmnodeid_list_ptr,
data_layout->num_entries[storage::DataLayout::OSM_NODE_ID_LIST]); data_layout.num_entries[storage::DataLayout::OSM_NODE_ID_LIST]);
// We (ab)use the number of coordinates here because we know we have the same amount of ids // We (ab)use the number of coordinates here because we know we have the same amount of ids
m_osmnodeid_list.set_number_of_entries( m_osmnodeid_list.set_number_of_entries(
data_layout->num_entries[storage::DataLayout::COORDINATE_LIST]); data_layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
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, true>::vector travel_mode_list( util::ShM<extractor::TravelMode, true>::vector travel_mode_list(
travel_mode_list_ptr, data_layout->num_entries[storage::DataLayout::TRAVEL_MODE]); 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 =
data_layout->GetBlockPtr<LaneDataID>(memory_block, storage::DataLayout::LANE_DATA_ID); data_layout.GetBlockPtr<LaneDataID>(memory_block, storage::DataLayout::LANE_DATA_ID);
util::ShM<LaneDataID, true>::vector lane_data_id( util::ShM<LaneDataID, true>::vector lane_data_id(
lane_data_id_ptr, data_layout->num_entries[storage::DataLayout::LANE_DATA_ID]); lane_data_id_ptr, data_layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
m_lane_data_id = std::move(lane_data_id); m_lane_data_id = std::move(lane_data_id);
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, true>::vector lane_tupel_id_pair( util::ShM<util::guidance::LaneTupleIdPair, true>::vector lane_tupel_id_pair(
lane_tupel_id_pair_ptr, data_layout->num_entries[storage::DataLayout::TURN_LANE_DATA]); 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, true>::vector turn_instruction_list( util::ShM<extractor::guidance::TurnInstruction, true>::vector turn_instruction_list(
turn_instruction_list_ptr, 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);
const auto name_id_list_ptr = const auto name_id_list_ptr =
data_layout->GetBlockPtr<unsigned>(memory_block, storage::DataLayout::NAME_ID_LIST); data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::NAME_ID_LIST);
util::ShM<unsigned, true>::vector name_id_list( util::ShM<unsigned, true>::vector name_id_list(
name_id_list_ptr, data_layout->num_entries[storage::DataLayout::NAME_ID_LIST]); name_id_list_ptr, data_layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
m_name_ID_list = std::move(name_id_list); m_name_ID_list = std::move(name_id_list);
const auto entry_class_id_list_ptr = data_layout->GetBlockPtr<EntryClassID>( const auto entry_class_id_list_ptr =
memory_block, storage::DataLayout::ENTRY_CLASSID); data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID);
typename util::ShM<EntryClassID, true>::vector entry_class_id_list( typename util::ShM<EntryClassID, true>::vector entry_class_id_list(
entry_class_id_list_ptr, data_layout->num_entries[storage::DataLayout::ENTRY_CLASSID]); 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, true>::vector pre_turn_bearing( typename util::ShM<util::guidance::TurnBearing, true>::vector pre_turn_bearing(
pre_turn_bearing_ptr, data_layout->num_entries[storage::DataLayout::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, true>::vector post_turn_bearing( typename util::ShM<util::guidance::TurnBearing, true>::vector post_turn_bearing(
post_turn_bearing_ptr, post_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
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);
} }
void InitViaNodeList(storage::DataLayout *data_layout, char *memory_block) void InitializeViaNodeListPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
auto via_geometry_list_ptr = auto via_geometry_list_ptr =
data_layout->GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST); data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
util::ShM<GeometryID, true>::vector via_geometry_list( util::ShM<GeometryID, true>::vector via_geometry_list(
via_geometry_list_ptr, data_layout->num_entries[storage::DataLayout::VIA_NODE_LIST]); via_geometry_list_ptr, data_layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
m_via_geometry_list = std::move(via_geometry_list); m_via_geometry_list = std::move(via_geometry_list);
} }
void InitNames(storage::DataLayout *data_layout, char *memory_block) void InitializeNamePointers(storage::DataLayout &data_layout, char *memory_block)
{ {
auto offsets_ptr = auto offsets_ptr =
data_layout->GetBlockPtr<unsigned>(memory_block, storage::DataLayout::NAME_OFFSETS); data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::NAME_OFFSETS);
auto blocks_ptr = auto blocks_ptr =
data_layout->GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::NAME_BLOCKS); data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::NAME_BLOCKS);
util::ShM<unsigned, true>::vector name_offsets( util::ShM<unsigned, true>::vector name_offsets(
offsets_ptr, data_layout->num_entries[storage::DataLayout::NAME_OFFSETS]); offsets_ptr, data_layout.num_entries[storage::DataLayout::NAME_OFFSETS]);
util::ShM<IndexBlock, true>::vector name_blocks( util::ShM<IndexBlock, true>::vector name_blocks(
blocks_ptr, data_layout->num_entries[storage::DataLayout::NAME_BLOCKS]); blocks_ptr, data_layout.num_entries[storage::DataLayout::NAME_BLOCKS]);
auto names_list_ptr = auto names_list_ptr =
data_layout->GetBlockPtr<char>(memory_block, storage::DataLayout::NAME_CHAR_LIST); data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::NAME_CHAR_LIST);
util::ShM<char, true>::vector names_char_list( util::ShM<char, true>::vector names_char_list(
names_list_ptr, data_layout->num_entries[storage::DataLayout::NAME_CHAR_LIST]); names_list_ptr, data_layout.num_entries[storage::DataLayout::NAME_CHAR_LIST]);
m_name_table = std::make_unique<util::RangeTable<16, true>>( m_name_table = std::make_unique<util::RangeTable<16, true>>(
name_offsets, name_blocks, static_cast<unsigned>(names_char_list.size())); name_offsets, name_blocks, static_cast<unsigned>(names_char_list.size()));
m_names_char_list = std::move(names_char_list); m_names_char_list = std::move(names_char_list);
} }
void InitTurnLaneDescriptions(storage::DataLayout *data_layout, char *memory_block) void InitializeTurnLaneDescriptionsPointers(storage::DataLayout &data_layout,
char *memory_block)
{ {
auto offsets_ptr = data_layout->GetBlockPtr<std::uint32_t>( auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS); memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
util::ShM<std::uint32_t, true>::vector offsets( util::ShM<std::uint32_t, true>::vector offsets(
offsets_ptr, data_layout->num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]); offsets_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]);
m_lane_description_offsets = std::move(offsets); m_lane_description_offsets = std::move(offsets);
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, true>::vector masks( util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector masks(
masks_ptr, data_layout->num_entries[storage::DataLayout::LANE_DESCRIPTION_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);
} }
void InitCoreInformation(storage::DataLayout *data_layout, char *memory_block) void InitializeCoreInformationPointer(storage::DataLayout &data_layout, char *memory_block)
{ {
auto core_marker_ptr = auto core_marker_ptr =
data_layout->GetBlockPtr<unsigned>(memory_block, storage::DataLayout::CORE_MARKER); data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::CORE_MARKER);
util::ShM<bool, true>::vector is_core_node( util::ShM<bool, true>::vector is_core_node(
core_marker_ptr, data_layout->num_entries[storage::DataLayout::CORE_MARKER]); core_marker_ptr, data_layout.num_entries[storage::DataLayout::CORE_MARKER]);
m_is_core_node = std::move(is_core_node); m_is_core_node = std::move(is_core_node);
} }
void InitGeometries(storage::DataLayout *data_layout, char *memory_block) void InitializeGeometryPointers(storage::DataLayout &data_layout, char *memory_block)
{ {
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, true>::vector geometry_begin_indices( util::ShM<unsigned, true>::vector geometry_begin_indices(
geometries_index_ptr, data_layout->num_entries[storage::DataLayout::GEOMETRIES_INDEX]); geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);
m_geometry_indices = std::move(geometry_begin_indices); m_geometry_indices = std::move(geometry_begin_indices);
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);
util::ShM<NodeID, true>::vector geometry_node_list( util::ShM<NodeID, true>::vector geometry_node_list(
geometries_node_list_ptr, geometries_node_list_ptr,
data_layout->num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST]); data_layout.num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST]);
m_geometry_node_list = std::move(geometry_node_list); m_geometry_node_list = std::move(geometry_node_list);
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, true>::vector geometry_fwd_weight_list( util::ShM<EdgeWeight, true>::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]);
m_geometry_fwd_weight_list = std::move(geometry_fwd_weight_list); m_geometry_fwd_weight_list = std::move(geometry_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, true>::vector geometry_rev_weight_list( util::ShM<EdgeWeight, true>::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]);
m_geometry_rev_weight_list = std::move(geometry_rev_weight_list); m_geometry_rev_weight_list = std::move(geometry_rev_weight_list);
auto datasources_list_ptr = auto datasources_list_ptr =
data_layout->GetBlockPtr<uint8_t>(memory_block, storage::DataLayout::DATASOURCES_LIST); data_layout.GetBlockPtr<uint8_t>(memory_block, storage::DataLayout::DATASOURCES_LIST);
util::ShM<uint8_t, true>::vector datasources_list( util::ShM<uint8_t, true>::vector datasources_list(
datasources_list_ptr, data_layout->num_entries[storage::DataLayout::DATASOURCES_LIST]); datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);
m_datasource_list = std::move(datasources_list); m_datasource_list = std::move(datasources_list);
auto datasource_name_data_ptr = auto datasource_name_data_ptr =
data_layout->GetBlockPtr<char>(memory_block, storage::DataLayout::DATASOURCE_NAME_DATA); data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::DATASOURCE_NAME_DATA);
util::ShM<char, true>::vector datasource_name_data( util::ShM<char, true>::vector datasource_name_data(
datasource_name_data_ptr, datasource_name_data_ptr,
data_layout->num_entries[storage::DataLayout::DATASOURCE_NAME_DATA]); data_layout.num_entries[storage::DataLayout::DATASOURCE_NAME_DATA]);
m_datasource_name_data = std::move(datasource_name_data); m_datasource_name_data = std::move(datasource_name_data);
auto datasource_name_offsets_ptr = data_layout->GetBlockPtr<std::size_t>( auto datasource_name_offsets_ptr = data_layout.GetBlockPtr<std::size_t>(
memory_block, storage::DataLayout::DATASOURCE_NAME_OFFSETS); memory_block, storage::DataLayout::DATASOURCE_NAME_OFFSETS);
util::ShM<std::size_t, true>::vector datasource_name_offsets( util::ShM<std::size_t, true>::vector datasource_name_offsets(
datasource_name_offsets_ptr, datasource_name_offsets_ptr,
data_layout->num_entries[storage::DataLayout::DATASOURCE_NAME_OFFSETS]); data_layout.num_entries[storage::DataLayout::DATASOURCE_NAME_OFFSETS]);
m_datasource_name_offsets = std::move(datasource_name_offsets); m_datasource_name_offsets = std::move(datasource_name_offsets);
auto datasource_name_lengths_ptr = data_layout->GetBlockPtr<std::size_t>( auto datasource_name_lengths_ptr = data_layout.GetBlockPtr<std::size_t>(
memory_block, storage::DataLayout::DATASOURCE_NAME_LENGTHS); memory_block, storage::DataLayout::DATASOURCE_NAME_LENGTHS);
util::ShM<std::size_t, true>::vector datasource_name_lengths( util::ShM<std::size_t, true>::vector datasource_name_lengths(
datasource_name_lengths_ptr, datasource_name_lengths_ptr,
data_layout->num_entries[storage::DataLayout::DATASOURCE_NAME_LENGTHS]); data_layout.num_entries[storage::DataLayout::DATASOURCE_NAME_LENGTHS]);
m_datasource_name_lengths = std::move(datasource_name_lengths); m_datasource_name_lengths = std::move(datasource_name_lengths);
} }
void InitIntersectionClasses(storage::DataLayout *data_layout, char *memory_block) void InitializeIntersectionClassPointers(storage::DataLayout &data_layout, char *memory_block)
{ {
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, true>::vector bearing_class_id_table( typename util::ShM<BearingClassID, true>::vector bearing_class_id_table(
bearing_class_id_ptr, data_layout->num_entries[storage::DataLayout::BEARING_CLASSID]); 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, true>::vector bearing_class_table( typename util::ShM<DiscreteBearing, true>::vector bearing_class_table(
bearing_class_ptr, data_layout->num_entries[storage::DataLayout::BEARING_VALUES]); 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 =
data_layout->GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS); data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS);
auto blocks_ptr = auto blocks_ptr =
data_layout->GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS); data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS);
util::ShM<unsigned, true>::vector bearing_offsets( util::ShM<unsigned, true>::vector bearing_offsets(
offsets_ptr, data_layout->num_entries[storage::DataLayout::BEARING_OFFSETS]); offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
util::ShM<IndexBlock, true>::vector bearing_blocks( util::ShM<IndexBlock, true>::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, true>>( m_bearing_ranges_table = std::make_unique<util::RangeTable<16, true>>(
bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size())); 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, true>::vector entry_class_table( typename util::ShM<util::guidance::EntryClass, true>::vector entry_class_table(
entry_class_ptr, data_layout->num_entries[storage::DataLayout::ENTRY_CLASS]); 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);
} }
public: public:
void Init(storage::DataLayout *data_layout, char *memory_block) void InitializeInternalPointers(storage::DataLayout &data_layout, char *memory_block)
{ {
InitGraph(data_layout, memory_block); InitializeGraphPointer(data_layout, memory_block);
InitChecksum(data_layout, memory_block); InitializeChecksumPointer(data_layout, memory_block);
InitNodeAndEdgeInformation(data_layout, memory_block); InitializeNodeAndEdgeInformationPointers(data_layout, memory_block);
InitGeometries(data_layout, memory_block); InitializeGeometryPointers(data_layout, memory_block);
InitTimestamp(data_layout, memory_block); InitializeTimestampPointer(data_layout, memory_block);
InitViaNodeList(data_layout, memory_block); InitializeViaNodeListPointer(data_layout, memory_block);
InitNames(data_layout, memory_block); InitializeNamePointers(data_layout, memory_block);
InitTurnLaneDescriptions(data_layout, memory_block); InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
InitCoreInformation(data_layout, memory_block); InitializeCoreInformationPointer(data_layout, memory_block);
InitProfileProperties(data_layout, memory_block); InitializeProfilePropertiesPointer(data_layout, memory_block);
InitRTree(data_layout, memory_block); InitializeRTreePointers(data_layout, memory_block);
InitIntersectionClasses(data_layout, memory_block); InitializeIntersectionClassPointers(data_layout, memory_block);
} }
// search graph access // search graph access

2
include/engine/datafacade/process_memory_datafacade.hpp
View File

@ -42,7 +42,7 @@ class ProcessMemoryDataFacade final : public ContiguousInternalMemoryDataFacadeB
storage.PopulateData(*internal_layout, internal_memory.get()); storage.PopulateData(*internal_layout, internal_memory.get());
// Adjust all the private m_* members to point to the right places // Adjust all the private m_* members to point to the right places
Init(internal_layout.get(), internal_memory.get()); InitializeInternalPointers(*internal_layout.get(), internal_memory.get());
} }
}; };
} }

4
include/engine/datafacade/shared_memory_datafacade.hpp
View File

@ -83,8 +83,8 @@ class SharedMemoryDataFacade : public ContiguousInternalMemoryDataFacadeBase
BOOST_ASSERT(storage::SharedMemory::RegionExists(data_region)); BOOST_ASSERT(storage::SharedMemory::RegionExists(data_region));
m_large_memory = storage::makeSharedMemory(data_region); m_large_memory = storage::makeSharedMemory(data_region);
Init(static_cast<storage::DataLayout *>(m_layout_memory->Ptr()), InitializeInternalPointers(*reinterpret_cast<storage::DataLayout *>(m_layout_memory->Ptr()),
static_cast<char *>(m_large_memory->Ptr())); reinterpret_cast<char *>(m_large_memory->Ptr()));
} }
}; };
} }