From d13cd4d4b39073f6db1cef96e9326bfa95f5a4f8 Mon Sep 17 00:00:00 2001 From: Patrick Niklaus Date: Thu, 8 May 2014 23:07:16 +0200 Subject: [PATCH] Apply clang-format on Contractor/ --- Contractor/Contractor.h | 804 ++++++++++++++++----------- Contractor/EdgeBasedGraphFactory.cpp | 701 ++++++++++++----------- Contractor/EdgeBasedGraphFactory.h | 98 ++-- Contractor/GeometryCompressor.cpp | 9 +- Contractor/GeometryCompressor.h | 2 +- Contractor/TemporaryStorage.cpp | 134 +++-- Contractor/TemporaryStorage.h | 55 +- 7 files changed, 968 insertions(+), 835 deletions(-) diff --git a/Contractor/Contractor.h b/Contractor/Contractor.h index 5d103f8a9..df8e6095e 100644 --- a/Contractor/Contractor.h +++ b/Contractor/Contractor.h @@ -48,107 +48,139 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -class Contractor { +class Contractor +{ -private: - struct ContractorEdgeData { - ContractorEdgeData() : - distance(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0), originalViaNodeID(false) {} - ContractorEdgeData( unsigned _distance, unsigned _originalEdges, unsigned _id, bool _shortcut, bool _forward, bool _backward) : - distance(_distance), id(_id), originalEdges(std::min((unsigned)1<<28, _originalEdges) ), shortcut(_shortcut), forward(_forward), backward(_backward), originalViaNodeID(false) {} + private: + struct ContractorEdgeData + { + ContractorEdgeData() + : distance(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0), + originalViaNodeID(false) + { + } + ContractorEdgeData(unsigned _distance, + unsigned _originalEdges, + unsigned _id, + bool _shortcut, + bool _forward, + bool _backward) + : distance(_distance), id(_id), + originalEdges(std::min((unsigned)1 << 28, _originalEdges)), shortcut(_shortcut), + forward(_forward), backward(_backward), originalViaNodeID(false) + { + } unsigned distance; unsigned id; - unsigned originalEdges:28; - bool shortcut:1; - bool forward:1; - bool backward:1; - bool originalViaNodeID:1; + unsigned originalEdges : 28; + bool shortcut : 1; + bool forward : 1; + bool backward : 1; + bool originalViaNodeID : 1; } data; - struct _HeapData { + struct _HeapData + { short hop; bool target; _HeapData() : hop(0), target(false) {} - _HeapData( short h, bool t ) : hop(h), target(t) {} + _HeapData(short h, bool t) : hop(h), target(t) {} }; - typedef DynamicGraph< ContractorEdgeData > _DynamicGraph; + typedef DynamicGraph _DynamicGraph; // typedef BinaryHeap< NodeID, NodeID, int, _HeapData, ArrayStorage > _Heap; - typedef BinaryHeap< NodeID, NodeID, int, _HeapData, XORFastHashStorage > _Heap; + typedef BinaryHeap> _Heap; typedef _DynamicGraph::InputEdge _ContractorEdge; - struct _ThreadData { + struct _ThreadData + { _Heap heap; - std::vector< _ContractorEdge > insertedEdges; - std::vector< NodeID > neighbours; - _ThreadData( NodeID nodes ): heap( nodes ) { } + std::vector<_ContractorEdge> insertedEdges; + std::vector neighbours; + _ThreadData(NodeID nodes) : heap(nodes) {} }; - struct _PriorityData { + struct _PriorityData + { int depth; - _PriorityData() : depth(0) { } + _PriorityData() : depth(0) {} }; - struct _ContractionInformation { + struct _ContractionInformation + { int edgesDeleted; int edgesAdded; int originalEdgesDeleted; int originalEdgesAdded; - _ContractionInformation() : edgesDeleted(0), edgesAdded(0), originalEdgesDeleted(0), originalEdgesAdded(0) {} + _ContractionInformation() + : edgesDeleted(0), edgesAdded(0), originalEdgesDeleted(0), originalEdgesAdded(0) + { + } }; - struct _RemainingNodeData { - _RemainingNodeData() : id (0), isIndependent(false) {} - NodeID id:31; - bool isIndependent:1; + struct _RemainingNodeData + { + _RemainingNodeData() : id(0), isIndependent(false) {} + NodeID id : 31; + bool isIndependent : 1; }; - struct _NodePartitionor { - inline bool operator()(_RemainingNodeData & nodeData ) const { + struct _NodePartitionor + { + inline bool operator()(_RemainingNodeData &nodeData) const + { return !nodeData.isIndependent; } }; -public: - - template - Contractor( int nodes, ContainerT& inputEdges) { - std::vector< _ContractorEdge > edges; - edges.reserve(inputEdges.size()*2); + public: + template Contractor(int nodes, ContainerT &inputEdges) + { + std::vector<_ContractorEdge> edges; + edges.reserve(inputEdges.size() * 2); temp_edge_counter = 0; typename ContainerT::deallocation_iterator diter = inputEdges.dbegin(); - typename ContainerT::deallocation_iterator dend = inputEdges.dend(); + typename ContainerT::deallocation_iterator dend = inputEdges.dend(); _ContractorEdge newEdge; - while(diter!=dend) { + while (diter != dend) + { newEdge.source = diter->source(); newEdge.target = diter->target(); - newEdge.data = ContractorEdgeData( (std::max)((int)diter->weight(), 1 ), 1, diter->id(), false, diter->isForward(), diter->isBackward()); - BOOST_ASSERT_MSG( newEdge.data.distance > 0, "edge distance < 1" ); + newEdge.data = ContractorEdgeData((std::max)((int)diter->weight(), 1), + 1, + diter->id(), + false, + diter->isForward(), + diter->isBackward()); + BOOST_ASSERT_MSG(newEdge.data.distance > 0, "edge distance < 1"); #ifndef NDEBUG - if ( newEdge.data.distance > 24 * 60 * 60 * 10 ) { - SimpleLogger().Write(logWARNING) << - "Edge weight large -> " << newEdge.data.distance; + if (newEdge.data.distance > 24 * 60 * 60 * 10) + { + SimpleLogger().Write(logWARNING) << "Edge weight large -> " + << newEdge.data.distance; } #endif - edges.push_back( newEdge ); - std::swap( newEdge.source, newEdge.target ); + edges.push_back(newEdge); + std::swap(newEdge.source, newEdge.target); newEdge.data.forward = diter->isBackward(); newEdge.data.backward = diter->isForward(); - edges.push_back( newEdge ); + edges.push_back(newEdge); ++diter; } - //clear input vector and trim the current set of edges with the well-known swap trick + // clear input vector and trim the current set of edges with the well-known swap trick inputEdges.clear(); - sort( edges.begin(), edges.end() ); + sort(edges.begin(), edges.end()); NodeID edge = 0; - for ( NodeID i = 0; i < edges.size(); ) { + for (NodeID i = 0; i < edges.size();) + { const NodeID source = edges[i].source; const NodeID target = edges[i].target; const NodeID id = edges[i].data.id; - //remove eigenloops - if ( source == target ) { + // remove eigenloops + if (source == target) + { i++; continue; } @@ -161,38 +193,51 @@ public: forwardEdge.data.shortcut = backwardEdge.data.shortcut = false; forwardEdge.data.id = backwardEdge.data.id = id; forwardEdge.data.originalEdges = backwardEdge.data.originalEdges = 1; - forwardEdge.data.distance = backwardEdge.data.distance = std::numeric_limits< int >::max(); - //remove parallel edges - while ( i < edges.size() && edges[i].source == source && edges[i].target == target ) { - if ( edges[i].data.forward) { - forwardEdge.data.distance = std::min( edges[i].data.distance, forwardEdge.data.distance ); + forwardEdge.data.distance = backwardEdge.data.distance = + std::numeric_limits::max(); + // remove parallel edges + while (i < edges.size() && edges[i].source == source && edges[i].target == target) + { + if (edges[i].data.forward) + { + forwardEdge.data.distance = + std::min(edges[i].data.distance, forwardEdge.data.distance); } - if ( edges[i].data.backward) { - backwardEdge.data.distance = std::min( edges[i].data.distance, backwardEdge.data.distance ); + if (edges[i].data.backward) + { + backwardEdge.data.distance = + std::min(edges[i].data.distance, backwardEdge.data.distance); } ++i; } - //merge edges (s,t) and (t,s) into bidirectional edge - if ( forwardEdge.data.distance == backwardEdge.data.distance ) { - if ( (int)forwardEdge.data.distance != std::numeric_limits< int >::max() ) { + // merge edges (s,t) and (t,s) into bidirectional edge + if (forwardEdge.data.distance == backwardEdge.data.distance) + { + if ((int)forwardEdge.data.distance != std::numeric_limits::max()) + { forwardEdge.data.backward = true; edges[edge++] = forwardEdge; } - } else { //insert seperate edges - if ( ((int)forwardEdge.data.distance) != std::numeric_limits< int >::max() ) { + } + else + { // insert seperate edges + if (((int)forwardEdge.data.distance) != std::numeric_limits::max()) + { edges[edge++] = forwardEdge; } - if ( (int)backwardEdge.data.distance != std::numeric_limits< int >::max() ) { + if ((int)backwardEdge.data.distance != std::numeric_limits::max()) + { edges[edge++] = backwardEdge; } } } - std::cout << "merged " << edges.size() - edge << " edges out of " << edges.size() << std::endl; - edges.resize( edge ); - _graph = boost::make_shared<_DynamicGraph>( nodes, edges ); + std::cout << "merged " << edges.size() - edge << " edges out of " << edges.size() + << std::endl; + edges.resize(edge); + _graph = boost::make_shared<_DynamicGraph>(nodes, edges); edges.clear(); std::vector<_ContractorEdge>().swap(edges); - BOOST_ASSERT( 0 == edges.capacity() ); + BOOST_ASSERT(0 == edges.capacity()); // unsigned maxdegree = 0; // NodeID highestNode = 0; // @@ -204,61 +249,74 @@ public: // } // } // - // SimpleLogger().Write() << "edges at node with id " << highestNode << " has degree " << maxdegree; - // for(unsigned i = _graph->BeginEdges(highestNode); i < _graph->EndEdges(highestNode); ++i) { - // SimpleLogger().Write() << " ->(" << highestNode << "," << _graph->GetTarget(i) << "); via: " << _graph->GetEdgeData(i).via; + // SimpleLogger().Write() << "edges at node with id " << highestNode << " has degree + // " << maxdegree; + // for(unsigned i = _graph->BeginEdges(highestNode); i < + // _graph->EndEdges(highestNode); ++i) { + // SimpleLogger().Write() << " ->(" << highestNode << "," << _graph->GetTarget(i) + // << "); via: " << _graph->GetEdgeData(i).via; // } - //Create temporary file + // Create temporary file // GetTemporaryFileName(temporaryEdgeStorageFilename); edge_storage_slot = TemporaryStorage::GetInstance().AllocateSlot(); std::cout << "contractor finished initalization" << std::endl; } - ~Contractor() { - //Delete temporary file + ~Contractor() + { + // Delete temporary file // remove(temporaryEdgeStorageFilename.c_str()); TemporaryStorage::GetInstance().DeallocateSlot(edge_storage_slot); } - void Run() { + void Run() + { const NodeID numberOfNodes = _graph->GetNumberOfNodes(); - Percent p (numberOfNodes); + Percent p(numberOfNodes); const unsigned maxThreads = omp_get_max_threads(); - std::vector < _ThreadData* > threadData; - for ( unsigned threadNum = 0; threadNum < maxThreads; ++threadNum ) { - threadData.push_back( new _ThreadData( numberOfNodes ) ); + std::vector<_ThreadData *> threadData; + for (unsigned threadNum = 0; threadNum < maxThreads; ++threadNum) + { + threadData.push_back(new _ThreadData(numberOfNodes)); } std::cout << "Contractor is using " << maxThreads << " threads" << std::endl; NodeID numberOfContractedNodes = 0; - std::vector< _RemainingNodeData > remainingNodes( numberOfNodes ); - std::vector< float > nodePriority( numberOfNodes ); - std::vector< _PriorityData > nodeData( numberOfNodes ); + std::vector<_RemainingNodeData> remainingNodes(numberOfNodes); + std::vector nodePriority(numberOfNodes); + std::vector<_PriorityData> nodeData(numberOfNodes); - //initialize the variables -#pragma omp parallel for schedule ( guided ) - for ( int x = 0; x < ( int ) numberOfNodes; ++x ) { +// initialize the variables +#pragma omp parallel for schedule(guided) + for (int x = 0; x < (int)numberOfNodes; ++x) + { remainingNodes[x].id = x; } std::cout << "initializing elimination PQ ..." << std::flush; #pragma omp parallel { - _ThreadData* data = threadData[omp_get_thread_num()]; -#pragma omp parallel for schedule ( guided ) - for ( int x = 0; x < ( int ) numberOfNodes; ++x ) { - nodePriority[x] = _Evaluate( data, &nodeData[x], x ); + _ThreadData *data = threadData[omp_get_thread_num()]; +#pragma omp parallel for schedule(guided) + for (int x = 0; x < (int)numberOfNodes; ++x) + { + nodePriority[x] = _Evaluate(data, &nodeData[x], x); } } - std::cout << "ok" << std::endl << "preprocessing " << numberOfNodes << " nodes ..." << std::flush; + std::cout << "ok" << std::endl << "preprocessing " << numberOfNodes << " nodes ..." + << std::flush; bool flushedContractor = false; - while ( numberOfNodes > 2 && numberOfContractedNodes < numberOfNodes ) { - if(!flushedContractor && (numberOfContractedNodes > (numberOfNodes*0.65) ) ){ - DeallocatingVector<_ContractorEdge> newSetOfEdges; //this one is not explicitely cleared since it goes out of scope anywa + while (numberOfNodes > 2 && numberOfContractedNodes < numberOfNodes) + { + if (!flushedContractor && (numberOfContractedNodes > (numberOfNodes * 0.65))) + { + DeallocatingVector<_ContractorEdge> newSetOfEdges; // this one is not explicitely + // cleared since it goes out of + // scope anywa std::cout << " [flush " << numberOfContractedNodes << " nodes] " << std::flush; //Delete old heap data to free memory that we need for the coming operations @@ -267,113 +325,129 @@ public: } threadData.clear(); - //Create new priority array + // Create new priority array std::vector newNodePriority(remainingNodes.size()); - //this map gives the old IDs from the new ones, necessary to get a consistent graph at the end of contraction + // this map gives the old IDs from the new ones, necessary to get a consistent graph + // at the end of contraction oldNodeIDFromNewNodeIDMap.resize(remainingNodes.size()); - //this map gives the new IDs from the old ones, necessary to remap targets from the remaining graph + // this map gives the new IDs from the old ones, necessary to remap targets from the + // remaining graph std::vector newNodeIDFromOldNodeIDMap(numberOfNodes, UINT_MAX); - //build forward and backward renumbering map and remap ids in remainingNodes and Priorities. - for(unsigned newNodeID = 0; newNodeID < remainingNodes.size(); ++newNodeID) { - //create renumbering maps in both directions + // build forward and backward renumbering map and remap ids in remainingNodes and + // Priorities. + for (unsigned newNodeID = 0; newNodeID < remainingNodes.size(); ++newNodeID) + { + // create renumbering maps in both directions oldNodeIDFromNewNodeIDMap[newNodeID] = remainingNodes[newNodeID].id; newNodeIDFromOldNodeIDMap[remainingNodes[newNodeID].id] = newNodeID; newNodePriority[newNodeID] = nodePriority[remainingNodes[newNodeID].id]; remainingNodes[newNodeID].id = newNodeID; } - TemporaryStorage & tempStorage = TemporaryStorage::GetInstance(); - //walk over all nodes - for(unsigned i = 0; i < _graph->GetNumberOfNodes(); ++i) { + TemporaryStorage &tempStorage = TemporaryStorage::GetInstance(); + // walk over all nodes + for (unsigned i = 0; i < _graph->GetNumberOfNodes(); ++i) + { const NodeID start = i; - for(_DynamicGraph::EdgeIterator currentEdge = _graph->BeginEdges(start); currentEdge < _graph->EndEdges(start); ++currentEdge) { - _DynamicGraph::EdgeData & data = _graph->GetEdgeData(currentEdge); + for (_DynamicGraph::EdgeIterator currentEdge = _graph->BeginEdges(start); + currentEdge < _graph->EndEdges(start); + ++currentEdge) + { + _DynamicGraph::EdgeData &data = _graph->GetEdgeData(currentEdge); const NodeID target = _graph->GetTarget(currentEdge); - if(UINT_MAX == newNodeIDFromOldNodeIDMap[i] ){ - //Save edges of this node w/o renumbering. - tempStorage.WriteToSlot(edge_storage_slot, (char*)&start, sizeof(NodeID)); - tempStorage.WriteToSlot(edge_storage_slot, (char*)&target, sizeof(NodeID)); - tempStorage.WriteToSlot(edge_storage_slot, (char*)&data, sizeof(_DynamicGraph::EdgeData)); + if (UINT_MAX == newNodeIDFromOldNodeIDMap[i]) + { + // Save edges of this node w/o renumbering. + tempStorage.WriteToSlot( + edge_storage_slot, (char *)&start, sizeof(NodeID)); + tempStorage.WriteToSlot( + edge_storage_slot, (char *)&target, sizeof(NodeID)); + tempStorage.WriteToSlot( + edge_storage_slot, (char *)&data, sizeof(_DynamicGraph::EdgeData)); ++temp_edge_counter; - } else { - //node is not yet contracted. - //add (renumbered) outgoing edges to new DynamicGraph. + } + else + { + // node is not yet contracted. + // add (renumbered) outgoing edges to new DynamicGraph. _ContractorEdge newEdge; newEdge.source = newNodeIDFromOldNodeIDMap[start]; newEdge.target = newNodeIDFromOldNodeIDMap[target]; newEdge.data = data; newEdge.data.originalViaNodeID = true; - BOOST_ASSERT_MSG( - UINT_MAX != newNodeIDFromOldNodeIDMap[start], - "new start id not resolveable" - ); - BOOST_ASSERT_MSG( - UINT_MAX != newNodeIDFromOldNodeIDMap[target], - "new target id not resolveable" - ); + BOOST_ASSERT_MSG(UINT_MAX != newNodeIDFromOldNodeIDMap[start], + "new start id not resolveable"); + BOOST_ASSERT_MSG(UINT_MAX != newNodeIDFromOldNodeIDMap[target], + "new target id not resolveable"); newSetOfEdges.push_back(newEdge); } } } - //Delete map from old NodeIDs to new ones. + // Delete map from old NodeIDs to new ones. std::vector().swap(newNodeIDFromOldNodeIDMap); - //Replace old priorities array by new one + // Replace old priorities array by new one nodePriority.swap(newNodePriority); - //Delete old nodePriority vector + // Delete old nodePriority vector std::vector().swap(newNodePriority); - //old Graph is removed + // old Graph is removed _graph.reset(); - //create new graph + // create new graph std::sort(newSetOfEdges.begin(), newSetOfEdges.end()); _graph = boost::make_shared<_DynamicGraph>(remainingNodes.size(), newSetOfEdges); newSetOfEdges.clear(); flushedContractor = true; - //INFO: MAKE SURE THIS IS THE LAST OPERATION OF THE FLUSH! - //reinitialize heaps and ThreadData objects with appropriate size - for ( unsigned threadNum = 0; threadNum < maxThreads; ++threadNum ) { - threadData.push_back( new _ThreadData( _graph->GetNumberOfNodes() ) ); + // INFO: MAKE SURE THIS IS THE LAST OPERATION OF THE FLUSH! + // reinitialize heaps and ThreadData objects with appropriate size + for (unsigned threadNum = 0; threadNum < maxThreads; ++threadNum) + { + threadData.push_back(new _ThreadData(_graph->GetNumberOfNodes())); } } - const int last = ( int ) remainingNodes.size(); + const int last = (int)remainingNodes.size(); #pragma omp parallel { - //determine independent node set - _ThreadData* const data = threadData[omp_get_thread_num()]; -#pragma omp for schedule ( guided ) - for ( int i = 0; i < last; ++i ) { + // determine independent node set + _ThreadData *const data = threadData[omp_get_thread_num()]; +#pragma omp for schedule(guided) + for (int i = 0; i < last; ++i) + { const NodeID node = remainingNodes[i].id; - remainingNodes[i].isIndependent = _IsIndependent( nodePriority/*, nodeData*/, data, node ); + remainingNodes[i].isIndependent = + _IsIndependent(nodePriority /*, nodeData*/, data, node); } } _NodePartitionor functor; - const std::vector < _RemainingNodeData >::const_iterator first = stable_partition( remainingNodes.begin(), remainingNodes.end(), functor ); + const std::vector<_RemainingNodeData>::const_iterator first = + stable_partition(remainingNodes.begin(), remainingNodes.end(), functor); const int firstIndependent = first - remainingNodes.begin(); - //contract independent nodes +// contract independent nodes #pragma omp parallel { - _ThreadData* data = threadData[omp_get_thread_num()]; -#pragma omp for schedule ( guided ) nowait - for ( int position = firstIndependent ; position < last; ++position ) { + _ThreadData *data = threadData[omp_get_thread_num()]; +#pragma omp for schedule(guided) nowait + for (int position = firstIndependent; position < last; ++position) + { NodeID x = remainingNodes[position].id; - _Contract< false > ( data, x ); - //nodePriority[x] = -1; + _Contract(data, x); + // nodePriority[x] = -1; } - std::sort( data->insertedEdges.begin(), data->insertedEdges.end() ); + std::sort(data->insertedEdges.begin(), data->insertedEdges.end()); } #pragma omp parallel { - _ThreadData* data = threadData[omp_get_thread_num()]; -#pragma omp for schedule ( guided ) nowait - for ( int position = firstIndependent ; position < last; ++position ) { + _ThreadData *data = threadData[omp_get_thread_num()]; +#pragma omp for schedule(guided) nowait + for (int position = firstIndependent; position < last; ++position) + { NodeID x = remainingNodes[position].id; - _DeleteIncomingEdges( data, x ); + _DeleteIncomingEdges(data, x); } } //insert new edges @@ -383,42 +457,45 @@ public: _DynamicGraph::EdgeIterator currentEdgeID = _graph->FindEdge(edge.source, edge.target); if(currentEdgeID < _graph->EndEdges(edge.source) ) { _DynamicGraph::EdgeData & currentEdgeData = _graph->GetEdgeData(currentEdgeID); - if( currentEdgeData.shortcut && - edge.data.forward == currentEdgeData.forward && - edge.data.backward == currentEdgeData.backward && - edge.data.distance < currentEdgeData.distance - ) { + if(currentEdgeData.shortcut && + edge.data.forward == currentEdgeData.forward && + edge.data.backward == currentEdgeData.backward && + edge.data.distance < currentEdgeData.distance) + { // found a duplicate edge with smaller weight, update it. currentEdgeData = edge.data; - // currentEdgeData.distance = std::min(currentEdgeData.distance, edge.data.distance); + // currentEdgeData.distance = std::min(currentEdgeData.distance, + // edge.data.distance); continue; } } - _graph->InsertEdge( edge.source, edge.target, edge.data ); + _graph->InsertEdge(edge.source, edge.target, edge.data); } data.insertedEdges.clear(); } - //update priorities +// update priorities #pragma omp parallel { - _ThreadData* data = threadData[omp_get_thread_num()]; -#pragma omp for schedule ( guided ) nowait - for ( int position = firstIndependent ; position < last; ++position ) { + _ThreadData *data = threadData[omp_get_thread_num()]; +#pragma omp for schedule(guided) nowait + for (int position = firstIndependent; position < last; ++position) + { NodeID x = remainingNodes[position].id; - _UpdateNeighbours( nodePriority, nodeData, data, x ); + _UpdateNeighbours(nodePriority, nodeData, data, x); } } - //remove contracted nodes from the pool + // remove contracted nodes from the pool numberOfContractedNodes += last - firstIndependent; - remainingNodes.resize( firstIndependent ); - std::vector< _RemainingNodeData>( remainingNodes ).swap( remainingNodes ); + remainingNodes.resize(firstIndependent); + std::vector<_RemainingNodeData>(remainingNodes).swap(remainingNodes); // unsigned maxdegree = 0; // unsigned avgdegree = 0; // unsigned mindegree = UINT_MAX; // unsigned quaddegree = 0; // // for(unsigned i = 0; i < remainingNodes.size(); ++i) { - // unsigned degree = _graph->EndEdges(remainingNodes[i].first) - _graph->BeginEdges(remainingNodes[i].first); + // unsigned degree = _graph->EndEdges(remainingNodes[i].first) - + // _graph->BeginEdges(remainingNodes[i].first); // if(degree > maxdegree) // maxdegree = degree; // if(degree < mindegree) @@ -431,7 +508,9 @@ public: // avgdegree /= std::max((unsigned)1,(unsigned)remainingNodes.size() ); // quaddegree /= std::max((unsigned)1,(unsigned)remainingNodes.size() ); // - // SimpleLogger().Write() << "rest: " << remainingNodes.size() << ", max: " << maxdegree << ", min: " << mindegree << ", avg: " << avgdegree << ", quad: " << quaddegree; + // SimpleLogger().Write() << "rest: " << remainingNodes.size() << ", max: " + // << maxdegree << ", min: " << mindegree << ", avg: " << avgdegree << ", + // quad: " << quaddegree; p.printStatus(numberOfContractedNodes); } @@ -441,225 +520,283 @@ public: threadData.clear(); } - template< class Edge > - inline void GetEdges( DeallocatingVector< Edge >& edges ) { - Percent p (_graph->GetNumberOfNodes()); + template inline void GetEdges(DeallocatingVector &edges) + { + Percent p(_graph->GetNumberOfNodes()); SimpleLogger().Write() << "Getting edges of minimized graph"; NodeID numberOfNodes = _graph->GetNumberOfNodes(); - if(_graph->GetNumberOfNodes()) { + if (_graph->GetNumberOfNodes()) + { Edge newEdge; - for ( NodeID node = 0; node < numberOfNodes; ++node ) { + for (NodeID node = 0; node < numberOfNodes; ++node) + { p.printStatus(node); - for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge < endEdges; ++edge ) { - const NodeID target = _graph->GetTarget( edge ); - const _DynamicGraph::EdgeData& data = _graph->GetEdgeData( edge ); - if( !oldNodeIDFromNewNodeIDMap.empty() ) { + for (_DynamicGraph::EdgeIterator edge = _graph->BeginEdges(node), + endEdges = _graph->EndEdges(node); + edge < endEdges; + ++edge) + { + const NodeID target = _graph->GetTarget(edge); + const _DynamicGraph::EdgeData &data = _graph->GetEdgeData(edge); + if (!oldNodeIDFromNewNodeIDMap.empty()) + { newEdge.source = oldNodeIDFromNewNodeIDMap[node]; newEdge.target = oldNodeIDFromNewNodeIDMap[target]; - } else { + } + else + { newEdge.source = node; newEdge.target = target; } - BOOST_ASSERT_MSG( - UINT_MAX != newEdge.source, - "Source id invalid" - ); - BOOST_ASSERT_MSG( - UINT_MAX != newEdge.target, - "Target id invalid" - ); + BOOST_ASSERT_MSG(UINT_MAX != newEdge.source, "Source id invalid"); + BOOST_ASSERT_MSG(UINT_MAX != newEdge.target, "Target id invalid"); newEdge.data.distance = data.distance; newEdge.data.shortcut = data.shortcut; - if( - !data.originalViaNodeID && - !oldNodeIDFromNewNodeIDMap.empty() - ) { + if (!data.originalViaNodeID && !oldNodeIDFromNewNodeIDMap.empty()) + { newEdge.data.id = oldNodeIDFromNewNodeIDMap[data.id]; - } else { + } + else + { newEdge.data.id = data.id; } - BOOST_ASSERT_MSG( - newEdge.data.id != INT_MAX, //2^31 - "edge id invalid" - ); + BOOST_ASSERT_MSG(newEdge.data.id != INT_MAX, // 2^31 + "edge id invalid"); newEdge.data.forward = data.forward; newEdge.data.backward = data.backward; - edges.push_back( newEdge ); + edges.push_back(newEdge); } } } _graph.reset(); std::vector().swap(oldNodeIDFromNewNodeIDMap); - BOOST_ASSERT( 0 == oldNodeIDFromNewNodeIDMap.capacity() ); + BOOST_ASSERT(0 == oldNodeIDFromNewNodeIDMap.capacity()); - TemporaryStorage & tempStorage = TemporaryStorage::GetInstance(); - //loads edges of graph before renumbering, no need for further numbering action. + TemporaryStorage &tempStorage = TemporaryStorage::GetInstance(); + // loads edges of graph before renumbering, no need for further numbering action. NodeID start; NodeID target; _DynamicGraph::EdgeData data; Edge restored_edge; - for(unsigned i = 0; i < temp_edge_counter; ++i) { - tempStorage.ReadFromSlot(edge_storage_slot, (char*)&start, sizeof(NodeID)); - tempStorage.ReadFromSlot(edge_storage_slot, (char*)&target, sizeof(NodeID)); - tempStorage.ReadFromSlot(edge_storage_slot, (char*)&data, sizeof(_DynamicGraph::EdgeData)); - restored_edge.source = start; + for (unsigned i = 0; i < temp_edge_counter; ++i) + { + tempStorage.ReadFromSlot(edge_storage_slot, (char *)&start, sizeof(NodeID)); + tempStorage.ReadFromSlot(edge_storage_slot, (char *)&target, sizeof(NodeID)); + tempStorage.ReadFromSlot( + edge_storage_slot, (char *)&data, sizeof(_DynamicGraph::EdgeData)); + restored_edge.source = start; restored_edge.target = target; restored_edge.data.distance = data.distance; restored_edge.data.shortcut = data.shortcut; restored_edge.data.id = data.id; restored_edge.data.forward = data.forward; restored_edge.data.backward = data.backward; - edges.push_back( restored_edge ); + edges.push_back(restored_edge); } tempStorage.DeallocateSlot(edge_storage_slot); } -private: - inline void _Dijkstra( const int maxDistance, const unsigned numTargets, const int maxNodes, _ThreadData* const data, const NodeID middleNode ){ + private: + inline void _Dijkstra(const int maxDistance, + const unsigned numTargets, + const int maxNodes, + _ThreadData *const data, + const NodeID middleNode) + { - _Heap& heap = data->heap; + _Heap &heap = data->heap; int nodes = 0; unsigned targetsFound = 0; - while ( heap.Size() > 0 ) { + while (heap.Size() > 0) + { const NodeID node = heap.DeleteMin(); - const int distance = heap.GetKey( node ); - const short currentHop = heap.GetData( node ).hop+1; + const int distance = heap.GetKey(node); + const short currentHop = heap.GetData(node).hop + 1; - if ( ++nodes > maxNodes ) + if (++nodes > maxNodes) return; - //Destination settled? - if ( distance > maxDistance ) + // Destination settled? + if (distance > maxDistance) return; - if ( heap.GetData( node ).target ) { + if (heap.GetData(node).target) + { ++targetsFound; - if ( targetsFound >= numTargets ) { + if (targetsFound >= numTargets) + { return; } } - //iterate over all edges of node - for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge != endEdges; ++edge ) { - const ContractorEdgeData& data = _graph->GetEdgeData( edge ); - if ( !data.forward ){ + // iterate over all edges of node + for (_DynamicGraph::EdgeIterator edge = _graph->BeginEdges(node), + endEdges = _graph->EndEdges(node); + edge != endEdges; + ++edge) + { + const ContractorEdgeData &data = _graph->GetEdgeData(edge); + if (!data.forward) + { continue; } - const NodeID to = _graph->GetTarget( edge ); - if(middleNode == to) { + const NodeID to = _graph->GetTarget(edge); + if (middleNode == to) + { continue; } const int toDistance = distance + data.distance; - //New Node discovered -> Add to Heap + Node Info Storage - if ( !heap.WasInserted( to ) ) { - heap.Insert( to, toDistance, _HeapData(currentHop, false) ); + // New Node discovered -> Add to Heap + Node Info Storage + if (!heap.WasInserted(to)) + { + heap.Insert(to, toDistance, _HeapData(currentHop, false)); } - //Found a shorter Path -> Update distance - else if ( toDistance < heap.GetKey( to ) ) { - heap.DecreaseKey( to, toDistance ); - heap.GetData( to ).hop = currentHop; + // Found a shorter Path -> Update distance + else if (toDistance < heap.GetKey(to)) + { + heap.DecreaseKey(to, toDistance); + heap.GetData(to).hop = currentHop; } } } } - inline float _Evaluate( _ThreadData* const data, _PriorityData* const nodeData, const NodeID node){ + inline float + _Evaluate(_ThreadData *const data, _PriorityData *const nodeData, const NodeID node) + { _ContractionInformation stats; - //perform simulated contraction - _Contract< true> ( data, node, &stats ); + // perform simulated contraction + _Contract(data, node, &stats); // Result will contain the priority float result; - if ( 0 == (stats.edgesDeleted*stats.originalEdgesDeleted) ) + if (0 == (stats.edgesDeleted * stats.originalEdgesDeleted)) result = 1 * nodeData->depth; else - result = 2 * ((( float ) stats.edgesAdded ) / stats.edgesDeleted ) + 4 * ((( float ) stats.originalEdgesAdded ) / stats.originalEdgesDeleted ) + 1 * nodeData->depth; - assert( result >= 0 ); + result = 2 * (((float)stats.edgesAdded) / stats.edgesDeleted) + + 4 * (((float)stats.originalEdgesAdded) / stats.originalEdgesDeleted) + + 1 * nodeData->depth; + assert(result >= 0); return result; } - template< bool Simulate > - inline bool _Contract( _ThreadData* data, NodeID node, _ContractionInformation* stats = NULL ) { - _Heap& heap = data->heap; + template + inline bool _Contract(_ThreadData *data, NodeID node, _ContractionInformation *stats = NULL) + { + _Heap &heap = data->heap; int insertedEdgesSize = data->insertedEdges.size(); - std::vector< _ContractorEdge >& insertedEdges = data->insertedEdges; + std::vector<_ContractorEdge> &insertedEdges = data->insertedEdges; - for ( _DynamicGraph::EdgeIterator inEdge = _graph->BeginEdges( node ), endInEdges = _graph->EndEdges( node ); inEdge != endInEdges; ++inEdge ) { - const ContractorEdgeData& inData = _graph->GetEdgeData( inEdge ); - const NodeID source = _graph->GetTarget( inEdge ); - if ( Simulate ) { - assert( stats != NULL ); + for (_DynamicGraph::EdgeIterator inEdge = _graph->BeginEdges(node), + endInEdges = _graph->EndEdges(node); + inEdge != endInEdges; + ++inEdge) + { + const ContractorEdgeData &inData = _graph->GetEdgeData(inEdge); + const NodeID source = _graph->GetTarget(inEdge); + if (Simulate) + { + assert(stats != NULL); ++stats->edgesDeleted; stats->originalEdgesDeleted += inData.originalEdges; } - if ( !inData.backward ) + if (!inData.backward) continue; heap.Clear(); - heap.Insert( source, 0, _HeapData() ); + heap.Insert(source, 0, _HeapData()); int maxDistance = 0; unsigned numTargets = 0; - for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) { - const ContractorEdgeData& outData = _graph->GetEdgeData( outEdge ); - if ( !outData.forward ) { + for (_DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges(node), + endOutEdges = _graph->EndEdges(node); + outEdge != endOutEdges; + ++outEdge) + { + const ContractorEdgeData &outData = _graph->GetEdgeData(outEdge); + if (!outData.forward) + { continue; } - const NodeID target = _graph->GetTarget( outEdge ); + const NodeID target = _graph->GetTarget(outEdge); const int pathDistance = inData.distance + outData.distance; - maxDistance = std::max( maxDistance, pathDistance ); - if ( !heap.WasInserted( target ) ) { - heap.Insert( target, INT_MAX, _HeapData( 0, true ) ); + maxDistance = std::max(maxDistance, pathDistance); + if (!heap.WasInserted(target)) + { + heap.Insert(target, INT_MAX, _HeapData(0, true)); ++numTargets; } } - if( Simulate ) { - _Dijkstra( maxDistance, numTargets, 1000, data, node ); - } else { - _Dijkstra( maxDistance, numTargets, 2000, data, node ); + if (Simulate) + { + _Dijkstra(maxDistance, numTargets, 1000, data, node); } - for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) { - const ContractorEdgeData& outData = _graph->GetEdgeData( outEdge ); - if ( !outData.forward ) { + else + { + _Dijkstra(maxDistance, numTargets, 2000, data, node); + } + for (_DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges(node), + endOutEdges = _graph->EndEdges(node); + outEdge != endOutEdges; + ++outEdge) + { + const ContractorEdgeData &outData = _graph->GetEdgeData(outEdge); + if (!outData.forward) + { continue; } - const NodeID target = _graph->GetTarget( outEdge ); + const NodeID target = _graph->GetTarget(outEdge); const int pathDistance = inData.distance + outData.distance; - const int distance = heap.GetKey( target ); - if ( pathDistance < distance ) { - if ( Simulate ) { - assert( stats != NULL ); - stats->edgesAdded+=2; - stats->originalEdgesAdded += 2* ( outData.originalEdges + inData.originalEdges ); - } else { + const int distance = heap.GetKey(target); + if (pathDistance < distance) + { + if (Simulate) + { + assert(stats != NULL); + stats->edgesAdded += 2; + stats->originalEdgesAdded += + 2 * (outData.originalEdges + inData.originalEdges); + } + else + { _ContractorEdge newEdge; newEdge.source = source; newEdge.target = target; - newEdge.data = ContractorEdgeData( pathDistance, outData.originalEdges + inData.originalEdges, node/*, 0, inData.turnInstruction*/, true, true, false);; - insertedEdges.push_back( newEdge ); - std::swap( newEdge.source, newEdge.target ); + newEdge.data = + ContractorEdgeData(pathDistance, + outData.originalEdges + inData.originalEdges, + node /*, 0, inData.turnInstruction*/, + true, + true, + false); + ; + insertedEdges.push_back(newEdge); + std::swap(newEdge.source, newEdge.target); newEdge.data.forward = false; newEdge.data.backward = true; - insertedEdges.push_back( newEdge ); + insertedEdges.push_back(newEdge); } } } } - if ( !Simulate ) { - for ( int i = insertedEdgesSize, iend = insertedEdges.size(); i < iend; ++i ) { + if (!Simulate) + { + for (int i = insertedEdgesSize, iend = insertedEdges.size(); i < iend; ++i) + { bool found = false; - for ( int other = i + 1 ; other < iend ; ++other ) { - if ( insertedEdges[other].source != insertedEdges[i].source ) + for (int other = i + 1; other < iend; ++other) + { + if (insertedEdges[other].source != insertedEdges[i].source) continue; - if ( insertedEdges[other].target != insertedEdges[i].target ) + if (insertedEdges[other].target != insertedEdges[i].target) continue; - if ( insertedEdges[other].data.distance != insertedEdges[i].data.distance ) + if (insertedEdges[other].data.distance != insertedEdges[i].data.distance) continue; - if ( insertedEdges[other].data.shortcut != insertedEdges[i].data.shortcut ) + if (insertedEdges[other].data.shortcut != insertedEdges[i].data.shortcut) continue; insertedEdges[other].data.forward |= insertedEdges[i].data.forward; insertedEdges[other].data.backward |= insertedEdges[i].data.backward; @@ -670,45 +807,57 @@ private: insertedEdges[insertedEdgesSize++] = insertedEdges[i]; } } - insertedEdges.resize( insertedEdgesSize ); + insertedEdges.resize(insertedEdgesSize); } return true; } - inline void _DeleteIncomingEdges( _ThreadData* data, const NodeID node ) { - std::vector< NodeID >& neighbours = data->neighbours; + inline void _DeleteIncomingEdges(_ThreadData *data, const NodeID node) + { + std::vector &neighbours = data->neighbours; neighbours.clear(); - //find all neighbours - for ( _DynamicGraph::EdgeIterator e = _graph->BeginEdges( node ) ; e < _graph->EndEdges( node ) ; ++e ) { - const NodeID u = _graph->GetTarget( e ); - if ( u != node ) - neighbours.push_back( u ); + // find all neighbours + for (_DynamicGraph::EdgeIterator e = _graph->BeginEdges(node); e < _graph->EndEdges(node); + ++e) + { + const NodeID u = _graph->GetTarget(e); + if (u != node) + neighbours.push_back(u); } - //eliminate duplicate entries ( forward + backward edges ) - std::sort( neighbours.begin(), neighbours.end() ); - neighbours.resize( std::unique( neighbours.begin(), neighbours.end() ) - neighbours.begin() ); + // eliminate duplicate entries ( forward + backward edges ) + std::sort(neighbours.begin(), neighbours.end()); + neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin()); - for ( int i = 0, e = ( int ) neighbours.size(); i < e; ++i ) { - _graph->DeleteEdgesTo( neighbours[i], node ); + for (int i = 0, e = (int)neighbours.size(); i < e; ++i) + { + _graph->DeleteEdgesTo(neighbours[i], node); } } - inline bool _UpdateNeighbours( std::vector< float > & priorities, std::vector< _PriorityData > & nodeData, _ThreadData* const data, const NodeID node) { - std::vector< NodeID >& neighbours = data->neighbours; + inline bool _UpdateNeighbours(std::vector &priorities, + std::vector<_PriorityData> &nodeData, + _ThreadData *const data, + const NodeID node) + { + std::vector &neighbours = data->neighbours; neighbours.clear(); - //find all neighbours - for ( _DynamicGraph::EdgeIterator e = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ) ; e < endEdges ; ++e ) { - const NodeID u = _graph->GetTarget( e ); - if ( u == node ) + // find all neighbours + for (_DynamicGraph::EdgeIterator e = _graph->BeginEdges(node), + endEdges = _graph->EndEdges(node); + e < endEdges; + ++e) + { + const NodeID u = _graph->GetTarget(e); + if (u == node) continue; - neighbours.push_back( u ); - nodeData[u].depth = (std::max)(nodeData[node].depth + 1, nodeData[u].depth ); + neighbours.push_back(u); + nodeData[u].depth = (std::max)(nodeData[node].depth + 1, nodeData[u].depth); } - //eliminate duplicate entries ( forward + backward edges ) - std::sort( neighbours.begin(), neighbours.end() ); - neighbours.resize( std::unique( neighbours.begin(), neighbours.end() ) - neighbours.begin() ); + // eliminate duplicate entries ( forward + backward edges ) + std::sort(neighbours.begin(), neighbours.end()); + neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin()); for(const NodeID u : neighbours) { priorities[u] = _Evaluate( data, &( nodeData )[u], u ); @@ -716,40 +865,49 @@ private: return true; } - inline bool _IsIndependent( const std::vector< float >& priorities/*, const std::vector< _PriorityData >& nodeData*/, _ThreadData* const data, NodeID node ) const { + inline bool _IsIndependent( + const std::vector &priorities /*, const std::vector< _PriorityData >& nodeData*/, + _ThreadData *const data, + NodeID node) const + { const double priority = priorities[node]; - std::vector< NodeID >& neighbours = data->neighbours; + std::vector &neighbours = data->neighbours; neighbours.clear(); - for ( _DynamicGraph::EdgeIterator e = _graph->BeginEdges( node ) ; e < _graph->EndEdges( node ) ; ++e ) { - const NodeID target = _graph->GetTarget( e ); - if(node==target) + for (_DynamicGraph::EdgeIterator e = _graph->BeginEdges(node); e < _graph->EndEdges(node); + ++e) + { + const NodeID target = _graph->GetTarget(e); + if (node == target) continue; const double targetPriority = priorities[target]; - assert( targetPriority >= 0 ); - //found a neighbour with lower priority? - if ( priority > targetPriority ) + assert(targetPriority >= 0); + // found a neighbour with lower priority? + if (priority > targetPriority) return false; - //tie breaking - if ( std::abs(priority - targetPriority) < std::numeric_limits::epsilon() && bias(node, target) ) { + // tie breaking + if (std::abs(priority - targetPriority) < std::numeric_limits::epsilon() && + bias(node, target)) + { return false; } // TODO: C++11 copy_if with lambda - neighbours.push_back( target ); + neighbours.push_back(target); } - std::sort( neighbours.begin(), neighbours.end() ); - neighbours.resize( std::unique( neighbours.begin(), neighbours.end() ) - neighbours.begin() ); + std::sort(neighbours.begin(), neighbours.end()); + neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin()); - //examine all neighbours that are at most 2 hops away - for(const NodeID u : neighbours) { - for ( _DynamicGraph::EdgeIterator e = _graph->BeginEdges( u ) ; e < _graph->EndEdges( u ) ; ++e ) { - const NodeID target = _graph->GetTarget( e ); - if(node==target) - { + // examine all neighbours that are at most 2 hops away + for(const NodeID u : neighbours) + { + for (_DynamicGraph::EdgeIterator e = _graph->BeginEdges(u); e < _graph->EndEdges(u); + ++e) + { + const NodeID target = _graph->GetTarget(e); + if (node == target) continue; - } const double targetPriority = priorities[target]; assert( targetPriority >= 0 ); @@ -769,12 +927,14 @@ private: /** * This bias function takes up 22 assembly instructions in total on X86 */ - inline bool bias(const NodeID a, const NodeID b) const { + inline bool bias(const NodeID a, const NodeID b) const + { unsigned short hasha = fastHash(a); unsigned short hashb = fastHash(b); - //The compiler optimizes that to conditional register flags but without branching statements! - if(hasha != hashb) + // The compiler optimizes that to conditional register flags but without branching + // statements! + if (hasha != hashb) return hasha < hashb; return a < b; } diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 3a3c7f95d..c92efa651 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -25,7 +25,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - #include "EdgeBasedGraphFactory.h" #include "../Util/ComputeAngle.h" #include "../DataStructures/BFSComponentExplorer.h" @@ -39,107 +38,97 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include EdgeBasedGraphFactory::EdgeBasedGraphFactory( - const boost::shared_ptr& node_based_graph, + const boost::shared_ptr &node_based_graph, std::unique_ptr restriction_map, - std::vector & barrier_node_list, - std::vector & traffic_light_node_list, - std::vector & m_node_info_list, - SpeedProfileProperties & speed_profile -) : speed_profile(speed_profile), - m_number_of_edge_based_nodes(std::numeric_limits::max()), - m_node_info_list(m_node_info_list), - m_node_based_graph(node_based_graph), - m_restriction_map(std::move(restriction_map)), - max_id(0) + std::vector &barrier_node_list, + std::vector &traffic_light_node_list, + std::vector &m_node_info_list, + SpeedProfileProperties &speed_profile) + : speed_profile(speed_profile), + m_number_of_edge_based_nodes(std::numeric_limits::max()), + m_node_info_list(m_node_info_list), m_node_based_graph(node_based_graph), + m_restriction_map(std::move(restriction_map)), max_id(0) { // insert into unordered sets for fast lookup - m_barrier_nodes.insert( - barrier_node_list.begin(), - barrier_node_list.end() - ); - - m_traffic_lights.insert( - traffic_light_node_list.begin(), - traffic_light_node_list.end() - ); + m_barrier_nodes.insert(barrier_node_list.begin(), barrier_node_list.end()); + m_traffic_lights.insert(traffic_light_node_list.begin(), traffic_light_node_list.end()); } - -void EdgeBasedGraphFactory::GetEdgeBasedEdges( - DeallocatingVector< EdgeBasedEdge >& output_edge_list -) { - BOOST_ASSERT_MSG( - 0 == output_edge_list.size(), - "Vector is not empty" - ); +void EdgeBasedGraphFactory::GetEdgeBasedEdges(DeallocatingVector &output_edge_list) +{ + BOOST_ASSERT_MSG(0 == output_edge_list.size(), "Vector is not empty"); m_edge_based_edge_list.swap(output_edge_list); } -void EdgeBasedGraphFactory::GetEdgeBasedNodes( std::vector & nodes) { +void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector &nodes) +{ #ifndef NDEBUG - BOOST_FOREACH(const EdgeBasedNode & node, m_edge_based_node_list){ + BOOST_FOREACH (const EdgeBasedNode &node, m_edge_based_node_list) + { - BOOST_ASSERT( m_node_info_list.at(node.u).lat != INT_MAX ); - BOOST_ASSERT( m_node_info_list.at(node.u).lon != INT_MAX ); - BOOST_ASSERT( m_node_info_list.at(node.v).lon != INT_MAX ); - BOOST_ASSERT( m_node_info_list.at(node.v).lat != INT_MAX ); + BOOST_ASSERT(m_node_info_list.at(node.u).lat != INT_MAX); + BOOST_ASSERT(m_node_info_list.at(node.u).lon != INT_MAX); + BOOST_ASSERT(m_node_info_list.at(node.v).lon != INT_MAX); + BOOST_ASSERT(m_node_info_list.at(node.v).lat != INT_MAX); } #endif nodes.swap(m_edge_based_node_list); } - -void EdgeBasedGraphFactory::InsertEdgeBasedNode( - NodeIterator u, - NodeIterator v, - EdgeIterator e1, - bool belongs_to_tiny_cc -) { +void EdgeBasedGraphFactory::InsertEdgeBasedNode(NodeIterator u, + NodeIterator v, + EdgeIterator e1, + bool belongs_to_tiny_cc) +{ // merge edges together into one EdgeBasedNode - BOOST_ASSERT( u != SPECIAL_NODEID ); - BOOST_ASSERT( v != SPECIAL_NODEID ); - BOOST_ASSERT( e1 != SPECIAL_EDGEID ); + BOOST_ASSERT(u != SPECIAL_NODEID); + BOOST_ASSERT(v != SPECIAL_NODEID); + BOOST_ASSERT(e1 != SPECIAL_EDGEID); #ifndef NDEBUG // find forward edge id and const EdgeID e1b = m_node_based_graph->FindEdge(u, v); - BOOST_ASSERT( e1 == e1b ); + BOOST_ASSERT(e1 == e1b); #endif - BOOST_ASSERT( e1 != SPECIAL_EDGEID ); - const EdgeData & forward_data = m_node_based_graph->GetEdgeData(e1); + BOOST_ASSERT(e1 != SPECIAL_EDGEID); + const EdgeData &forward_data = m_node_based_graph->GetEdgeData(e1); // find reverse edge id and const EdgeID e2 = m_node_based_graph->FindEdge(v, u); #ifndef NDEBUG - if ( e2 == m_node_based_graph->EndEdges(v) ) { + if (e2 == m_node_based_graph->EndEdges(v)) + { SimpleLogger().Write(logWARNING) << "Did not find edge (" << v << "," << u << ")"; } #endif - BOOST_ASSERT( e2 != SPECIAL_EDGEID ); - BOOST_ASSERT( e2 < m_node_based_graph->EndEdges(v) ); - const EdgeData & reverse_data = m_node_based_graph->GetEdgeData(e2); + BOOST_ASSERT(e2 != SPECIAL_EDGEID); + BOOST_ASSERT(e2 < m_node_based_graph->EndEdges(v)); + const EdgeData &reverse_data = m_node_based_graph->GetEdgeData(e2); - if( - forward_data.edgeBasedNodeID == SPECIAL_NODEID && - reverse_data.edgeBasedNodeID == SPECIAL_NODEID - ) { + if (forward_data.edgeBasedNodeID == SPECIAL_NODEID && + reverse_data.edgeBasedNodeID == SPECIAL_NODEID) + { return; } - BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e1) == m_geometry_compressor.HasEntryForID(e2) ); - if( m_geometry_compressor.HasEntryForID(e1) ) { + BOOST_ASSERT(m_geometry_compressor.HasEntryForID(e1) == + m_geometry_compressor.HasEntryForID(e2)); + if (m_geometry_compressor.HasEntryForID(e1)) + { - BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e2) ); + BOOST_ASSERT(m_geometry_compressor.HasEntryForID(e2)); // reconstruct geometry and put in each individual edge with its offset - const std::vector & forward_geometry = m_geometry_compressor.GetBucketReference(e1); - const std::vector & reverse_geometry = m_geometry_compressor.GetBucketReference(e2); - BOOST_ASSERT( forward_geometry.size() == reverse_geometry.size() ); - BOOST_ASSERT( 0 != forward_geometry.size() ); + const std::vector &forward_geometry = + m_geometry_compressor.GetBucketReference(e1); + const std::vector &reverse_geometry = + m_geometry_compressor.GetBucketReference(e2); + BOOST_ASSERT(forward_geometry.size() == reverse_geometry.size()); + BOOST_ASSERT(0 != forward_geometry.size()); // reconstruct bidirectional edge with individual weights and put each into the NN index @@ -155,20 +144,21 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode( forward_dist_prefix_sum[i] = temp_sum; temp_sum += forward_geometry[i].second; - BOOST_ASSERT( forward_data.distance >= temp_sum ); + BOOST_ASSERT(forward_data.distance >= temp_sum); } temp_sum = 0; - for( unsigned i = 0; i < reverse_geometry.size(); ++i ) { - temp_sum += reverse_geometry[reverse_geometry.size()-1-i].second; + for (unsigned i = 0; i < reverse_geometry.size(); ++i) + { + temp_sum += reverse_geometry[reverse_geometry.size() - 1 - i].second; reverse_dist_prefix_sum[i] = reverse_data.distance - temp_sum; - BOOST_ASSERT( reverse_data.distance >= temp_sum ); + BOOST_ASSERT(reverse_data.distance >= temp_sum); } - BOOST_ASSERT( forward_geometry.size() == reverse_geometry.size() ); + BOOST_ASSERT(forward_geometry.size() == reverse_geometry.size()); const unsigned geometry_size = forward_geometry.size(); - BOOST_ASSERT( geometry_size > 1 ); + BOOST_ASSERT(geometry_size > 1); NodeID current_edge_start_coordinate_id = u; if (forward_data.edgeBasedNodeID != SPECIAL_NODEID) @@ -181,104 +171,93 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode( } // traverse arrays from start and end respectively - for( unsigned i = 0; i < geometry_size; ++i ) { - BOOST_ASSERT( current_edge_start_coordinate_id == reverse_geometry[geometry_size-1-i].first ); + for (unsigned i = 0; i < geometry_size; ++i) + { + BOOST_ASSERT(current_edge_start_coordinate_id == + reverse_geometry[geometry_size - 1 - i].first); const NodeID current_edge_target_coordinate_id = forward_geometry[i].first; - BOOST_ASSERT( current_edge_target_coordinate_id != current_edge_start_coordinate_id); + BOOST_ASSERT(current_edge_target_coordinate_id != current_edge_start_coordinate_id); // build edges m_edge_based_node_list.emplace_back( - EdgeBasedNode( - forward_data.edgeBasedNodeID, - reverse_data.edgeBasedNodeID, - current_edge_start_coordinate_id, - current_edge_target_coordinate_id, - forward_data.nameID, - forward_geometry[i].second, - reverse_geometry[i].second, - forward_dist_prefix_sum[i], - reverse_dist_prefix_sum[i], - m_geometry_compressor.GetPositionForID(e1), - i, - belongs_to_tiny_cc - ) - ); + EdgeBasedNode(forward_data.edgeBasedNodeID, + reverse_data.edgeBasedNodeID, + current_edge_start_coordinate_id, + current_edge_target_coordinate_id, + forward_data.nameID, + forward_geometry[i].second, + reverse_geometry[i].second, + forward_dist_prefix_sum[i], + reverse_dist_prefix_sum[i], + m_geometry_compressor.GetPositionForID(e1), + i, + belongs_to_tiny_cc)); current_edge_start_coordinate_id = current_edge_target_coordinate_id; - BOOST_ASSERT( m_edge_based_node_list.back().IsCompressed() ); + BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed()); - BOOST_ASSERT( - u != m_edge_based_node_list.back().u || - v != m_edge_based_node_list.back().v - ); + BOOST_ASSERT(u != m_edge_based_node_list.back().u || + v != m_edge_based_node_list.back().v); - BOOST_ASSERT( - u != m_edge_based_node_list.back().v || - v != m_edge_based_node_list.back().u - ); + BOOST_ASSERT(u != m_edge_based_node_list.back().v || + v != m_edge_based_node_list.back().u); } - BOOST_ASSERT( current_edge_start_coordinate_id == v ); - BOOST_ASSERT( m_edge_based_node_list.back().IsCompressed() ); + BOOST_ASSERT(current_edge_start_coordinate_id == v); + BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed()); + } + else + { + BOOST_ASSERT(!m_geometry_compressor.HasEntryForID(e2)); - } else { - BOOST_ASSERT( !m_geometry_compressor.HasEntryForID(e2) ); - - if( forward_data.edgeBasedNodeID != SPECIAL_NODEID ) { - BOOST_ASSERT( forward_data.forward ); + if (forward_data.edgeBasedNodeID != SPECIAL_NODEID) + { + BOOST_ASSERT(forward_data.forward); } - if( reverse_data.edgeBasedNodeID != SPECIAL_NODEID ) { - BOOST_ASSERT( reverse_data.forward ); + if (reverse_data.edgeBasedNodeID != SPECIAL_NODEID) + { + BOOST_ASSERT(reverse_data.forward); } - if( forward_data.edgeBasedNodeID == SPECIAL_NODEID ) { - BOOST_ASSERT( !forward_data.forward ); + if (forward_data.edgeBasedNodeID == SPECIAL_NODEID) + { + BOOST_ASSERT(!forward_data.forward); } - if( reverse_data.edgeBasedNodeID == SPECIAL_NODEID ) { - BOOST_ASSERT( !reverse_data.forward ); + if (reverse_data.edgeBasedNodeID == SPECIAL_NODEID) + { + BOOST_ASSERT(!reverse_data.forward); } - BOOST_ASSERT( - forward_data.edgeBasedNodeID != SPECIAL_NODEID || - reverse_data.edgeBasedNodeID != SPECIAL_NODEID - ); + BOOST_ASSERT(forward_data.edgeBasedNodeID != SPECIAL_NODEID || + reverse_data.edgeBasedNodeID != SPECIAL_NODEID); - m_edge_based_node_list.emplace_back( - EdgeBasedNode( - forward_data.edgeBasedNodeID, - reverse_data.edgeBasedNodeID, - u, - v, - forward_data.nameID, - forward_data.distance, - reverse_data.distance, - 0, - 0, - SPECIAL_EDGEID, - 0, - belongs_to_tiny_cc - ) - ); - BOOST_ASSERT( !m_edge_based_node_list.back().IsCompressed() ); + m_edge_based_node_list.emplace_back(EdgeBasedNode(forward_data.edgeBasedNodeID, + reverse_data.edgeBasedNodeID, + u, + v, + forward_data.nameID, + forward_data.distance, + reverse_data.distance, + 0, + 0, + SPECIAL_EDGEID, + 0, + belongs_to_tiny_cc)); + BOOST_ASSERT(!m_edge_based_node_list.back().IsCompressed()); } } - void EdgeBasedGraphFactory::FlushVectorToStream( - std::ofstream & edge_data_file, - std::vector & original_edge_data_vector -) const { - edge_data_file.write( - (char*)&(original_edge_data_vector[0]), - original_edge_data_vector.size()*sizeof(OriginalEdgeData) - ); + std::ofstream &edge_data_file, std::vector &original_edge_data_vector) const +{ + edge_data_file.write((char *)&(original_edge_data_vector[0]), + original_edge_data_vector.size() * sizeof(OriginalEdgeData)); original_edge_data_vector.clear(); } -void EdgeBasedGraphFactory::Run( - const std::string & original_edge_data_filename, - const std::string & geometry_filename, - lua_State *lua_state -) { +void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename, + const std::string &geometry_filename, + lua_State *lua_state) +{ CompressGeometry(); @@ -288,8 +267,7 @@ void EdgeBasedGraphFactory::Run( GenerateEdgeExpandedEdges(original_edge_data_filename, lua_state); - m_geometry_compressor.SerializeInternalVector( geometry_filename ); - + m_geometry_compressor.SerializeInternalVector(geometry_filename); } void EdgeBasedGraphFactory::CompressGeometry() @@ -302,79 +280,84 @@ void EdgeBasedGraphFactory::CompressGeometry() Percent p(original_number_of_nodes); unsigned removed_node_count = 0; - for( NodeID v = 0; v < original_number_of_nodes; ++v ) { + for (NodeID v = 0; v < original_number_of_nodes; ++v) + { p.printStatus(v); // only contract degree 2 vertices - if( 2 != m_node_based_graph->GetOutDegree(v) ) { + if (2 != m_node_based_graph->GetOutDegree(v)) + { continue; } // don't contract barrier node - if( m_barrier_nodes.end() != m_barrier_nodes.find(v) ) { + if (m_barrier_nodes.end() != m_barrier_nodes.find(v)) + { continue; } - const bool reverse_edge_order = !(m_node_based_graph->GetEdgeData(m_node_based_graph->BeginEdges(v)).forward); + const bool reverse_edge_order = + !(m_node_based_graph->GetEdgeData(m_node_based_graph->BeginEdges(v)).forward); const EdgeIterator forward_e2 = m_node_based_graph->BeginEdges(v) + reverse_edge_order; - BOOST_ASSERT( SPECIAL_EDGEID != forward_e2 ); + BOOST_ASSERT(SPECIAL_EDGEID != forward_e2); const EdgeIterator reverse_e2 = m_node_based_graph->BeginEdges(v) + 1 - reverse_edge_order; - BOOST_ASSERT( SPECIAL_EDGEID != reverse_e2 ); + BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2); - const EdgeData & fwd_edge_data2 = m_node_based_graph->GetEdgeData(forward_e2); - const EdgeData & rev_edge_data2 = m_node_based_graph->GetEdgeData(reverse_e2); + const EdgeData &fwd_edge_data2 = m_node_based_graph->GetEdgeData(forward_e2); + const EdgeData &rev_edge_data2 = m_node_based_graph->GetEdgeData(reverse_e2); const NodeIterator w = m_node_based_graph->GetTarget(forward_e2); - BOOST_ASSERT( SPECIAL_NODEID != w ); - BOOST_ASSERT( v != w ); + BOOST_ASSERT(SPECIAL_NODEID != w); + BOOST_ASSERT(v != w); const NodeIterator u = m_node_based_graph->GetTarget(reverse_e2); - BOOST_ASSERT( SPECIAL_NODEID != u ); - BOOST_ASSERT( u != v ); + BOOST_ASSERT(SPECIAL_NODEID != u); + BOOST_ASSERT(u != v); const EdgeIterator forward_e1 = m_node_based_graph->FindEdge(u, v); - BOOST_ASSERT( m_node_based_graph->EndEdges(u) != forward_e1 ); - BOOST_ASSERT( SPECIAL_EDGEID != forward_e1 ); - BOOST_ASSERT( v == m_node_based_graph->GetTarget(forward_e1)); + BOOST_ASSERT(m_node_based_graph->EndEdges(u) != forward_e1); + BOOST_ASSERT(SPECIAL_EDGEID != forward_e1); + BOOST_ASSERT(v == m_node_based_graph->GetTarget(forward_e1)); const EdgeIterator reverse_e1 = m_node_based_graph->FindEdge(w, v); - BOOST_ASSERT( SPECIAL_EDGEID != reverse_e1 ); - BOOST_ASSERT( v == m_node_based_graph->GetTarget(reverse_e1)); + BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1); + BOOST_ASSERT(v == m_node_based_graph->GetTarget(reverse_e1)); - const EdgeData & fwd_edge_data1 = m_node_based_graph->GetEdgeData(forward_e1); - const EdgeData & rev_edge_data1 = m_node_based_graph->GetEdgeData(reverse_e1); + const EdgeData &fwd_edge_data1 = m_node_based_graph->GetEdgeData(forward_e1); + const EdgeData &rev_edge_data1 = m_node_based_graph->GetEdgeData(reverse_e1); - if( - ( m_node_based_graph->FindEdge(u, w) != m_node_based_graph->EndEdges(u) ) || - ( m_node_based_graph->FindEdge(w, u) != m_node_based_graph->EndEdges(w) ) - ) { + if ((m_node_based_graph->FindEdge(u, w) != m_node_based_graph->EndEdges(u)) || + (m_node_based_graph->FindEdge(w, u) != m_node_based_graph->EndEdges(w))) + { continue; } - if ( //TODO: rename to IsCompatibleTo - fwd_edge_data1.IsEqualTo(fwd_edge_data2) && - rev_edge_data1.IsEqualTo(rev_edge_data2) - ) { - //Get distances before graph is modified + if ( // TODO: rename to IsCompatibleTo + fwd_edge_data1.IsEqualTo(fwd_edge_data2) && rev_edge_data1.IsEqualTo(rev_edge_data2)) + { + // Get distances before graph is modified const int forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance; const int forward_weight2 = m_node_based_graph->GetEdgeData(forward_e2).distance; - BOOST_ASSERT( 0 != forward_weight1 ); - BOOST_ASSERT( 0 != forward_weight2 ); + BOOST_ASSERT(0 != forward_weight1); + BOOST_ASSERT(0 != forward_weight2); const int reverse_weight1 = m_node_based_graph->GetEdgeData(reverse_e1).distance; const int reverse_weight2 = m_node_based_graph->GetEdgeData(reverse_e2).distance; - BOOST_ASSERT( 0 != reverse_weight1 ); - BOOST_ASSERT( 0 != forward_weight2 ); + BOOST_ASSERT(0 != reverse_weight1); + BOOST_ASSERT(0 != forward_weight2); - const bool add_traffic_signal_penalty = (m_traffic_lights.find(v) != m_traffic_lights.end()); + const bool add_traffic_signal_penalty = + (m_traffic_lights.find(v) != m_traffic_lights.end()); // add weight of e2's to e1 m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance; m_node_based_graph->GetEdgeData(reverse_e1).distance += rev_edge_data2.distance; if (add_traffic_signal_penalty) { - m_node_based_graph->GetEdgeData(forward_e1).distance += speed_profile.trafficSignalPenalty; - m_node_based_graph->GetEdgeData(reverse_e1).distance += speed_profile.trafficSignalPenalty; + m_node_based_graph->GetEdgeData(forward_e1).distance += + speed_profile.trafficSignalPenalty; + m_node_based_graph->GetEdgeData(reverse_e1).distance += + speed_profile.trafficSignalPenalty; } // extend e1's to targets of e2's @@ -386,11 +369,11 @@ void EdgeBasedGraphFactory::CompressGeometry() m_node_based_graph->DeleteEdge(v, reverse_e2); // update any involved turn restrictions - m_restriction_map->FixupStartingTurnRestriction( u, v, w ); - m_restriction_map->FixupArrivingTurnRestriction( u, v, w ); + m_restriction_map->FixupStartingTurnRestriction(u, v, w); + m_restriction_map->FixupArrivingTurnRestriction(u, v, w); - m_restriction_map->FixupStartingTurnRestriction( w, v, u ); - m_restriction_map->FixupArrivingTurnRestriction( w, v, u ); + m_restriction_map->FixupStartingTurnRestriction(w, v, u); + m_restriction_map->FixupArrivingTurnRestriction(w, v, u); // store compressed geometry in container m_geometry_compressor.CompressEdge( @@ -398,24 +381,21 @@ void EdgeBasedGraphFactory::CompressGeometry() forward_e2, v, w, - forward_weight1 + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty :0), - forward_weight2 - ); + forward_weight1 + + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty : 0), + forward_weight2); m_geometry_compressor.CompressEdge( reverse_e1, reverse_e2, v, u, - reverse_weight1 , - reverse_weight2 + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty :0) - ); + reverse_weight1, + reverse_weight2 + + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty : 0)); ++removed_node_count; - BOOST_ASSERT - ( - m_node_based_graph->GetEdgeData(forward_e1).nameID == - m_node_based_graph->GetEdgeData(reverse_e1).nameID - ); + BOOST_ASSERT(m_node_based_graph->GetEdgeData(forward_e1).nameID == + m_node_based_graph->GetEdgeData(reverse_e1).nameID); } } SimpleLogger().Write() << "removed " << removed_node_count << " nodes"; @@ -423,15 +403,19 @@ void EdgeBasedGraphFactory::CompressGeometry() unsigned new_node_count = 0; unsigned new_edge_count = 0; - for( unsigned i = 0; i < m_node_based_graph->GetNumberOfNodes(); ++i ) { - if( m_node_based_graph->GetOutDegree(i) > 0 ) { + for (unsigned i = 0; i < m_node_based_graph->GetNumberOfNodes(); ++i) + { + if (m_node_based_graph->GetOutDegree(i) > 0) + { ++new_node_count; new_edge_count += (m_node_based_graph->EndEdges(i) - m_node_based_graph->BeginEdges(i)); } } SimpleLogger().Write() << "new nodes: " << new_node_count << ", edges " << new_edge_count; - SimpleLogger().Write() << "Node compression ratio: " << new_node_count/(double)original_number_of_nodes; - SimpleLogger().Write() << "Edge compression ratio: " << new_edge_count/(double)original_number_of_edges; + SimpleLogger().Write() << "Node compression ratio: " + << new_node_count / (double)original_number_of_nodes; + SimpleLogger().Write() << "Edge compression ratio: " + << new_edge_count / (double)original_number_of_edges; } /** @@ -441,18 +425,24 @@ void EdgeBasedGraphFactory::RenumberEdges() { // renumber edge based node IDs unsigned numbered_edges_count = 0; - for(NodeID current_node = 0; current_node < m_node_based_graph->GetNumberOfNodes(); ++current_node) { - for(EdgeIterator current_edge = m_node_based_graph->BeginEdges(current_node); current_edge < m_node_based_graph->EndEdges(current_node); ++current_edge) { - EdgeData & edge_data = m_node_based_graph->GetEdgeData(current_edge); - if( !edge_data.forward ) { + for (NodeID current_node = 0; current_node < m_node_based_graph->GetNumberOfNodes(); + ++current_node) + { + for (EdgeIterator current_edge = m_node_based_graph->BeginEdges(current_node); + current_edge < m_node_based_graph->EndEdges(current_node); + ++current_edge) + { + EdgeData &edge_data = m_node_based_graph->GetEdgeData(current_edge); + if (!edge_data.forward) + { continue; } - BOOST_ASSERT( numbered_edges_count < m_node_based_graph->GetNumberOfEdges() ); + BOOST_ASSERT(numbered_edges_count < m_node_based_graph->GetNumberOfEdges()); edge_data.edgeBasedNodeID = numbered_edges_count; ++numbered_edges_count; - BOOST_ASSERT( SPECIAL_NODEID != edge_data.edgeBasedNodeID); + BOOST_ASSERT(SPECIAL_NODEID != edge_data.edgeBasedNodeID); } } @@ -466,96 +456,84 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes() { SimpleLogger().Write() << "Identifying components of the road network"; - //Run a BFS on the undirected graph and identify small components + // Run a BFS on the undirected graph and identify small components BFSComponentExplorer component_explorer( - *m_node_based_graph, - *m_restriction_map, - m_barrier_nodes - ); + *m_node_based_graph, *m_restriction_map, m_barrier_nodes); component_explorer.run(); - SimpleLogger().Write() << - "identified: " << component_explorer.getNumberOfComponents() << " many components"; + SimpleLogger().Write() << "identified: " << component_explorer.getNumberOfComponents() + << " many components"; SimpleLogger().Write() << "generating edge-expanded nodes"; Percent p(m_node_based_graph->GetNumberOfNodes()); - //loop over all edges and generate new set of nodes - for( - NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes(); - u < end; - ++u - ) { - BOOST_ASSERT( u != SPECIAL_NODEID ); - BOOST_ASSERT( u < m_node_based_graph->GetNumberOfNodes() ); + // loop over all edges and generate new set of nodes + for (NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes(); u < end; ++u) + { + BOOST_ASSERT(u != SPECIAL_NODEID); + BOOST_ASSERT(u < m_node_based_graph->GetNumberOfNodes()); p.printIncrement(); - for( - EdgeID e1 = m_node_based_graph->BeginEdges(u), - last_edge = m_node_based_graph->EndEdges(u); - e1 < last_edge; - ++e1 - ) { - const EdgeData & edge_data = m_node_based_graph->GetEdgeData(e1); - if( edge_data.edgeBasedNodeID == SPECIAL_NODEID ) { + for (EdgeID e1 = m_node_based_graph->BeginEdges(u), + last_edge = m_node_based_graph->EndEdges(u); + e1 < last_edge; + ++e1) + { + const EdgeData &edge_data = m_node_based_graph->GetEdgeData(e1); + if (edge_data.edgeBasedNodeID == SPECIAL_NODEID) + { // continue; } - BOOST_ASSERT( e1 != SPECIAL_EDGEID ); + BOOST_ASSERT(e1 != SPECIAL_EDGEID); const NodeID v = m_node_based_graph->GetTarget(e1); - BOOST_ASSERT( SPECIAL_NODEID != v ); + BOOST_ASSERT(SPECIAL_NODEID != v); // pick only every other edge - if( u > v ) { + if (u > v) + { continue; } - BOOST_ASSERT( u < v ); - BOOST_ASSERT( edge_data.type != SHRT_MAX ); + BOOST_ASSERT(u < v); + BOOST_ASSERT(edge_data.type != SHRT_MAX); - //Note: edges that end on barrier nodes or on a turn restriction - //may actually be in two distinct components. We choose the smallest - const unsigned size_of_component = std::min( - component_explorer.getComponentSize(u), - component_explorer.getComponentSize(v) - ); + // Note: edges that end on barrier nodes or on a turn restriction + // may actually be in two distinct components. We choose the smallest + const unsigned size_of_component = std::min(component_explorer.getComponentSize(u), + component_explorer.getComponentSize(v)); - const bool component_is_tiny = ( size_of_component < 1000 ); - InsertEdgeBasedNode( u, v, e1, component_is_tiny ); + const bool component_is_tiny = (size_of_component < 1000); + InsertEdgeBasedNode(u, v, e1, component_is_tiny); } } - SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() << - " nodes in edge-expanded graph"; + SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() + << " nodes in edge-expanded graph"; } /** * Actually it also generates OriginalEdgeData and serializes them... */ -void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string& original_edge_data_filename, lua_State* lua_state) +void +EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string &original_edge_data_filename, + lua_State *lua_state) { SimpleLogger().Write() << "generating edge-expanded edges"; unsigned node_based_edge_counter = 0; - unsigned original_edges_counter = 0; + unsigned original_edges_counter = 0; - std::ofstream edge_data_file( - original_edge_data_filename.c_str(), - std::ios::binary - ); - - //writes a dummy value that is updated later - edge_data_file.write( - (char*)&original_edges_counter, - sizeof(unsigned) - ); + std::ofstream edge_data_file(original_edge_data_filename.c_str(), std::ios::binary); + // writes a dummy value that is updated later + edge_data_file.write((char *)&original_edges_counter, sizeof(unsigned)); std::vector original_edge_data_vector; - original_edge_data_vector.reserve(1024*1024); + original_edge_data_vector.reserve(1024 * 1024); - //Loop over all turns and generate new set of edges. - //Three nested loop look super-linear, but we are dealing with a (kind of) - //linear number of turns only. + // Loop over all turns and generate new set of edges. + // Three nested loop look super-linear, but we are dealing with a (kind of) + // linear number of turns only. unsigned restricted_turns_counter = 0; unsigned skipped_uturns_counter = 0; unsigned skipped_barrier_turns_counter = 0; @@ -565,32 +543,37 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string& origina for (NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes(); u < end; ++u) { - for (EdgeIterator e1 = m_node_based_graph->BeginEdges(u), last_edge_u = m_node_based_graph->EndEdges(u); e1 < last_edge_u; ++e1) + for (EdgeIterator e1 = m_node_based_graph->BeginEdges(u), + last_edge_u = m_node_based_graph->EndEdges(u); + e1 < last_edge_u; + ++e1) { - if( !m_node_based_graph->GetEdgeData(e1).forward ) { + if (!m_node_based_graph->GetEdgeData(e1).forward) + { continue; } ++node_based_edge_counter; const NodeIterator v = m_node_based_graph->GetTarget(e1); - const NodeID to_node_of_only_restriction = m_restriction_map->CheckForEmanatingIsOnlyTurn(u, v); - const bool is_barrier_node = ( m_barrier_nodes.find(v) != m_barrier_nodes.end() ); + const NodeID to_node_of_only_restriction = + m_restriction_map->CheckForEmanatingIsOnlyTurn(u, v); + const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end()); - for( - EdgeIterator e2 = m_node_based_graph->BeginEdges(v), - last_edge_v = m_node_based_graph->EndEdges(v); - e2 < last_edge_v; - ++e2 - ) { + for (EdgeIterator e2 = m_node_based_graph->BeginEdges(v), + last_edge_v = m_node_based_graph->EndEdges(v); + e2 < last_edge_v; + ++e2) + { if (!m_node_based_graph->GetEdgeData(e2).forward) { continue; } const NodeIterator w = m_node_based_graph->GetTarget(e2); - if ((to_node_of_only_restriction != SPECIAL_NODEID) && (w != to_node_of_only_restriction)) + if ((to_node_of_only_restriction != SPECIAL_NODEID) && + (w != to_node_of_only_restriction)) { - //We are at an only_-restriction but not at the right turn. + // We are at an only_-restriction but not at the right turn. ++restricted_turns_counter; continue; } @@ -612,17 +595,19 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string& origina } } - //only add an edge if turn is not a U-turn except when it is - //at the end of a dead-end street - if (m_restriction_map->CheckIfTurnIsRestricted(u, v, w) && (to_node_of_only_restriction == SPECIAL_NODEID) && (w != to_node_of_only_restriction)) + // only add an edge if turn is not a U-turn except when it is + // at the end of a dead-end street + if (m_restriction_map->CheckIfTurnIsRestricted(u, v, w) && + (to_node_of_only_restriction == SPECIAL_NODEID) && + (w != to_node_of_only_restriction)) { ++restricted_turns_counter; continue; } - //only add an edge if turn is not prohibited - const EdgeData & edge_data1 = m_node_based_graph->GetEdgeData(e1); - const EdgeData & edge_data2 = m_node_based_graph->GetEdgeData(e2); + // only add an edge if turn is not prohibited + const EdgeData &edge_data1 = m_node_based_graph->GetEdgeData(e1); + const EdgeData &edge_data2 = m_node_based_graph->GetEdgeData(e2); BOOST_ASSERT(edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID); BOOST_ASSERT(edge_data1.forward); @@ -649,147 +634,143 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string& origina ++compressed; } - original_edge_data_vector.push_back( - OriginalEdgeData( - (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : v), - edge_data1.nameID, - turn_instruction, - edge_is_compressed - ) - ); + original_edge_data_vector.push_back(OriginalEdgeData( + (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : v), + edge_data1.nameID, + turn_instruction, + edge_is_compressed)); ++original_edges_counter; - if (original_edge_data_vector.size() > 1024*1024*10) + if (original_edge_data_vector.size() > 1024 * 1024 * 10) { FlushVectorToStream(edge_data_file, original_edge_data_vector); } - BOOST_ASSERT( SPECIAL_NODEID != edge_data1.edgeBasedNodeID ); - BOOST_ASSERT( SPECIAL_NODEID != edge_data2.edgeBasedNodeID ); + BOOST_ASSERT(SPECIAL_NODEID != edge_data1.edgeBasedNodeID); + BOOST_ASSERT(SPECIAL_NODEID != edge_data2.edgeBasedNodeID); - m_edge_based_edge_list.emplace_back( - EdgeBasedEdge( - edge_data1.edgeBasedNodeID, - edge_data2.edgeBasedNodeID, - m_edge_based_edge_list.size(), - distance, - true, - false - ) - ); + m_edge_based_edge_list.emplace_back(EdgeBasedEdge(edge_data1.edgeBasedNodeID, + edge_data2.edgeBasedNodeID, + m_edge_based_edge_list.size(), + distance, + true, + false)); } } p.printIncrement(); } - FlushVectorToStream( edge_data_file, original_edge_data_vector ); + FlushVectorToStream(edge_data_file, original_edge_data_vector); - edge_data_file.seekp( std::ios::beg ); - edge_data_file.write( (char*)&original_edges_counter, sizeof(unsigned) ); + edge_data_file.seekp(std::ios::beg); + edge_data_file.write((char *)&original_edges_counter, sizeof(unsigned)); edge_data_file.close(); SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size() << " edge based nodes"; SimpleLogger().Write() << "Node-based graph contains " << node_based_edge_counter << " edges"; SimpleLogger().Write() << "Edge-expanded graph ..."; SimpleLogger().Write() << " contains " << m_edge_based_edge_list.size() << " edges"; - SimpleLogger().Write() << " skips " << restricted_turns_counter << " turns, " - "defined by " << m_restriction_map->size() << " restrictions"; - SimpleLogger().Write() << " skips " << skipped_uturns_counter << " U turns"; - SimpleLogger().Write() << " skips " << skipped_barrier_turns_counter << " turns over barriers"; + SimpleLogger().Write() << " skips " << restricted_turns_counter << " turns, " + "defined by " + << m_restriction_map->size() << " restrictions"; + SimpleLogger().Write() << " skips " << skipped_uturns_counter << " U turns"; + SimpleLogger().Write() << " skips " << skipped_barrier_turns_counter << " turns over barriers"; } +int EdgeBasedGraphFactory::GetTurnPenalty(const NodeID u, + const NodeID v, + const NodeID w, + lua_State *lua_state) const +{ + const double angle = GetAngleBetweenThreeFixedPointCoordinates( + m_node_info_list[u], m_node_info_list[v], m_node_info_list[w]); -int EdgeBasedGraphFactory::GetTurnPenalty( - const NodeID u, - const NodeID v, - const NodeID w, - lua_State *lua_state -) const { - const double angle = GetAngleBetweenThreeFixedPointCoordinates ( - m_node_info_list[u], - m_node_info_list[v], - m_node_info_list[w] - ); - - if( speed_profile.has_turn_penalty_function ) { - try { - //call lua profile to compute turn penalty - return luabind::call_function( - lua_state, - "turn_function", - 180.-angle - ); - } catch (const luabind::error &er) { + if (speed_profile.has_turn_penalty_function) + { + try + { + // call lua profile to compute turn penalty + return luabind::call_function(lua_state, "turn_function", 180. - angle); + } + catch (const luabind::error &er) + { SimpleLogger().Write(logWARNING) << er.what(); } } return 0; } -TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( - const NodeID u, - const NodeID v, - const NodeID w -) const { - if(u == w) { +TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) + const +{ + if (u == w) + { return TurnInstruction::UTurn; } const EdgeIterator edge1 = m_node_based_graph->FindEdge(u, v); const EdgeIterator edge2 = m_node_based_graph->FindEdge(v, w); - const EdgeData & data1 = m_node_based_graph->GetEdgeData(edge1); - const EdgeData & data2 = m_node_based_graph->GetEdgeData(edge2); + const EdgeData &data1 = m_node_based_graph->GetEdgeData(edge1); + const EdgeData &data2 = m_node_based_graph->GetEdgeData(edge2); - if(!data1.contraFlow && data2.contraFlow) { + if (!data1.contraFlow && data2.contraFlow) + { return TurnInstruction::EnterAgainstAllowedDirection; } - if(data1.contraFlow && !data2.contraFlow) { + if (data1.contraFlow && !data2.contraFlow) + { return TurnInstruction::LeaveAgainstAllowedDirection; } - //roundabouts need to be handled explicitely - if(data1.roundabout && data2.roundabout) { - //Is a turn possible? If yes, we stay on the roundabout! - if( 1 == m_node_based_graph->GetOutDegree(v) ) { - //No turn possible. + // roundabouts need to be handled explicitely + if (data1.roundabout && data2.roundabout) + { + // Is a turn possible? If yes, we stay on the roundabout! + if (1 == m_node_based_graph->GetOutDegree(v)) + { + // No turn possible. return TurnInstruction::NoTurn; } return TurnInstruction::StayOnRoundAbout; } - //Does turn start or end on roundabout? - if(data1.roundabout || data2.roundabout) { - //We are entering the roundabout - if( (!data1.roundabout) && data2.roundabout) { + // Does turn start or end on roundabout? + if (data1.roundabout || data2.roundabout) + { + // We are entering the roundabout + if ((!data1.roundabout) && data2.roundabout) + { return TurnInstruction::EnterRoundAbout; } - //We are leaving the roundabout - if(data1.roundabout && (!data2.roundabout) ) { + // We are leaving the roundabout + if (data1.roundabout && (!data2.roundabout)) + { return TurnInstruction::LeaveRoundAbout; } } - //If street names stay the same and if we are certain that it is not a - //a segment of a roundabout, we skip it. - if( data1.nameID == data2.nameID ) { - //TODO: Here we should also do a small graph exploration to check for + // If street names stay the same and if we are certain that it is not a + // a segment of a roundabout, we skip it. + if (data1.nameID == data2.nameID) + { + // TODO: Here we should also do a small graph exploration to check for // more complex situations - if( 0 != data1.nameID ) { + if (0 != data1.nameID) + { return TurnInstruction::NoTurn; - } else if (m_node_based_graph->GetOutDegree(v) <= 2) { + } + else if (m_node_based_graph->GetOutDegree(v) <= 2) + { return TurnInstruction::NoTurn; } } - const double angle = GetAngleBetweenThreeFixedPointCoordinates ( - m_node_info_list[u], - m_node_info_list[v], - m_node_info_list[w] - ); + const double angle = GetAngleBetweenThreeFixedPointCoordinates( + m_node_info_list[u], m_node_info_list[v], m_node_info_list[w]); return TurnInstructionsClass::GetTurnDirectionOfInstruction(angle); } -unsigned EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const { +unsigned EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const +{ return m_number_of_edge_based_nodes; } - diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index a2506c5d0..663735d5e 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -58,94 +58,76 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -class EdgeBasedGraphFactory : boost::noncopyable { -public: +class EdgeBasedGraphFactory : boost::noncopyable +{ + public: struct SpeedProfileProperties; - explicit EdgeBasedGraphFactory( - const boost::shared_ptr& node_based_graph, - std::unique_ptr restricion_map, - std::vector & barrier_node_list, - std::vector & traffic_light_node_list, - std::vector & m_node_info_list, - SpeedProfileProperties & speed_profile - ); + explicit EdgeBasedGraphFactory(const boost::shared_ptr &node_based_graph, + std::unique_ptr restricion_map, + std::vector &barrier_node_list, + std::vector &traffic_light_node_list, + std::vector &m_node_info_list, + SpeedProfileProperties &speed_profile); - void Run( - const std::string & original_edge_data_filename, - const std::string & geometry_filename, - lua_State *myLuaState - ); + void Run(const std::string &original_edge_data_filename, + const std::string &geometry_filename, + lua_State *myLuaState); - void GetEdgeBasedEdges( DeallocatingVector< EdgeBasedEdge >& edges ); + void GetEdgeBasedEdges(DeallocatingVector &edges); - void GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes); + void GetEdgeBasedNodes(std::vector &nodes); - TurnInstruction AnalyzeTurn( - const NodeID u, - const NodeID v, - const NodeID w - ) const; + TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) const; - int GetTurnPenalty( - const NodeID u, - const NodeID v, - const NodeID w, - lua_State *myLuaState - ) const; + int GetTurnPenalty(const NodeID u, const NodeID v, const NodeID w, lua_State *myLuaState) const; unsigned GetNumberOfEdgeBasedNodes() const; - struct SpeedProfileProperties{ - SpeedProfileProperties() : - trafficSignalPenalty(0), - uTurnPenalty(0), - has_turn_penalty_function(false) - { } + struct SpeedProfileProperties + { + SpeedProfileProperties() + : trafficSignalPenalty(0), uTurnPenalty(0), has_turn_penalty_function(false) + { + } int trafficSignalPenalty; int uTurnPenalty; bool has_turn_penalty_function; } speed_profile; -private: + private: typedef NodeBasedDynamicGraph::NodeIterator NodeIterator; typedef NodeBasedDynamicGraph::EdgeIterator EdgeIterator; - typedef NodeBasedDynamicGraph::EdgeData EdgeData; + typedef NodeBasedDynamicGraph::EdgeData EdgeData; unsigned m_number_of_edge_based_nodes; - std::vector m_node_info_list; - std::vector m_edge_based_node_list; - DeallocatingVector m_edge_based_edge_list; + std::vector m_node_info_list; + std::vector m_edge_based_node_list; + DeallocatingVector m_edge_based_edge_list; - boost::shared_ptr m_node_based_graph; - boost::unordered_set m_barrier_nodes; - boost::unordered_set m_traffic_lights; + boost::shared_ptr m_node_based_graph; + boost::unordered_set m_barrier_nodes; + boost::unordered_set m_traffic_lights; - std::unique_ptr m_restriction_map; + std::unique_ptr m_restriction_map; - GeometryCompressor m_geometry_compressor; + GeometryCompressor m_geometry_compressor; void CompressGeometry(); void RenumberEdges(); void GenerateEdgeExpandedNodes(); - void GenerateEdgeExpandedEdges( - const std::string& original_edge_data_filename, - lua_State* lua_state - ); + void GenerateEdgeExpandedEdges(const std::string &original_edge_data_filename, + lua_State *lua_state); - void InsertEdgeBasedNode( - NodeBasedDynamicGraph::NodeIterator u, - NodeBasedDynamicGraph::NodeIterator v, - NodeBasedDynamicGraph::EdgeIterator e1, - bool belongsToTinyComponent - ); + void InsertEdgeBasedNode(NodeBasedDynamicGraph::NodeIterator u, + NodeBasedDynamicGraph::NodeIterator v, + NodeBasedDynamicGraph::EdgeIterator e1, + bool belongsToTinyComponent); - void FlushVectorToStream( - std::ofstream & edge_data_file, - std::vector & original_edge_data_vector - ) const; + void FlushVectorToStream(std::ofstream &edge_data_file, + std::vector &original_edge_data_vector) const; unsigned max_id; }; diff --git a/Contractor/GeometryCompressor.cpp b/Contractor/GeometryCompressor.cpp index 752a3d402..8a9ba6f5d 100644 --- a/Contractor/GeometryCompressor.cpp +++ b/Contractor/GeometryCompressor.cpp @@ -70,14 +70,14 @@ unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const void GeometryCompressor::SerializeInternalVector(const std::string &path) const { - boost::filesystem::fstream geometry_out_stream(path, std::ios::binary|std::ios::out); + boost::filesystem::fstream geometry_out_stream(path, std::ios::binary | std::ios::out); const unsigned number_of_compressed_geometries = m_compressed_geometries.size() + 1; BOOST_ASSERT(UINT_MAX != number_of_compressed_geometries); geometry_out_stream.write((char *)&number_of_compressed_geometries, sizeof(unsigned)); // write indices array unsigned prefix_sum_of_list_indices = 0; - for (auto & elem : m_compressed_geometries) + for (auto &elem : m_compressed_geometries) { geometry_out_stream.write((char *)&prefix_sum_of_list_indices, sizeof(unsigned)); @@ -94,7 +94,7 @@ void GeometryCompressor::SerializeInternalVector(const std::string &path) const unsigned control_sum = 0; // write compressed geometries - for (auto & elem : m_compressed_geometries) + for (auto &elem : m_compressed_geometries) { const std::vector ¤t_vector = elem; const unsigned unpacked_size = current_vector.size(); @@ -146,7 +146,8 @@ void GeometryCompressor::CompressEdge(const EdgeID edge_id_1, m_free_list.pop_back(); } - const boost::unordered_map::const_iterator iter = m_edge_id_to_list_index_map.find(edge_id_1); + const boost::unordered_map::const_iterator iter = + m_edge_id_to_list_index_map.find(edge_id_1); BOOST_ASSERT(iter != m_edge_id_to_list_index_map.end()); const unsigned edge_bucket_id1 = iter->second; BOOST_ASSERT(edge_bucket_id1 == GetPositionForID(edge_id_1)); diff --git a/Contractor/GeometryCompressor.h b/Contractor/GeometryCompressor.h index 39c92d45d..5cd9dcbee 100644 --- a/Contractor/GeometryCompressor.h +++ b/Contractor/GeometryCompressor.h @@ -56,7 +56,7 @@ class GeometryCompressor private: void IncreaseFreeList(); - std::vector > m_compressed_geometries; + std::vector> m_compressed_geometries; std::vector m_free_list; boost::unordered_map m_edge_id_to_list_index_map; }; diff --git a/Contractor/TemporaryStorage.cpp b/Contractor/TemporaryStorage.cpp index d0e160b6f..582d7e66f 100644 --- a/Contractor/TemporaryStorage.cpp +++ b/Contractor/TemporaryStorage.cpp @@ -27,136 +27,154 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "TemporaryStorage.h" -TemporaryStorage::TemporaryStorage() { - temp_directory = boost::filesystem::temp_directory_path(); -} +TemporaryStorage::TemporaryStorage() { temp_directory = boost::filesystem::temp_directory_path(); } -TemporaryStorage & TemporaryStorage::GetInstance(){ +TemporaryStorage &TemporaryStorage::GetInstance() +{ static TemporaryStorage static_instance; return static_instance; } -TemporaryStorage::~TemporaryStorage() { - RemoveAll(); -} +TemporaryStorage::~TemporaryStorage() { RemoveAll(); } -void TemporaryStorage::RemoveAll() { +void TemporaryStorage::RemoveAll() +{ boost::mutex::scoped_lock lock(mutex); - for(unsigned slot_id = 0; slot_id < stream_data_list.size(); ++slot_id) { + for (unsigned slot_id = 0; slot_id < stream_data_list.size(); ++slot_id) + { DeallocateSlot(slot_id); } stream_data_list.clear(); } -int TemporaryStorage::AllocateSlot() { +int TemporaryStorage::AllocateSlot() +{ boost::mutex::scoped_lock lock(mutex); - try { + try + { stream_data_list.push_back(StreamData()); - } catch(boost::filesystem::filesystem_error & e) { + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } CheckIfTemporaryDeviceFull(); return stream_data_list.size() - 1; } -void TemporaryStorage::DeallocateSlot(const int slot_id) { - try { - StreamData & data = stream_data_list[slot_id]; +void TemporaryStorage::DeallocateSlot(const int slot_id) +{ + try + { + StreamData &data = stream_data_list[slot_id]; boost::mutex::scoped_lock lock(*data.readWriteMutex); - if(!boost::filesystem::exists(data.temp_path)) { + if (!boost::filesystem::exists(data.temp_path)) + { return; } - if(data.temp_file->is_open()) { + if (data.temp_file->is_open()) + { data.temp_file->close(); } boost::filesystem::remove(data.temp_path); - } catch(boost::filesystem::filesystem_error & e) { + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } } -void TemporaryStorage::WriteToSlot( - const int slot_id, - char * pointer, - const std::size_t size -) { - try { - StreamData & data = stream_data_list[slot_id]; +void TemporaryStorage::WriteToSlot(const int slot_id, char *pointer, const std::size_t size) +{ + try + { + StreamData &data = stream_data_list[slot_id]; BOOST_ASSERT(data.write_mode); boost::mutex::scoped_lock lock(*data.readWriteMutex); - BOOST_ASSERT_MSG( - data.write_mode, - "Writing after first read is not allowed" - ); - if( 1073741824 < data.buffer.size() ) { + BOOST_ASSERT_MSG(data.write_mode, "Writing after first read is not allowed"); + if (1073741824 < data.buffer.size()) + { data.temp_file->write(&data.buffer[0], data.buffer.size()); // data.temp_file->write(pointer, size); data.buffer.clear(); CheckIfTemporaryDeviceFull(); } - data.buffer.insert(data.buffer.end(), pointer, pointer+size); - - } catch(boost::filesystem::filesystem_error & e) { + data.buffer.insert(data.buffer.end(), pointer, pointer + size); + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } } -void TemporaryStorage::ReadFromSlot( - const int slot_id, - char * pointer, - const std::size_t size -) { - try { - StreamData & data = stream_data_list[slot_id]; +void TemporaryStorage::ReadFromSlot(const int slot_id, char *pointer, const std::size_t size) +{ + try + { + StreamData &data = stream_data_list[slot_id]; boost::mutex::scoped_lock lock(*data.readWriteMutex); - if( data.write_mode ) { + if (data.write_mode) + { data.write_mode = false; data.temp_file->write(&data.buffer[0], data.buffer.size()); data.buffer.clear(); - data.temp_file->seekg( data.temp_file->beg ); - BOOST_ASSERT( data.temp_file->beg == data.temp_file->tellg() ); + data.temp_file->seekg(data.temp_file->beg); + BOOST_ASSERT(data.temp_file->beg == data.temp_file->tellg()); } - BOOST_ASSERT( !data.write_mode ); + BOOST_ASSERT(!data.write_mode); data.temp_file->read(pointer, size); - } catch(boost::filesystem::filesystem_error & e) { + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } } -uint64_t TemporaryStorage::GetFreeBytesOnTemporaryDevice() { +uint64_t TemporaryStorage::GetFreeBytesOnTemporaryDevice() +{ uint64_t value = -1; - try { - boost::filesystem::path p = boost::filesystem::temp_directory_path(); - boost::filesystem::space_info s = boost::filesystem::space( p ); + try + { + boost::filesystem::path p = boost::filesystem::temp_directory_path(); + boost::filesystem::space_info s = boost::filesystem::space(p); value = s.free; - } catch(boost::filesystem::filesystem_error & e) { + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } return value; } -void TemporaryStorage::CheckIfTemporaryDeviceFull() { +void TemporaryStorage::CheckIfTemporaryDeviceFull() +{ boost::filesystem::path p = boost::filesystem::temp_directory_path(); - boost::filesystem::space_info s = boost::filesystem::space( p ); - if( (1024*1024) > s.free ) { + boost::filesystem::space_info s = boost::filesystem::space(p); + if ((1024 * 1024) > s.free) + { throw OSRMException("temporary device is full"); } } -boost::filesystem::fstream::pos_type TemporaryStorage::Tell(const int slot_id) { +boost::filesystem::fstream::pos_type TemporaryStorage::Tell(const int slot_id) +{ boost::filesystem::fstream::pos_type position; - try { - StreamData & data = stream_data_list[slot_id]; + try + { + StreamData &data = stream_data_list[slot_id]; boost::mutex::scoped_lock lock(*data.readWriteMutex); position = data.temp_file->tellp(); - } catch(boost::filesystem::filesystem_error & e) { + } + catch (boost::filesystem::filesystem_error &e) + { Abort(e); } return position; } -void TemporaryStorage::Abort(const boost::filesystem::filesystem_error& e) { +void TemporaryStorage::Abort(const boost::filesystem::filesystem_error &e) +{ RemoveAll(); throw OSRMException(e.what()); } diff --git a/Contractor/TemporaryStorage.h b/Contractor/TemporaryStorage.h index 5704e7dd8..ee80662ea 100644 --- a/Contractor/TemporaryStorage.h +++ b/Contractor/TemporaryStorage.h @@ -56,61 +56,52 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. static boost::filesystem::path temp_directory; static std::string TemporaryFilePattern("OSRM-%%%%-%%%%-%%%%"); -class TemporaryStorage { -public: - static TemporaryStorage & GetInstance(); +class TemporaryStorage +{ + public: + static TemporaryStorage &GetInstance(); virtual ~TemporaryStorage(); int AllocateSlot(); void DeallocateSlot(const int slot_id); - void WriteToSlot(const int slot_id, char * pointer, const std::size_t size); - void ReadFromSlot(const int slot_id, char * pointer, const std::size_t size); - //returns the number of free bytes + void WriteToSlot(const int slot_id, char *pointer, const std::size_t size); + void ReadFromSlot(const int slot_id, char *pointer, const std::size_t size); + // returns the number of free bytes uint64_t GetFreeBytesOnTemporaryDevice(); boost::filesystem::fstream::pos_type Tell(const int slot_id); void RemoveAll(); -private: + + private: TemporaryStorage(); - TemporaryStorage(TemporaryStorage const &){}; + TemporaryStorage(TemporaryStorage const &) {}; - TemporaryStorage & operator=(TemporaryStorage const &) { - return *this; - } + TemporaryStorage &operator=(TemporaryStorage const &) { return *this; } - void Abort(const boost::filesystem::filesystem_error& e); + void Abort(const boost::filesystem::filesystem_error &e); void CheckIfTemporaryDeviceFull(); - struct StreamData { + struct StreamData + { bool write_mode; boost::filesystem::path temp_path; boost::shared_ptr temp_file; boost::shared_ptr readWriteMutex; std::vector buffer; - StreamData() : - write_mode(true), - temp_path( - boost::filesystem::unique_path( - temp_directory.append( - TemporaryFilePattern.begin(), - TemporaryFilePattern.end() - ) - ) - ), - temp_file( - new boost::filesystem::fstream( - temp_path, - std::ios::in|std::ios::out|std::ios::trunc|std::ios::binary - ) - ), - readWriteMutex(boost::make_shared()) + StreamData() + : write_mode(true), temp_path(boost::filesystem::unique_path(temp_directory.append( + TemporaryFilePattern.begin(), TemporaryFilePattern.end()))), + temp_file(new boost::filesystem::fstream( + temp_path, std::ios::in | std::ios::out | std::ios::trunc | std::ios::binary)), + readWriteMutex(boost::make_shared()) { - if( temp_file->fail() ) { + if (temp_file->fail()) + { throw OSRMException("temporary file could not be created"); } } }; - //vector of file streams that is used to store temporary data + // vector of file streams that is used to store temporary data boost::mutex mutex; std::vector stream_data_list; };