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

Ownership: vector already owns, no need for wrapping in unique_ptr.

Browse Source 
Removes the pointless `std::unique_ptr<std::vector<T>>` usage,
as a `std::vector` already owns its resources and manages them.

Results in one indirection less (hint: good).
This commit is contained in:
Daniel J. Hofmann 2015-09-09 18:34:09 +02:00
parent db092c828e
commit f10fb77a81
2 changed files with 101 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
contractor/processing_chain.cpp
View File

@ -40,7 +40,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../util/graph_loader.hpp" #include "../util/graph_loader.hpp"
#include "../util/integer_range.hpp" #include "../util/integer_range.hpp"
#include "../util/lua_util.hpp" #include "../util/lua_util.hpp"
#include "../util/make_unique.hpp"
#include "../util/osrm_exception.hpp" #include "../util/osrm_exception.hpp"
#include "../util/simple_logger.hpp" #include "../util/simple_logger.hpp"
#include "../util/string_util.hpp" #include "../util/string_util.hpp"
@ -79,12 +78,11 @@ int Prepare::Run()
TIMER_START(expansion); TIMER_START(expansion);
auto node_based_edge_list = osrm::make_unique<std::vector<EdgeBasedNode>>();; std::vector<EdgeBasedNode> node_based_edge_list;
DeallocatingVector<EdgeBasedEdge> edge_based_edge_list; DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
auto internal_to_external_node_map = osrm::make_unique<std::vector<QueryNode>>(); std::vector<QueryNode> internal_to_external_node_map;
auto graph_size = auto graph_size = BuildEdgeExpandedGraph(internal_to_external_node_map, node_based_edge_list,
BuildEdgeExpandedGraph(*internal_to_external_node_map, edge_based_edge_list);
*node_based_edge_list, edge_based_edge_list);
auto number_of_node_based_nodes = graph_size.first; auto number_of_node_based_nodes = graph_size.first;
auto max_edge_id = graph_size.second; auto max_edge_id = graph_size.second;
@ -94,39 +92,37 @@ int Prepare::Run()
SimpleLogger().Write() << "building r-tree ..."; SimpleLogger().Write() << "building r-tree ...";
TIMER_START(rtree); TIMER_START(rtree);
FindComponents(max_edge_id, edge_based_edge_list, *node_based_edge_list); FindComponents(max_edge_id, edge_based_edge_list, node_based_edge_list);
BuildRTree(*node_based_edge_list, *internal_to_external_node_map); BuildRTree(node_based_edge_list, internal_to_external_node_map);
TIMER_STOP(rtree); TIMER_STOP(rtree);
SimpleLogger().Write() << "writing node map ..."; SimpleLogger().Write() << "writing node map ...";
WriteNodeMapping(std::move(internal_to_external_node_map)); WriteNodeMapping(internal_to_external_node_map);
// Contracting the edge-expanded graph // Contracting the edge-expanded graph
TIMER_START(contraction); TIMER_START(contraction);
std::vector<bool> is_core_node; std::vector<bool> is_core_node;
auto contracted_edge_list = osrm::make_unique<DeallocatingVector<QueryEdge>>(); DeallocatingVector<QueryEdge> contracted_edge_list;
ContractGraph(max_edge_id, edge_based_edge_list, *contracted_edge_list, is_core_node); ContractGraph(max_edge_id, edge_based_edge_list, contracted_edge_list, is_core_node);
TIMER_STOP(contraction); TIMER_STOP(contraction);
SimpleLogger().Write() << "Contraction took " << TIMER_SEC(contraction) << " sec"; SimpleLogger().Write() << "Contraction took " << TIMER_SEC(contraction) << " sec";
std::size_t number_of_used_edges = WriteContractedGraph(max_edge_id, std::size_t number_of_used_edges =
std::move(node_based_edge_list), WriteContractedGraph(max_edge_id, node_based_edge_list, contracted_edge_list);
std::move(contracted_edge_list));
WriteCoreNodeMarker(std::move(is_core_node)); WriteCoreNodeMarker(std::move(is_core_node));
TIMER_STOP(preparing); TIMER_STOP(preparing);
SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds"; SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
SimpleLogger().Write() << "Expansion : " << (number_of_node_based_nodes / TIMER_SEC(expansion)) SimpleLogger().Write() << "Expansion : " << (number_of_node_based_nodes / TIMER_SEC(expansion))
<< " nodes/sec and " << " nodes/sec and " << ((max_edge_id + 1) / TIMER_SEC(expansion))
<< ((max_edge_id+1) / TIMER_SEC(expansion)) << " edges/sec"; << " edges/sec";
SimpleLogger().Write() << "Contraction: " SimpleLogger().Write() << "Contraction: " << ((max_edge_id + 1) / TIMER_SEC(contraction))
<< ((max_edge_id+1) / TIMER_SEC(contraction))
<< " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction) << " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction)
<< " edges/sec"; << " edges/sec";
@ -135,30 +131,34 @@ int Prepare::Run()
return 0; return 0;
} }
void Prepare::FindComponents(unsigned max_edge_id, const DeallocatingVector<EdgeBasedEdge>& input_edge_list, void Prepare::FindComponents(unsigned max_edge_id,
std::vector<EdgeBasedNode>& input_nodes) const const DeallocatingVector<EdgeBasedEdge> &input_edge_list,
std::vector<EdgeBasedNode> &input_nodes) const
{ {
struct UncontractedEdgeData { }; struct UncontractedEdgeData
struct InputEdge { {
};
struct InputEdge
{
unsigned source; unsigned source;
unsigned target; unsigned target;
UncontractedEdgeData data; UncontractedEdgeData data;
bool operator<(const InputEdge& rhs) const bool operator<(const InputEdge &rhs) const
{ {
return source < rhs.source || (source == rhs.source && target < rhs.target); return source < rhs.source || (source == rhs.source && target < rhs.target);
} }
bool operator==(const InputEdge& rhs) const bool operator==(const InputEdge &rhs) const
{ {
return source == rhs.source && target == rhs.target; return source == rhs.source && target == rhs.target;
} }
}; };
using UncontractedGraph = StaticGraph<UncontractedEdgeData>; using UncontractedGraph = StaticGraph<UncontractedEdgeData>;
std::vector<InputEdge> edges; std::vector<InputEdge> edges;
edges.reserve(input_edge_list.size() * 2); edges.reserve(input_edge_list.size() * 2);
for (const auto& edge : input_edge_list) for (const auto &edge : input_edge_list)
{ {
BOOST_ASSERT_MSG(static_cast<unsigned int>(std::max(edge.weight, 1)) > 0, BOOST_ASSERT_MSG(static_cast<unsigned int>(std::max(edge.weight, 1)) > 0,
"edge distance < 1"); "edge distance < 1");
@ -174,7 +174,7 @@ void Prepare::FindComponents(unsigned max_edge_id, const DeallocatingVector<Edge
} }
// connect forward and backward nodes of each edge // connect forward and backward nodes of each edge
for (const auto& node : input_nodes) for (const auto &node : input_nodes)
{ {
if (node.reverse_edge_based_node_id != SPECIAL_NODEID) if (node.reverse_edge_based_node_id != SPECIAL_NODEID)
{ {
@ -187,16 +187,18 @@ void Prepare::FindComponents(unsigned max_edge_id, const DeallocatingVector<Edge
auto new_end = std::unique(edges.begin(), edges.end()); auto new_end = std::unique(edges.begin(), edges.end());
edges.resize(new_end - edges.begin()); edges.resize(new_end - edges.begin());
auto uncontractor_graph = std::make_shared<UncontractedGraph>(max_edge_id+1, edges); auto uncontractor_graph = std::make_shared<UncontractedGraph>(max_edge_id + 1, edges);
TarjanSCC<UncontractedGraph> component_search(std::const_pointer_cast<const UncontractedGraph>(uncontractor_graph)); TarjanSCC<UncontractedGraph> component_search(
std::const_pointer_cast<const UncontractedGraph>(uncontractor_graph));
component_search.run(); component_search.run();
for (auto& node : input_nodes) for (auto &node : input_nodes)
{ {
auto forward_component = component_search.get_component_id(node.forward_edge_based_node_id); auto forward_component = component_search.get_component_id(node.forward_edge_based_node_id);
BOOST_ASSERT(node.reverse_edge_based_node_id == SPECIAL_EDGEID || BOOST_ASSERT(node.reverse_edge_based_node_id == SPECIAL_EDGEID ||
forward_component == component_search.get_component_id(node.reverse_edge_based_node_id)); forward_component ==
component_search.get_component_id(node.reverse_edge_based_node_id));
const unsigned component_size = component_search.get_component_size(forward_component); const unsigned component_size = component_search.get_component_size(forward_component);
const bool is_tiny_component = component_size < 1000; const bool is_tiny_component = component_size < 1000;
@ -204,7 +206,7 @@ void Prepare::FindComponents(unsigned max_edge_id, const DeallocatingVector<Edge
} }
} }
void Prepare::WriteCoreNodeMarker(std::vector<bool>&& in_is_core_node) const void Prepare::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
{ {
std::vector<bool> is_core_node(in_is_core_node); std::vector<bool> is_core_node(in_is_core_node);
std::vector<char> unpacked_bool_flags(is_core_node.size()); std::vector<char> unpacked_bool_flags(is_core_node.size());
@ -213,21 +215,23 @@ void Prepare::WriteCoreNodeMarker(std::vector<bool>&& in_is_core_node) const
unpacked_bool_flags[i] = is_core_node[i] ? 1 : 0; unpacked_bool_flags[i] = is_core_node[i] ? 1 : 0;
} }
boost::filesystem::ofstream core_marker_output_stream(config.core_output_path, std::ios::binary); boost::filesystem::ofstream core_marker_output_stream(config.core_output_path,
std::ios::binary);
unsigned size = unpacked_bool_flags.size(); unsigned size = unpacked_bool_flags.size();
core_marker_output_stream.write((char *)&size, sizeof(unsigned)); core_marker_output_stream.write((char *)&size, sizeof(unsigned));
core_marker_output_stream.write((char *)unpacked_bool_flags.data(), sizeof(char)*unpacked_bool_flags.size()); core_marker_output_stream.write((char *)unpacked_bool_flags.data(),
sizeof(char) * unpacked_bool_flags.size());
} }
std::size_t Prepare::WriteContractedGraph(unsigned max_node_id, std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list, const std::vector<EdgeBasedNode> &node_based_edge_list,
std::unique_ptr<DeallocatingVector<QueryEdge>> contracted_edge_list) const DeallocatingVector<QueryEdge> &contracted_edge_list)
{ {
const unsigned crc32_value = CalculateEdgeChecksum(std::move(node_based_edge_list)); const unsigned crc32_value = CalculateEdgeChecksum(node_based_edge_list);
// Sorting contracted edges in a way that the static query graph can read some in in-place. // 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()); tbb::parallel_sort(contracted_edge_list);
const unsigned contracted_edge_count = contracted_edge_list->size(); const unsigned contracted_edge_count = contracted_edge_list.size();
SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count
<< " edges"; << " edges";
@ -237,7 +241,7 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
const unsigned max_used_node_id = [&contracted_edge_list] const unsigned max_used_node_id = [&contracted_edge_list]
{ {
unsigned tmp_max = 0; unsigned tmp_max = 0;
for (const QueryEdge &edge : *contracted_edge_list) for (const QueryEdge &edge : contracted_edge_list)
{ {
BOOST_ASSERT(SPECIAL_NODEID != edge.source); BOOST_ASSERT(SPECIAL_NODEID != edge.source);
BOOST_ASSERT(SPECIAL_NODEID != edge.target); BOOST_ASSERT(SPECIAL_NODEID != edge.target);
@ -247,8 +251,8 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
return tmp_max; return tmp_max;
}(); }();
SimpleLogger().Write(logDEBUG) << "input graph has " << (max_node_id+1) << " nodes"; SimpleLogger().Write(logDEBUG) << "input graph has " << (max_node_id + 1) << " nodes";
SimpleLogger().Write(logDEBUG) << "contracted graph has " << (max_used_node_id+1) << " nodes"; SimpleLogger().Write(logDEBUG) << "contracted graph has " << (max_used_node_id + 1) << " nodes";
std::vector<StaticGraph<EdgeData>::NodeArrayEntry> node_array; std::vector<StaticGraph<EdgeData>::NodeArrayEntry> node_array;
// make sure we have at least one sentinel // make sure we have at least one sentinel
@ -260,10 +264,10 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
StaticGraph<EdgeData>::EdgeIterator last_edge; StaticGraph<EdgeData>::EdgeIterator last_edge;
// initializing 'first_edge'-field of nodes: // initializing 'first_edge'-field of nodes:
for (const auto node : osrm::irange(0u, max_used_node_id+1)) for (const auto node : osrm::irange(0u, max_used_node_id + 1))
{ {
last_edge = edge; last_edge = edge;
while ((edge < contracted_edge_count) && ((*contracted_edge_list)[edge].source == node)) while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
{ {
++edge; ++edge;
} }
@ -271,7 +275,8 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
position += edge - last_edge; // remove position += edge - last_edge; // remove
} }
for (const auto sentinel_counter : osrm::irange<unsigned>(max_used_node_id+1, node_array.size())) for (const auto sentinel_counter :
osrm::irange<unsigned>(max_used_node_id + 1, node_array.size()))
{ {
// sentinel element, guarded against underflow // sentinel element, guarded against underflow
node_array[sentinel_counter].first_edge = contracted_edge_count; node_array[sentinel_counter].first_edge = contracted_edge_count;
@ -298,12 +303,12 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
int number_of_used_edges = 0; int number_of_used_edges = 0;
StaticGraph<EdgeData>::EdgeArrayEntry current_edge; StaticGraph<EdgeData>::EdgeArrayEntry current_edge;
for (const auto edge : osrm::irange<std::size_t>(0, contracted_edge_list->size())) for (const auto edge : osrm::irange<std::size_t>(0, contracted_edge_list.size()))
{ {
// no eigen loops // no eigen loops
BOOST_ASSERT((*contracted_edge_list)[edge].source != (*contracted_edge_list)[edge].target); BOOST_ASSERT(contracted_edge_list[edge].source != contracted_edge_list[edge].target);
current_edge.target = (*contracted_edge_list)[edge].target; current_edge.target = contracted_edge_list[edge].target;
current_edge.data = (*contracted_edge_list)[edge].data; current_edge.data = contracted_edge_list[edge].data;
// every target needs to be valid // every target needs to be valid
BOOST_ASSERT(current_edge.target <= max_used_node_id); BOOST_ASSERT(current_edge.target <= max_used_node_id);
@ -311,12 +316,12 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
if (current_edge.data.distance <= 0) if (current_edge.data.distance <= 0)
{ {
SimpleLogger().Write(logWARNING) << "Edge: " << edge SimpleLogger().Write(logWARNING) << "Edge: " << edge
<< ",source: " << (*contracted_edge_list)[edge].source << ",source: " << contracted_edge_list[edge].source
<< ", target: " << (*contracted_edge_list)[edge].target << ", target: " << contracted_edge_list[edge].target
<< ", dist: " << current_edge.data.distance; << ", dist: " << current_edge.data.distance;
SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node " SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node "
<< (*contracted_edge_list)[edge].source << "/" << contracted_edge_list[edge].source << "/"
<< node_array.size() - 1; << node_array.size() - 1;
return 1; return 1;
} }
@ -330,7 +335,7 @@ std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
return number_of_used_edges; return number_of_used_edges;
} }
unsigned Prepare::CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list) unsigned Prepare::CalculateEdgeChecksum(const std::vector<EdgeBasedNode> &node_based_edge_list)
{ {
RangebasedCRC32 crc32; RangebasedCRC32 crc32;
if (crc32.using_hardware()) if (crc32.using_hardware())
@ -342,7 +347,7 @@ unsigned Prepare::CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNod
SimpleLogger().Write() << "using software based CRC32 computation"; SimpleLogger().Write() << "using software based CRC32 computation";
} }
const unsigned crc32_value = crc32(*node_based_edge_list); const unsigned crc32_value = crc32(node_based_edge_list);
SimpleLogger().Write() << "CRC32: " << crc32_value; SimpleLogger().Write() << "CRC32: " << crc32_value;
return crc32_value; return crc32_value;
@ -352,8 +357,7 @@ unsigned Prepare::CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNod
\brief Setups scripting environment (lua-scripting) \brief Setups scripting environment (lua-scripting)
Also initializes speed profile. Also initializes speed profile.
*/ */
void Prepare::SetupScriptingEnvironment( void Prepare::SetupScriptingEnvironment(lua_State *lua_state, SpeedProfileProperties &speed_profile)
lua_State *lua_state, SpeedProfileProperties &speed_profile)
{ {
// open utility libraries string library; // open utility libraries string library;
luaL_openlibs(lua_state); luaL_openlibs(lua_state);
@ -395,7 +399,8 @@ void Prepare::SetupScriptingEnvironment(
*/ */
std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap() std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap()
{ {
boost::filesystem::ifstream input_stream(config.restrictions_path, std::ios::in | std::ios::binary); boost::filesystem::ifstream input_stream(config.restrictions_path,
std::ios::in | std::ios::binary);
std::vector<TurnRestriction> restriction_list; std::vector<TurnRestriction> restriction_list;
loadRestrictionsFromFile(input_stream, restriction_list); loadRestrictionsFromFile(input_stream, restriction_list);
@ -411,17 +416,17 @@ std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap()
std::shared_ptr<NodeBasedDynamicGraph> std::shared_ptr<NodeBasedDynamicGraph>
Prepare::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes, Prepare::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
std::unordered_set<NodeID> &traffic_lights, std::unordered_set<NodeID> &traffic_lights,
std::vector<QueryNode>& internal_to_external_node_map) std::vector<QueryNode> &internal_to_external_node_map)
{ {
std::vector<NodeBasedEdge> edge_list; std::vector<NodeBasedEdge> edge_list;
boost::filesystem::ifstream input_stream(config.osrm_input_path, std::ios::in | std::ios::binary); boost::filesystem::ifstream input_stream(config.osrm_input_path,
std::ios::in | std::ios::binary);
std::vector<NodeID> barrier_list; std::vector<NodeID> barrier_list;
std::vector<NodeID> traffic_light_list; std::vector<NodeID> traffic_light_list;
NodeID number_of_node_based_nodes = loadNodesFromFile(input_stream, NodeID number_of_node_based_nodes = loadNodesFromFile(
barrier_list, traffic_light_list, input_stream, barrier_list, traffic_light_list, internal_to_external_node_map);
internal_to_external_node_map);
SimpleLogger().Write() << " - " << barrier_list.size() << " bollard nodes, " SimpleLogger().Write() << " - " << barrier_list.size() << " bollard nodes, "
<< traffic_light_list.size() << " traffic lights"; << traffic_light_list.size() << " traffic lights";
@ -446,7 +451,6 @@ Prepare::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
return NodeBasedDynamicGraphFromEdges(number_of_node_based_nodes, edge_list); return NodeBasedDynamicGraphFromEdges(number_of_node_based_nodes, edge_list);
} }
/** /**
\brief Building an edge-expanded graph from node-based input and turn restrictions \brief Building an edge-expanded graph from node-based input and turn restrictions
*/ */
@ -465,20 +469,18 @@ Prepare::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_nod
std::unordered_set<NodeID> traffic_lights; std::unordered_set<NodeID> traffic_lights;
auto restriction_map = LoadRestrictionMap(); auto restriction_map = LoadRestrictionMap();
auto node_based_graph = LoadNodeBasedGraph(barrier_nodes, traffic_lights, internal_to_external_node_map); auto node_based_graph =
LoadNodeBasedGraph(barrier_nodes, traffic_lights, internal_to_external_node_map);
CompressedEdgeContainer compressed_edge_container; CompressedEdgeContainer compressed_edge_container;
GraphCompressor graph_compressor(speed_profile); GraphCompressor graph_compressor(speed_profile);
graph_compressor.Compress(barrier_nodes, traffic_lights, *restriction_map, *node_based_graph, compressed_edge_container); graph_compressor.Compress(barrier_nodes, traffic_lights, *restriction_map, *node_based_graph,
compressed_edge_container);
EdgeBasedGraphFactory edge_based_graph_factory(node_based_graph, EdgeBasedGraphFactory edge_based_graph_factory(
compressed_edge_container, node_based_graph, compressed_edge_container, barrier_nodes, traffic_lights,
barrier_nodes, std::const_pointer_cast<RestrictionMap const>(restriction_map),
traffic_lights, internal_to_external_node_map, speed_profile);
std::const_pointer_cast<RestrictionMap const>(restriction_map),
internal_to_external_node_map,
speed_profile);
compressed_edge_container.SerializeInternalVector(config.geometry_output_path); compressed_edge_container.SerializeInternalVector(config.geometry_output_path);
@ -497,9 +499,9 @@ Prepare::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_nod
\brief Build contracted graph. \brief Build contracted graph.
*/ */
void Prepare::ContractGraph(const unsigned max_edge_id, void Prepare::ContractGraph(const unsigned max_edge_id,
DeallocatingVector<EdgeBasedEdge>& edge_based_edge_list, DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
DeallocatingVector<QueryEdge>& contracted_edge_list, DeallocatingVector<QueryEdge> &contracted_edge_list,
std::vector<bool>& is_core_node) std::vector<bool> &is_core_node)
{ {
Contractor contractor(max_edge_id + 1, edge_based_edge_list); Contractor contractor(max_edge_id + 1, edge_based_edge_list);
contractor.Run(config.core_factor); contractor.Run(config.core_factor);
@ -510,14 +512,14 @@ void Prepare::ContractGraph(const unsigned max_edge_id,
/** /**
\brief Writing info on original (node-based) nodes \brief Writing info on original (node-based) nodes
*/ */
void Prepare::WriteNodeMapping(std::unique_ptr<std::vector<QueryNode>> internal_to_external_node_map) void Prepare::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
{ {
boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary); boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
const unsigned size_of_mapping = internal_to_external_node_map->size(); const unsigned size_of_mapping = internal_to_external_node_map.size();
node_stream.write((char *)&size_of_mapping, sizeof(unsigned)); node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
if (size_of_mapping > 0) if (size_of_mapping > 0)
{ {
node_stream.write((char *) internal_to_external_node_map->data(), node_stream.write((char *)internal_to_external_node_map.data(),
size_of_mapping * sizeof(QueryNode)); size_of_mapping * sizeof(QueryNode));
} }
node_stream.close(); node_stream.close();
@ -528,8 +530,10 @@ void Prepare::WriteNodeMapping(std::unique_ptr<std::vector<QueryNode>> internal_
Saves tree into '.ramIndex' and leaves into '.fileIndex'. Saves tree into '.ramIndex' and leaves into '.fileIndex'.
*/ */
void Prepare::BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list, const std::vector<QueryNode>& internal_to_external_node_map) void Prepare::BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
const std::vector<QueryNode> &internal_to_external_node_map)
{ {
StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path.c_str(), StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path.c_str(),
config.rtree_leafs_output_path.c_str(), internal_to_external_node_map); config.rtree_leafs_output_path.c_str(),
internal_to_external_node_map);
} }

30
contractor/processing_chain.hpp
View File

@ -58,30 +58,32 @@ class Prepare
int Run(); int Run();
protected: protected:
void SetupScriptingEnvironment(lua_State *myLuaState, void SetupScriptingEnvironment(lua_State *myLuaState, SpeedProfileProperties &speed_profile);
SpeedProfileProperties &speed_profile); unsigned CalculateEdgeChecksum(const std::vector<EdgeBasedNode> &node_based_edge_list);
unsigned CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list);
void ContractGraph(const unsigned max_edge_id, void ContractGraph(const unsigned max_edge_id,
DeallocatingVector<EdgeBasedEdge>& edge_based_edge_list, DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
DeallocatingVector<QueryEdge>& contracted_edge_list, DeallocatingVector<QueryEdge> &contracted_edge_list,
std::vector<bool>& is_core_node); std::vector<bool> &is_core_node);
void WriteCoreNodeMarker(std::vector<bool>&& is_core_node) const; void WriteCoreNodeMarker(std::vector<bool> &&is_core_node) const;
std::size_t WriteContractedGraph(unsigned number_of_edge_based_nodes, std::size_t WriteContractedGraph(unsigned number_of_edge_based_nodes,
std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list, const std::vector<EdgeBasedNode> &node_based_edge_list,
std::unique_ptr<DeallocatingVector<QueryEdge>> contracted_edge_list); const DeallocatingVector<QueryEdge> &contracted_edge_list);
std::shared_ptr<RestrictionMap> LoadRestrictionMap(); std::shared_ptr<RestrictionMap> LoadRestrictionMap();
std::shared_ptr<NodeBasedDynamicGraph> std::shared_ptr<NodeBasedDynamicGraph>
LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes, LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
std::unordered_set<NodeID> &traffic_lights, std::unordered_set<NodeID> &traffic_lights,
std::vector<QueryNode>& internal_to_external_node_map); std::vector<QueryNode> &internal_to_external_node_map);
std::pair<std::size_t, std::size_t> std::pair<std::size_t, std::size_t>
BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map, BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
std::vector<EdgeBasedNode> &node_based_edge_list, std::vector<EdgeBasedNode> &node_based_edge_list,
DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list); DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
void WriteNodeMapping(std::unique_ptr<std::vector<QueryNode>> internal_to_external_node_map); void WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map);
void FindComponents(unsigned max_edge_id, const DeallocatingVector<EdgeBasedEdge>& edges, std::vector<EdgeBasedNode>& nodes) const; void FindComponents(unsigned max_edge_id,
const DeallocatingVector<EdgeBasedEdge> &edges,
std::vector<EdgeBasedNode> &nodes) const;
void BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list, void BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
const std::vector<QueryNode> &internal_to_external_node_map); const std::vector<QueryNode> &internal_to_external_node_map);
private: private:
ContractorConfig config; ContractorConfig config;
}; };