From 2d3fb858ad052ad16d95c17e9071dcc628358556 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 5 May 2014 17:19:47 +0200 Subject: [PATCH] move StaticGraph to C++11 --- DataStructures/SearchEngineData.h | 11 +- DataStructures/StaticGraph.h | 200 +++++++++++---------- Server/DataStructures/InternalDataFacade.h | 4 +- Server/DataStructures/SharedDataFacade.h | 12 +- Server/DataStructures/SharedDataType.h | 62 +++---- datastore.cpp | 8 +- prepare.cpp | 8 +- 7 files changed, 162 insertions(+), 143 deletions(-) diff --git a/DataStructures/SearchEngineData.h b/DataStructures/SearchEngineData.h index dd7ac5f50..fac2ce68e 100644 --- a/DataStructures/SearchEngineData.h +++ b/DataStructures/SearchEngineData.h @@ -36,18 +36,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -#include #include -struct _HeapData { +struct HeapData +{ NodeID parent; - /* explicit */ _HeapData( NodeID p ) : parent(p) { } + /* explicit */ HeapData(NodeID p) : parent(p) {} }; // typedef StaticGraph QueryGraph; -struct SearchEngineData { - typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage > QueryHeap; +struct SearchEngineData +{ + typedef BinaryHeap> QueryHeap; typedef boost::thread_specific_ptr SearchEngineHeapPtr; static SearchEngineHeapPtr forwardHeap; diff --git a/DataStructures/StaticGraph.h b/DataStructures/StaticGraph.h index 8997402b7..a200f6623 100644 --- a/DataStructures/StaticGraph.h +++ b/DataStructures/StaticGraph.h @@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef STATICGRAPH_H_INCLUDED -#define STATICGRAPH_H_INCLUDED +#ifndef STATIC_GRAPH_H +#define STATIC_GRAPH_H #include "../DataStructures/Percent.h" #include "../DataStructures/SharedMemoryVectorWrapper.h" @@ -34,90 +34,107 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../typedefs.h" #include +#include #include -template< typename EdgeDataT, bool UseSharedMemory = false> -class StaticGraph { -public: +template class StaticGraph +{ + public: typedef NodeID NodeIterator; typedef NodeID EdgeIterator; typedef EdgeDataT EdgeData; - class InputEdge { - public: + class InputEdge + { + public: EdgeDataT data; NodeIterator source; NodeIterator target; - bool operator<( const InputEdge& right ) const { - if ( source != right.source ) { + bool operator<(const InputEdge &right) const + { + if (source != right.source) + { return source < right.source; } return target < right.target; } }; - struct _StrNode { - //index of the first edge + struct NodeArrayEntry + { + // index of the first edge EdgeIterator firstEdge; }; - struct _StrEdge { + struct EdgeArrayEntry + { NodeID target; EdgeDataT data; }; - StaticGraph( const int nodes, std::vector< InputEdge > &graph ) { - std::sort( graph.begin(), graph.end() ); - _numNodes = nodes; - _numEdges = ( EdgeIterator ) graph.size(); - _nodes.resize( _numNodes + 1); + StaticGraph(const int nodes, std::vector &graph) + { + std::sort(graph.begin(), graph.end()); + number_of_nodes = nodes; + number_of_edges = (EdgeIterator)graph.size(); + node_array.resize(number_of_nodes + 1); EdgeIterator edge = 0; EdgeIterator position = 0; - for ( NodeIterator node = 0; node <= _numNodes; ++node ) { + for (NodeIterator node = 0; node <= number_of_nodes; ++node) + { EdgeIterator lastEdge = edge; - while ( edge < _numEdges && graph[edge].source == node ) + while (edge < number_of_edges && graph[edge].source == node) ++edge; - _nodes[node].firstEdge = position; //=edge - position += edge - lastEdge; //remove + node_array[node].firstEdge = position; //=edge + position += edge - lastEdge; // remove } - _edges.resize( position ); //(edge) + edge_array.resize(position); //(edge) edge = 0; - for ( NodeIterator node = 0; node < _numNodes; ++node ) { - for ( EdgeIterator i = _nodes[node].firstEdge, e = _nodes[node+1].firstEdge; i != e; ++i ) { - _edges[i].target = graph[edge].target; - _edges[i].data = graph[edge].data; - assert(_edges[i].data.distance > 0); + for (NodeIterator node = 0; node < number_of_nodes; ++node) + { + EdgeIterator e = node_array[node + 1].firstEdge; + for (EdgeIterator i = node_array[node].firstEdge; i != e; ++i) + { + edge_array[i].target = graph[edge].target; + edge_array[i].data = graph[edge].data; + assert(edge_array[i].data.distance > 0); edge++; } } } - StaticGraph( - typename ShM<_StrNode, UseSharedMemory>::vector & nodes, - typename ShM<_StrEdge, UseSharedMemory>::vector & edges - ) { - _numNodes = nodes.size()-1; - _numEdges = edges.size(); + StaticGraph(typename ShM::vector &nodes, + typename ShM::vector &edges) + { + number_of_nodes = nodes.size() - 1; + number_of_edges = edges.size(); - _nodes.swap(nodes); - _edges.swap(edges); + node_array.swap(nodes); + edge_array.swap(edges); #ifndef NDEBUG Percent p(GetNumberOfNodes()); - for(unsigned u = 0; u < GetNumberOfNodes(); ++u) { - for(unsigned eid = BeginEdges(u); eid < EndEdges(u); ++eid) { + for (unsigned u = 0; u < GetNumberOfNodes(); ++u) + { + for (unsigned eid = BeginEdges(u); eid < EndEdges(u); ++eid) + { unsigned v = GetTarget(eid); - EdgeData & data = GetEdgeData(eid); - if(data.shortcut) { + EdgeData &data = GetEdgeData(eid); + if (data.shortcut) + { const EdgeID first_edge_id = FindEdgeInEitherDirection(u, data.id); if (SPECIAL_EDGEID == first_edge_id) { - SimpleLogger().Write(logWARNING) << "cannot find first segment of edge (" << u << "," << data.id << "," << v << "), eid: " << eid; + SimpleLogger().Write(logWARNING) << "cannot find first segment of edge (" + << u << "," << data.id << "," << v + << "), eid: " << eid; BOOST_ASSERT(false); } const EdgeID second_edge_id = FindEdgeInEitherDirection(data.id, v); if (SPECIAL_EDGEID == second_edge_id) { - SimpleLogger().Write(logWARNING) << "cannot find second segment of edge (" << u << "," << data.id << "," << v << "), eid: " << eid; + SimpleLogger().Write(logWARNING) << "cannot find second segment of edge (" + << u << "," << data.id << "," << v + << "), eid: " << eid; BOOST_ASSERT(false); } } @@ -127,75 +144,76 @@ public: #endif } - unsigned GetNumberOfNodes() const { - return _numNodes; + unsigned GetNumberOfNodes() const { return number_of_nodes; } + + unsigned GetNumberOfEdges() const { return number_of_edges; } + + unsigned GetOutDegree(const NodeIterator n) const { return BeginEdges(n) - EndEdges(n) - 1; } + + inline NodeIterator GetTarget(const EdgeIterator e) const + { + return NodeIterator(edge_array[e].target); } - unsigned GetNumberOfEdges() const { - return _numEdges; + inline EdgeDataT &GetEdgeData(const EdgeIterator e) { return edge_array[e].data; } + + const EdgeDataT &GetEdgeData(const EdgeIterator e) const { return edge_array[e].data; } + + EdgeIterator BeginEdges(const NodeIterator n) const + { + return EdgeIterator(node_array.at(n).firstEdge); } - unsigned GetOutDegree( const NodeIterator n ) const { - return BeginEdges(n)-EndEdges(n) - 1; + EdgeIterator EndEdges(const NodeIterator n) const + { + return EdgeIterator(node_array.at(n + 1).firstEdge); } - inline NodeIterator GetTarget( const EdgeIterator e ) const { - return NodeIterator( _edges[e].target ); - } - - inline EdgeDataT &GetEdgeData( const EdgeIterator e ) { - return _edges[e].data; - } - - const EdgeDataT &GetEdgeData( const EdgeIterator e ) const { - return _edges[e].data; - } - - EdgeIterator BeginEdges( const NodeIterator n ) const { - return EdgeIterator( _nodes.at(n).firstEdge ); - } - - EdgeIterator EndEdges( const NodeIterator n ) const { - return EdgeIterator( _nodes.at(n+1).firstEdge ); - } - - //searches for a specific edge - EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const { - EdgeIterator smallestEdge = SPECIAL_EDGEID; - EdgeWeight smallestWeight = INVALID_EDGE_WEIGHT; - for ( EdgeIterator edge = BeginEdges( from ); edge < EndEdges(from); edge++ ) { + // searches for a specific edge + EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const + { + EdgeIterator smallest_edge = SPECIAL_EDGEID; + EdgeWeight smallest_weight = INVALID_EDGE_WEIGHT; + for (EdgeIterator edge = BeginEdges(from); edge < EndEdges(from); edge++) + { const NodeID target = GetTarget(edge); const EdgeWeight weight = GetEdgeData(edge).distance; - if(target == to && weight < smallestWeight) { - smallestEdge = edge; smallestWeight = weight; + if (target == to && weight < smallest_weight) + { + smallest_edge = edge; + smallest_weight = weight; } } - return smallestEdge; + return smallest_edge; } - EdgeIterator FindEdgeInEitherDirection( const NodeIterator from, const NodeIterator to ) const { - EdgeIterator tmp = FindEdge( from, to ); - return (UINT_MAX != tmp ? tmp : FindEdge( to, from )); + EdgeIterator FindEdgeInEitherDirection(const NodeIterator from, const NodeIterator to) const + { + EdgeIterator tmp = FindEdge(from, to); + return (SPECIAL_NODEID != tmp ? tmp : FindEdge(to, from)); } - EdgeIterator FindEdgeIndicateIfReverse( const NodeIterator from, const NodeIterator to, bool & result ) const { - EdgeIterator tmp = FindEdge( from, to ); - if(UINT_MAX == tmp) { - tmp = FindEdge( to, from ); - if(UINT_MAX != tmp) { + EdgeIterator + FindEdgeIndicateIfReverse(const NodeIterator from, const NodeIterator to, bool &result) const + { + EdgeIterator current_iterator = FindEdge(from, to); + if (SPECIAL_NODEID == current_iterator) + { + current_iterator = FindEdge(to, from); + if (SPECIAL_NODEID != current_iterator) + { result = true; } } - return tmp; + return current_iterator; } -private: + private: + NodeIterator number_of_nodes; + EdgeIterator number_of_edges; - NodeIterator _numNodes; - EdgeIterator _numEdges; - - typename ShM< _StrNode, UseSharedMemory >::vector _nodes; - typename ShM< _StrEdge, UseSharedMemory >::vector _edges; + typename ShM::vector node_array; + typename ShM::vector edge_array; }; -#endif // STATICGRAPH_H_INCLUDED +#endif // STATIC_GRAPH_H diff --git a/Server/DataStructures/InternalDataFacade.h b/Server/DataStructures/InternalDataFacade.h index e82ae356d..3e03b53ed 100644 --- a/Server/DataStructures/InternalDataFacade.h +++ b/Server/DataStructures/InternalDataFacade.h @@ -102,8 +102,8 @@ private: } void LoadGraph(const boost::filesystem::path & hsgr_path) { - typename ShM::vector node_list; - typename ShM::vector edge_list; + typename ShM::vector node_list; + typename ShM::vector edge_list; SimpleLogger().Write() << "loading graph from " << hsgr_path.string(); diff --git a/Server/DataStructures/SharedDataFacade.h b/Server/DataStructures/SharedDataFacade.h index 21f2cb99a..de28a3c76 100644 --- a/Server/DataStructures/SharedDataFacade.h +++ b/Server/DataStructures/SharedDataFacade.h @@ -49,12 +49,12 @@ class SharedDataFacade : public BaseDataFacade { private: typedef EdgeDataT EdgeData; - typedef BaseDataFacade super; - typedef StaticGraph QueryGraph; - typedef typename StaticGraph::_StrNode GraphNode; - typedef typename StaticGraph::_StrEdge GraphEdge; - typedef typename QueryGraph::InputEdge InputEdge; - typedef typename super::RTreeLeaf RTreeLeaf; + typedef BaseDataFacade super; + typedef StaticGraph QueryGraph; + typedef typename StaticGraph::NodeArrayEntry GraphNode; + typedef typename StaticGraph::EdgeArrayEntry GraphEdge; + typedef typename QueryGraph::InputEdge InputEdge; + typedef typename super::RTreeLeaf RTreeLeaf; typedef typename StaticRTree::vector, true>::TreeNode RTreeNode; SharedDataLayout * data_layout; diff --git a/Server/DataStructures/SharedDataType.h b/Server/DataStructures/SharedDataType.h index 5efb19f3b..e433f9246 100644 --- a/Server/DataStructures/SharedDataType.h +++ b/Server/DataStructures/SharedDataType.h @@ -106,20 +106,20 @@ struct SharedDataLayout { uint64_t GetSizeOfLayout() const { uint64_t result = - (name_index_list_size * sizeof(unsigned) ) + - (name_char_list_size * sizeof(char) ) + - (name_id_list_size * sizeof(unsigned) ) + - (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + - (timestamp_length * sizeof(char) ) + - (coordinate_list_size * sizeof(FixedPointCoordinate) ) + - (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + - (r_search_tree_size * sizeof(RTreeNode) ) + - (geometries_indicators/32 + 1) * sizeof(unsigned) + - (geometries_index_list_size * sizeof(unsigned) ) + - (geometries_list_size * sizeof(unsigned) ) + - sizeof(checksum) + + (name_index_list_size * sizeof(unsigned) ) + + (name_char_list_size * sizeof(char) ) + + (name_id_list_size * sizeof(unsigned) ) + + (via_node_list_size * sizeof(NodeID) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + + (timestamp_length * sizeof(char) ) + + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + + (turn_instruction_list_size * sizeof(TurnInstructionsClass) ) + + (r_search_tree_size * sizeof(RTreeNode) ) + + (geometries_indicators/32 + 1) * sizeof(unsigned) + + (geometries_index_list_size * sizeof(unsigned) ) + + (geometries_list_size * sizeof(unsigned) ) + + sizeof(checksum) + 1024*sizeof(char); return result; } @@ -159,7 +159,7 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) ; + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) ; return result; } uint64_t GetTimeStampOffset() const { @@ -168,8 +168,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)); + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry)); return result; } uint64_t GetCoordinateListOffset() const { @@ -178,8 +178,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry)) + (timestamp_length * sizeof(char) ); return result; } @@ -189,8 +189,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry)) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate)); return result; @@ -201,8 +201,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)); @@ -214,8 +214,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + @@ -229,8 +229,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + @@ -245,8 +245,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + @@ -261,8 +261,8 @@ struct SharedDataLayout { (name_char_list_size * sizeof(char) ) + (name_id_list_size * sizeof(unsigned) ) + (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) + + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) + (timestamp_length * sizeof(char) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + diff --git a/datastore.cpp b/datastore.cpp index abf4a39b1..63cfa9851 100644 --- a/datastore.cpp +++ b/datastore.cpp @@ -419,21 +419,21 @@ int main( const int argc, const char * argv[] ) tree_node_file.close(); // load the nodes of the search graph - QueryGraph::_StrNode * graph_node_list_ptr = (QueryGraph::_StrNode*)( + QueryGraph::NodeArrayEntry * graph_node_list_ptr = (QueryGraph::NodeArrayEntry*)( shared_memory_ptr + shared_layout_ptr->GetGraphNodeListOffset() ); hsgr_input_stream.read( (char*) graph_node_list_ptr, - shared_layout_ptr->graph_node_list_size*sizeof(QueryGraph::_StrNode) + shared_layout_ptr->graph_node_list_size*sizeof(QueryGraph::NodeArrayEntry) ); // load the edges of the search graph - QueryGraph::_StrEdge * graph_edge_list_ptr = (QueryGraph::_StrEdge *)( + QueryGraph::EdgeArrayEntry * graph_edge_list_ptr = (QueryGraph::EdgeArrayEntry *)( shared_memory_ptr + shared_layout_ptr->GetGraphEdgeListOffset() ); hsgr_input_stream.read( (char*) graph_edge_list_ptr, - shared_layout_ptr->graph_edge_list_size*sizeof(QueryGraph::_StrEdge) + shared_layout_ptr->graph_edge_list_size*sizeof(QueryGraph::EdgeArrayEntry) ); hsgr_input_stream.close(); diff --git a/prepare.cpp b/prepare.cpp index 8d51be46f..4eef07fc2 100644 --- a/prepare.cpp +++ b/prepare.cpp @@ -345,7 +345,7 @@ int main (int argc, char *argv[]) { SimpleLogger().Write(logDEBUG) << "contracted graph has " << max_used_node_id << " nodes"; max_used_node_id+=1; - std::vector< StaticGraph::_StrNode > node_array; + std::vector< StaticGraph::NodeArrayEntry > node_array; node_array.resize( edgeBasedNodeNumber + 1); SimpleLogger().Write() << "Building node array"; @@ -381,14 +381,14 @@ int main (int argc, char *argv[]) { //serialize number of edges hsgr_output_stream.write((char*) &contracted_edge_count, sizeof(unsigned)); //serialize all nodes - hsgr_output_stream.write((char*) &node_array[0], sizeof(StaticGraph::_StrNode)*node_array_size); + hsgr_output_stream.write((char*) &node_array[0], sizeof(StaticGraph::NodeArrayEntry)*node_array_size); //serialize all edges SimpleLogger().Write() << "Building edge array"; edge = 0; int usedEdgeCounter = 0; - StaticGraph::_StrEdge currentEdge; + StaticGraph::EdgeArrayEntry currentEdge; for (unsigned edge = 0; edge < contractedEdgeList.size(); ++edge) { // no eigen loops @@ -409,7 +409,7 @@ int main (int argc, char *argv[]) { "Failed at adjacency list of node " << contractedEdgeList[edge].source << "/" << node_array.size()-1; return 1; } - hsgr_output_stream.write((char*) ¤tEdge, sizeof(StaticGraph::_StrEdge)); + hsgr_output_stream.write((char*) ¤tEdge, sizeof(StaticGraph::EdgeArrayEntry)); ++usedEdgeCounter; } hsgr_output_stream.close();