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

refactor function names; consolidate readCount() functions;

Browse Source 
remove templated types as much as possible for type safety;
add more comments;
clean up code, add const if possible;
This commit is contained in:
Huyen Chau Nguyen
2016-10-21 15:24:55 -07:00
parent fe94977c9b
commit cf35bbeb50
8 changed files with 169 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/contractor/contractor.cpp
+12 -10
View File
@@ -420,8 +420,8 @@ parse_turn_penalty_lookup_from_csv_files(const std::vector<std::string> &turn_pe
local.push_back(std::move(val));
}
util::SimpleLogger().Write() << "Loaded penalty file " << filename << " with " << local.size()
<< " turn penalties";
util::SimpleLogger().Write() << "Loaded penalty file " << filename << " with "
<< local.size() << " turn penalties";
{
Mutex::scoped_lock _{flatten_mutex};
@@ -437,8 +437,10 @@ parse_turn_penalty_lookup_from_csv_files(const std::vector<std::string> &turn_pe
// With flattened map-ish view of all the files, sort and unique them on from,to,source
// The greater '>' is used here since we want to give files later on higher precedence
const auto sort_by = [](const TurnPenaltySource &lhs, const TurnPenaltySource &rhs) {
return std::tie(lhs.segment.from, lhs.segment.via, lhs.segment.to, lhs.penalty_source.source) >
std::tie(rhs.segment.from, rhs.segment.via, rhs.segment.to, rhs.penalty_source.source);
return std::tie(
lhs.segment.from, lhs.segment.via, lhs.segment.to, lhs.penalty_source.source) >
std::tie(
rhs.segment.from, rhs.segment.via, rhs.segment.to, rhs.penalty_source.source);
};
std::stable_sort(begin(map), end(map), sort_by);
@@ -569,8 +571,8 @@ EdgeID Contractor::LoadEdgeExpandedGraph(
throw util::exception("Failed to open " + nodes_filename);
}
unsigned number_of_nodes = 0;
nodes_input_stream.read((char *)&number_of_nodes, sizeof(unsigned));
std::uint64_t number_of_nodes = 0;
nodes_input_stream.read((char *)&number_of_nodes, sizeof(std::uint64_t));
internal_to_external_node_map.resize(number_of_nodes);
// Load all the query nodes into a vector
@@ -976,7 +978,7 @@ Contractor::WriteContractedGraph(unsigned max_node_id,
{
// Sorting contracted edges in a way that the static query graph can read some in in-place.
tbb::parallel_sort(contracted_edge_list.begin(), contracted_edge_list.end());
const unsigned contracted_edge_count = contracted_edge_list.size();
const std::uint64_t contracted_edge_count = contracted_edge_list.size();
util::SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count
<< " edges";
@@ -1033,13 +1035,13 @@ Contractor::WriteContractedGraph(unsigned max_node_id,
const unsigned edges_crc32 = crc32_calculator(contracted_edge_list);
util::SimpleLogger().Write() << "Writing CRC32: " << edges_crc32;
const unsigned node_array_size = node_array.size();
const std::uint64_t node_array_size = node_array.size();
// serialize crc32, aka checksum
hsgr_output_stream.write((char *)&edges_crc32, sizeof(unsigned));
// serialize number of nodes
hsgr_output_stream.write((char *)&node_array_size, sizeof(unsigned));
hsgr_output_stream.write((char *)&node_array_size, sizeof(std::uint64_t));
// serialize number of edges
hsgr_output_stream.write((char *)&contracted_edge_count, sizeof(unsigned));
hsgr_output_stream.write((char *)&contracted_edge_count, sizeof(std::uint64_t));
// serialize all nodes
if (node_array_size > 0)
{
src/extractor/edge_based_graph_factory.cpp
+2 -2
View File
@@ -331,7 +331,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
}
// Writes a dummy value at the front that is updated later with the total length
const unsigned length_prefix_empty_space{0};
const std::uint64_t length_prefix_empty_space{0};
edge_data_file.write(reinterpret_cast<const char *>(&length_prefix_empty_space),
sizeof(length_prefix_empty_space));
@@ -598,7 +598,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
// Finally jump back to the empty space at the beginning and write length prefix
edge_data_file.seekp(std::ios::beg);
const auto length_prefix = boost::numeric_cast<unsigned>(original_edges_counter);
const auto length_prefix = boost::numeric_cast<std::uint64_t>(original_edges_counter);
static_assert(sizeof(length_prefix_empty_space) == sizeof(length_prefix), "type mismatch");
edge_data_file.write(reinterpret_cast<const char *>(&length_prefix), sizeof(length_prefix));
src/extractor/extractor.cpp
+3 -4
View File
@@ -112,8 +112,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
TIMER_START(extracting);
const unsigned recommended_num_threads = tbb::task_scheduler_init::default_num_threads();
const auto number_of_threads =
std::min(recommended_num_threads, config.requested_num_threads);
const auto number_of_threads = std::min(recommended_num_threads, config.requested_num_threads);
tbb::task_scheduler_init init(number_of_threads);
{
@@ -527,8 +526,8 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
void Extractor::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
{
boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
const unsigned size_of_mapping = internal_to_external_node_map.size();
node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
const std::uint64_t size_of_mapping = internal_to_external_node_map.size();
node_stream.write((char *)&size_of_mapping, sizeof(std::uint64_t));
if (size_of_mapping > 0)
{
node_stream.write((char *)internal_to_external_node_map.data(),
src/storage/storage.cpp
+31 -40
View File
@@ -230,7 +230,7 @@ Storage::ReturnCode Storage::Run(int max_wait)
throw util::exception("Could not open " + config.edges_data_path.string() +
" for reading.");
}
auto number_of_original_edges = io::readEdgesSize(edges_input_stream);
const auto number_of_original_edges = io::readElementCount(edges_input_stream);
// note: settings this all to the same size is correct, we extract them from the same struct
shared_layout_ptr->SetBlockSize<NodeID>(SharedDataLayout::VIA_NODE_LIST,
@@ -256,7 +256,7 @@ Storage::ReturnCode Storage::Run(int max_wait)
throw util::exception("Could not open " + config.hsgr_data_path.string() + " for reading.");
}
auto hsgr_header = io::readHSGRHeader(hsgr_input_stream);
const auto hsgr_header = io::readHSGRHeader(hsgr_input_stream);
shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::HSGR_CHECKSUM, 1);
shared_layout_ptr->SetBlockSize<QueryGraph::NodeArrayEntry>(SharedDataLayout::GRAPH_NODE_LIST,
hsgr_header.number_of_nodes);
@@ -266,13 +266,13 @@ Storage::ReturnCode Storage::Run(int max_wait)
// load rsearch tree size
boost::filesystem::ifstream tree_node_file(config.ram_index_path, std::ios::binary);
std::uint32_t tree_size = io::readRamIndexSize(tree_node_file);
const auto tree_size = io::readElementCount(tree_node_file);
shared_layout_ptr->SetBlockSize<RTreeNode>(SharedDataLayout::R_SEARCH_TREE, tree_size);
// allocate space in shared memory for profile properties
std::size_t PropertiesSize = io::readPropertiesSize();
const auto properties_size = io::readPropertiesCount();
shared_layout_ptr->SetBlockSize<extractor::ProfileProperties>(SharedDataLayout::PROPERTIES,
PropertiesSize);
properties_size);
// read timestampsize
boost::filesystem::ifstream timestamp_stream(config.timestamp_path);
@@ -280,7 +280,7 @@ Storage::ReturnCode Storage::Run(int max_wait)
{
throw util::exception("Could not open " + config.timestamp_path.string() + " for reading.");
}
std::size_t timestamp_size = io::readTimestampSize(timestamp_stream);
const auto timestamp_size = io::readNumberOfBytes(timestamp_stream);
shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::TIMESTAMP, timestamp_size);
// load core marker size
@@ -301,7 +301,7 @@ Storage::ReturnCode Storage::Run(int max_wait)
{
throw util::exception("Could not open " + config.core_data_path.string() + " for reading.");
}
auto coordinate_list_size = io::readNodesSize(nodes_input_stream);
const auto coordinate_list_size = io::readElementCount(nodes_input_stream);
shared_layout_ptr->SetBlockSize<util::Coordinate>(SharedDataLayout::COORDINATE_LIST,
coordinate_list_size);
// we'll read a list of OSM node IDs from the same data, so set the block size for the same
@@ -342,12 +342,8 @@ Storage::ReturnCode Storage::Run(int max_wait)
throw util::exception("Could not open " + config.datasource_indexes_path.string() +
" for reading.");
}
std::uint64_t number_of_compressed_datasources = 0;
if (geometry_datasource_input_stream)
{
number_of_compressed_datasources =
io::readDatasourceIndexesSize(geometry_datasource_input_stream);
}
const auto number_of_compressed_datasources =
io::readElementCount(geometry_datasource_input_stream);
shared_layout_ptr->SetBlockSize<uint8_t>(SharedDataLayout::DATASOURCES_LIST,
number_of_compressed_datasources);
@@ -361,19 +357,15 @@ Storage::ReturnCode Storage::Run(int max_wait)
throw util::exception("Could not open " + config.datasource_names_path.string() +
" for reading.");
}
io::DatasourceNamesData datasource_names_data;
if (datasource_names_input_stream)
{
datasource_names_data = io::readDatasourceNamesData(datasource_names_input_stream);
}
const io::DatasourceNamesData datasource_names_data =
io::readDatasourceNames(datasource_names_input_stream);
shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::DATASOURCE_NAME_DATA,
datasource_names_data.names.size());
shared_layout_ptr->SetBlockSize<std::uint32_t>(SharedDataLayout::DATASOURCE_NAME_OFFSETS,
datasource_names_data.offsets.size());
shared_layout_ptr->SetBlockSize<std::uint32_t>(SharedDataLayout::DATASOURCE_NAME_LENGTHS,
datasource_names_data.lengths.size());
shared_layout_ptr->SetBlockSize<std::size_t>(SharedDataLayout::DATASOURCE_NAME_OFFSETS,
datasource_names_data.offsets.size());
shared_layout_ptr->SetBlockSize<std::size_t>(SharedDataLayout::DATASOURCE_NAME_LENGTHS,
datasource_names_data.lengths.size());
boost::filesystem::ifstream intersection_stream(config.intersection_class_path,
std::ios::binary);
@@ -564,16 +556,16 @@ Storage::ReturnCode Storage::Run(int max_wait)
EntryClassID *entry_class_id_ptr = shared_layout_ptr->GetBlockPtr<EntryClassID, true>(
shared_memory_ptr, SharedDataLayout::ENTRY_CLASSID);
io::readEdgesData(edges_input_stream,
via_geometry_ptr,
name_id_ptr,
turn_instructions_ptr,
lane_data_id_ptr,
travel_mode_ptr,
entry_class_id_ptr,
pre_turn_bearing_ptr,
post_turn_bearing_ptr,
number_of_original_edges);
io::readEdges(edges_input_stream,
via_geometry_ptr,
name_id_ptr,
turn_instructions_ptr,
lane_data_id_ptr,
travel_mode_ptr,
entry_class_id_ptr,
pre_turn_bearing_ptr,
post_turn_bearing_ptr,
number_of_original_edges);
edges_input_stream.close();
// load compressed geometry
@@ -676,7 +668,7 @@ Storage::ReturnCode Storage::Run(int max_wait)
util::PackedVector<OSMNodeID, true> osmnodeid_list;
osmnodeid_list.reset(osmnodeid_ptr,
shared_layout_ptr->num_entries[SharedDataLayout::OSM_NODE_ID_LIST]);
io::readNodesData(nodes_input_stream, coordinates_ptr, osmnodeid_list, coordinate_list_size);
io::readNodes(nodes_input_stream, coordinates_ptr, osmnodeid_list, coordinate_list_size);
nodes_input_stream.close();
// store timestamp
@@ -685,9 +677,9 @@ Storage::ReturnCode Storage::Run(int max_wait)
io::readTimestamp(timestamp_stream, timestamp_ptr, timestamp_size);
// store search tree portion of rtree
RTreeNode *rtree_ptrtest = shared_layout_ptr->GetBlockPtr<RTreeNode, true>(shared_memory_ptr,
SharedDataLayout::R_SEARCH_TREE);
io::readRamIndexData(tree_node_file, rtree_ptrtest, tree_size);
RTreeNode *rtree_ptrtest = shared_layout_ptr->GetBlockPtr<RTreeNode, true>(
shared_memory_ptr, SharedDataLayout::R_SEARCH_TREE);
io::readRamIndex(tree_node_file, rtree_ptrtest, tree_size);
// load core markers
std::vector<char> unpacked_core_markers(number_of_core_markers);
@@ -744,9 +736,8 @@ Storage::ReturnCode Storage::Run(int max_wait)
{
util::exception("Could not open " + config.properties_path.string() + " for reading!");
}
io::readProperties(profile_properties_stream,
profile_properties_ptr,
sizeof(extractor::ProfileProperties));
io::readProperties(
profile_properties_stream, profile_properties_ptr, sizeof(extractor::ProfileProperties));
// load intersection classes
if (!bearing_class_id_table.empty())