From eb9630251f0a585141636c5146e3b6910cc0d068 Mon Sep 17 00:00:00 2001 From: DennisOSRM Date: Wed, 9 Nov 2011 16:12:05 +0100 Subject: [PATCH] First set of changes toward edge-based graph --- Contractor/Contractor.h | 24 ++-- Contractor/EdgeBasedGraphFactory.cpp | 189 +++++++++++++++++---------- Contractor/EdgeBasedGraphFactory.h | 41 +++++- DataStructures/DynamicGraph.h | 2 +- DataStructures/ExtractorStructs.h | 6 +- createHierarchy.cpp | 43 ++++-- extractor.cpp | 4 +- server.ini | 10 +- 8 files changed, 217 insertions(+), 102 deletions(-) diff --git a/Contractor/Contractor.h b/Contractor/Contractor.h index 9cef5cc67..974922485 100644 --- a/Contractor/Contractor.h +++ b/Contractor/Contractor.h @@ -155,31 +155,32 @@ public: forwardEdge.data.middleName.nameID = backwardEdge.data.middleName.nameID = middle; forwardEdge.data.shortcut = backwardEdge.data.shortcut = false; forwardEdge.data.originalEdges = backwardEdge.data.originalEdges = 1; - forwardEdge.data.distance = backwardEdge.data.distance = (std::numeric_limits< int >::max)(); + 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 = 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 ); + 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)() ) { + if ( (int)forwardEdge.data.distance != std::numeric_limits< int >::max() ) { forwardEdge.data.backward = true; edges[edge++] = forwardEdge; } } else { //insert seperate edges - if ( (int)forwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { + if ( ((int)forwardEdge.data.distance) != std::numeric_limits< int >::max() ) { edges[edge++] = forwardEdge; } - if ( (int)backwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { + if ( (int)backwardEdge.data.distance != std::numeric_limits< int >::max() ) { edges[edge++] = backwardEdge; } } } - cout << "ok" << endl << "removed " << edges.size() - edge << " edges of " << edges.size() << endl; + cout << "ok" << endl << "merged " << edges.size() - edge << " edges out of " << edges.size() << endl; + INFO("Contractor holds " << edge << " edges"); edges.resize( edge ); _graph = new _DynamicGraph( nodes, edges ); std::vector< _ImportEdge >().swap( edges ); @@ -375,8 +376,6 @@ public: } private: - bool _ConstructCH( _DynamicGraph* _graph ); - void _Dijkstra( NodeID source, const int maxDistance, const unsigned numTargets, _ThreadData* data ){ _Heap& heap = data->heap; @@ -427,6 +426,12 @@ private: return edgeQuotionFactor * ((( double ) stats.edgesAdded ) / stats.edgesDeleted ) + originalQuotientFactor * ((( double ) stats.originalEdgesAdded ) / stats.originalEdgesDeleted ) + depthFactor * nodeData->depth; } + /* + 8 * numAdded / numDeleted + 4 * numOriginalAdded / numOriginalDeleted + 2 * Tiefe + Kante einfüge = numAdded += 2 && numOriginalAdded += 2 * numOriginal + Kante löschen = numDeleted += 1 && numOriginalAdded += numOriginal + */ + template< class Edge > bool _CheckCH() { @@ -475,7 +480,6 @@ private: if ( node != source ) heap.Insert( node, inData.distance, _HeapData() ); int maxDistance = 0; - //unsigned numTargets = 0; for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) { const _EdgeData& outData = _graph->GetEdgeData( outEdge ); diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 8ba511f10..f7b1b986f 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -18,99 +18,154 @@ or see http://www.gnu.org/licenses/agpl.txt. */ -#include "../typedefs.h" -#include "../DataStructures/DynamicGraph.h" -#include "../DataStructures/ImportEdge.h" +#ifdef _GLIBCXX_PARALLEL +#include +#else +#include +#endif +#include + #include "EdgeBasedGraphFactory.h" +#include "../DataStructures/ExtractorStructs.h" template<> -EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector & inputEdges) { - std::vector< _ImportEdge > edges; +EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector & inputEdges, std::vector<_Restriction> & irs) : inputRestrictions(irs) { + +#ifdef _GLIBCXX_PARALLEL + __gnu_parallel::sort(inputRestrictions.begin(), inputRestrictions.end(), CmpRestrictionByFrom); +#else + std::sort(inputRestrictions.begin(), inputRestrictions.end(), CmpRestrictionByFrom); +#endif + + std::vector< _NodeBasedEdge > edges; edges.reserve( 2 * inputEdges.size() ); for ( typename std::vector< Edge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) { - _ImportEdge edge; + _NodeBasedEdge edge; edge.source = i->source(); edge.target = i->target(); + if(edge.source == edge.target) + continue; + edge.data.distance = (std::max)((int)i->weight(), 1 ); assert( edge.data.distance > 0 ); -#ifdef DEBUG - if ( edge.data.distance > 24 * 60 * 60 * 10 ) { - cout << "Edge Weight too large -> May lead to invalid CH" << endl; - continue; - } -#endif edge.data.shortcut = false; edge.data.middleName.nameID = i->name(); edge.data.type = i->type(); edge.data.forward = i->isForward(); edge.data.backward = i->isBackward(); - edge.data.originalEdges = 1; + edge.data.newNodeID = edges.size(); edges.push_back( edge ); std::swap( edge.source, edge.target ); - edge.data.forward = i->isBackward(); - edge.data.backward = i->isForward(); - edges.push_back( edge ); + if( edge.data.backward ) { + edge.data.forward = i->isBackward(); + edge.data.backward = i->isForward(); + edge.data.newNodeID = edges.size(); + edges.push_back( edge ); + } } - // std::vector< InputEdgeT >().swap( inputEdges ); //free memory + + INFO("edges.size()=" << edges.size()); + #ifdef _GLIBCXX_PARALLEL __gnu_parallel::sort( edges.begin(), edges.end() ); #else sort( edges.begin(), edges.end() ); #endif - NodeID edge = 0; - for ( NodeID i = 0; i < edges.size(); ) { - const NodeID source = edges[i].source; - const NodeID target = edges[i].target; - const NodeID middle = edges[i].data.middleName.nameID; - const short type = edges[i].data.type; - assert(type >= 0); - //remove eigenloops - if ( source == target ) { - i++; - continue; - } - _ImportEdge forwardEdge; - _ImportEdge backwardEdge; - forwardEdge.source = backwardEdge.source = source; - forwardEdge.target = backwardEdge.target = target; - forwardEdge.data.forward = backwardEdge.data.backward = true; - forwardEdge.data.backward = backwardEdge.data.forward = false; - forwardEdge.data.type = backwardEdge.data.type = type; - forwardEdge.data.middleName.nameID = backwardEdge.data.middleName.nameID = middle; - forwardEdge.data.shortcut = backwardEdge.data.shortcut = false; - 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 ); - 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)() ) { - forwardEdge.data.backward = true; - edges[edge++] = forwardEdge; - } - } else { //insert seperate edges - if ( (int)forwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { - edges[edge++] = forwardEdge; - } - if ( (int)backwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { - edges[edge++] = backwardEdge; - } - } + + _nodeBasedGraph.reset(new _NodeBasedDynamicGraph( nodes, edges )); + INFO("Converted " << inputEdges.size() << " node-based edges into " << _nodeBasedGraph->GetNumberOfEdges() << " edge-based nodes."); +} + +template<> +void EdgeBasedGraphFactory::GetEdges( std::vector< ImportEdge >& edges ) { + + GUARANTEE(0 == edges.size(), "Vector passed to " << __FUNCTION__ << " is not empty"); + GUARANTEE(0 != edgeBasedEdges.size(), "No edges in edge based graph"); + + for ( unsigned edge = 0; edge < edgeBasedEdges.size(); ++edge ) { + ImportEdge importEdge(edgeBasedEdges[edge].source, edgeBasedEdges[edge].target, edgeBasedEdges[edge].data.distance, edgeBasedEdges[edge].data.distance, true, false, edgeBasedEdges[edge].data.type); + edges.push_back(importEdge); } - cout << "ok" << endl << "removed " << edges.size() - edge << " edges of " << edges.size() << endl; - edges.resize( edge ); - _graph = new _NodeBasedDynamicGraph( nodes, edges ); - std::vector< _ImportEdge >().swap( edges ); + +#ifdef _GLIBCXX_PARALLEL + __gnu_parallel::sort( edges.begin(), edges.end() ); +#else + sort( edges.begin(), edges.end() ); +#endif + +} + + +template< class NodeT> +void EdgeBasedGraphFactory::GetNodes( std::vector< NodeT> & nodes) { + +} + +void EdgeBasedGraphFactory::Run() { + INFO("Generating Edge based representation of input data"); + + _edgeBasedGraph.reset(new _EdgeBasedDynamicGraph(_nodeBasedGraph->GetNumberOfEdges() ) ); + std::vector<_Restriction>::iterator restrictionIterator = inputRestrictions.begin(); + Percent p(_nodeBasedGraph->GetNumberOfNodes()); + int numberOfResolvedRestrictions(0); + int nodeBasedEdgeCounter(0); + + //Loop over all nodes u. Three nested loop look super-linear, but we are dealing with a number linear in the turns only. + for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) { + //loop over all adjacent edge (u,v) + while(restrictionIterator->fromNode < u && inputRestrictions.end() != restrictionIterator) { + ++restrictionIterator; + } + for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) { + ++nodeBasedEdgeCounter; + _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1); + //loop over all reachable edges (v,w) + for(_NodeBasedDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) { + _NodeBasedDynamicGraph::NodeIterator w = _nodeBasedGraph->GetTarget(e2); + //if (u,v,w) is a forbidden turn, continue + bool isTurnProhibited = false; + if( u != w ) { //only add an edge if turn is not a U-turn + if(u == restrictionIterator->fromNode) { + std::vector<_Restriction>::iterator secondRestrictionIterator = restrictionIterator; + do { + if( v == secondRestrictionIterator->viaNode && w == secondRestrictionIterator->toNode) { + isTurnProhibited = true; + } + ++secondRestrictionIterator; + } while(u == secondRestrictionIterator->fromNode); + } + if( !isTurnProhibited ) { //only add an edge if turn is not prohibited + //new costs for edge based edge (e1, e2) = cost (e1) + tc(e1,e2) + _NodeBasedDynamicGraph::NodeIterator edgeBasedSource = _nodeBasedGraph->GetEdgeData(e1).newNodeID; + _NodeBasedDynamicGraph::NodeIterator edgeBasedTarget = _nodeBasedGraph->GetEdgeData(e2).newNodeID; + _EdgeBasedEdge newEdge; + newEdge.source = edgeBasedSource; + newEdge.target = edgeBasedTarget; + //Todo: incorporate turn costs + newEdge.data.distance = _nodeBasedGraph->GetEdgeData(e1).distance; + newEdge.data.forward = true; + newEdge.data.backward = false; + newEdge.data.type = 3; + + edgeBasedEdges.push_back(newEdge); + } else { + ++numberOfResolvedRestrictions; + } + } + } + } + p.printIncrement(); + } + INFO("Node-based graph contains " << nodeBasedEdgeCounter << " edges"); + INFO("Edge-based graph contains " << edgeBasedEdges.size() << " edges, blowup is " << (double)edgeBasedEdges.size()/(double)nodeBasedEdgeCounter); + INFO("Edge-based graph obeys " << numberOfResolvedRestrictions << " turn restrictions, " << (inputRestrictions.size() - numberOfResolvedRestrictions )<< " skipped."); +} + +unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const { + return edgeBasedEdges.size(); } EdgeBasedGraphFactory::~EdgeBasedGraphFactory() { - DELETE(_graph); } diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index be60b20ec..74e9be6ab 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -25,8 +25,15 @@ #ifndef EDGEBASEDGRAPHFACTORY_H_ #define EDGEBASEDGRAPHFACTORY_H_ +#include #include +#include "../typedefs.h" +#include "../DataStructures/DynamicGraph.h" +#include "../DataStructures/ExtractorStructs.h" +#include "../DataStructures/ImportEdge.h" +#include "../DataStructures/Percent.h" + class EdgeBasedGraphFactory { private: union _MiddleName { @@ -36,27 +43,49 @@ private: struct _NodeBasedEdgeData { unsigned distance; + unsigned newNodeID; unsigned originalEdges : 29; bool shortcut : 1; bool forward : 1; bool backward : 1; short type:6; - bool forwardTurn:1; - bool backwardTurn:1; _MiddleName middleName; } data; - typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; - typedef typename _NodeBasedDynamicGraph::InputEdge _ImportEdge; + struct _EdgeBasedEdgeData { + unsigned distance; + unsigned instruction; + bool forward; + bool backward; + short type; + }; - _NodeBasedDynamicGraph * _graph; + typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; + typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge; + +public: + typedef DynamicGraph< _EdgeBasedEdgeData> _EdgeBasedDynamicGraph; + typedef _EdgeBasedDynamicGraph::InputEdge _EdgeBasedEdge; +private: + boost::shared_ptr<_NodeBasedDynamicGraph> _nodeBasedGraph; + boost::shared_ptr<_EdgeBasedDynamicGraph> _edgeBasedGraph; + + std::vector<_Restriction> & inputRestrictions; + + std::vector<_EdgeBasedEdge> edgeBasedEdges; public: template< class InputEdgeT > - explicit EdgeBasedGraphFactory(int nodes, std::vector & inputEdges); + explicit EdgeBasedGraphFactory(int nodes, std::vector & inputEdges, std::vector<_Restriction> & inputRestrictions); virtual ~EdgeBasedGraphFactory(); + void Run(); + template< class ImportEdgeT > + void GetEdges( std::vector< ImportEdgeT >& edges ); + template< class NodeT > + void GetNodes( std::vector< NodeT >& edges ); + unsigned GetNumberOfNodes() const; }; #endif /* EDGEBASEDGRAPHFACTORY_H_ */ diff --git a/DataStructures/DynamicGraph.h b/DataStructures/DynamicGraph.h index 02623b291..48465c916 100644 --- a/DataStructures/DynamicGraph.h +++ b/DataStructures/DynamicGraph.h @@ -75,7 +75,7 @@ class DynamicGraph { for ( EdgeIterator i = m_nodes[node].firstEdge, e = m_nodes[node].firstEdge + m_nodes[node].edges; i != e; ++i ) { m_edges[i].target = graph[edge].target; m_edges[i].data = graph[edge].data; - assert(graph[edge].data.distance > 0); + GUARANTEE(graph[edge].data.distance > 0, "edge: " << edge << "(" << graph[edge].source << "," << graph[edge].target << ")=" << graph[edge].data.distance); edge++; } } diff --git a/DataStructures/ExtractorStructs.h b/DataStructures/ExtractorStructs.h index a032397cd..26446a154 100644 --- a/DataStructures/ExtractorStructs.h +++ b/DataStructures/ExtractorStructs.h @@ -164,6 +164,8 @@ struct _Restriction { } }; +inline bool CmpRestrictionByFrom ( _Restriction a, _Restriction b) { return (a.fromNode < b.fromNode); } + struct _RawRestrictionContainer { _Restriction restriction; EdgeID fromWay; @@ -181,7 +183,7 @@ struct _RawRestrictionContainer { } }; -struct CmpRestrictionByFrom: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { +struct CmpRestrictionContainerByFrom: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { typedef _RawRestrictionContainer value_type; bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { return a.fromWay < b.fromWay; @@ -194,7 +196,7 @@ struct CmpRestrictionByFrom: public std::binary_function<_RawRestrictionContaine } }; -struct CmpRestrictionByTo: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { +struct CmpRestrictionContainerByTo: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { typedef _RawRestrictionContainer value_type; bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { return a.toWay < b.toWay; diff --git a/createHierarchy.cpp b/createHierarchy.cpp index a25976013..98162f2e1 100644 --- a/createHierarchy.cpp +++ b/createHierarchy.cpp @@ -18,7 +18,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA or see http://www.gnu.org/licenses/agpl.txt. */ -//g++ createHierarchy.cpp -fopenmp -Wno-deprecated -o createHierarchy -O3 -march=native -DNDEBUG +//g++ createHierarchy.cpp -fopenmp -Wno-deprecated -o createHierarchy -O3 -march=native -DNDEBUG -I/usr/include/libxml2 -lstxxl #define VERBOSE(x) x #define VERBOSE2(x) @@ -43,7 +43,9 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "typedefs.h" #include "Contractor/Contractor.h" #include "Contractor/ContractionCleanup.h" +#include "Contractor/EdgeBasedGraphFactory.h" #include "DataStructures/BinaryHeap.h" +#include "DataStructures/ExtractorStructs.h" #include "DataStructures/LevelInformation.h" #include "DataStructures/NNGrid.h" #include "Util/BaseConfiguration.h" @@ -56,13 +58,27 @@ typedef DynamicGraph::InputEdge InputEdge; typedef StaticGraph::InputEdge StaticEdge; typedef BaseConfiguration ContractorConfiguration; -vector * int2ExtNodeMap = new vector(); +vector int2ExtNodeMap; +vector<_Restriction> inputRestrictions; int main (int argc, char *argv[]) { if(argc <= 1) { cerr << "usage: " << endl << argv[0] << " " << endl; exit(-1); } + if(argc == 3) { + INFO("Using restrictions from file: " << argv[2]); + ifstream restrictionsInstream(argv[2], ios::binary); + _Restriction restriction; + unsigned usableRestrictionsCounter(0); + restrictionsInstream.read((char*)&usableRestrictionsCounter, sizeof(unsigned)); + for(unsigned i = 0; i < usableRestrictionsCounter; ++i) { + restrictionsInstream.read((char *)&(restriction), sizeof(_Restriction)); + inputRestrictions.push_back(restriction); + } + restrictionsInstream.close(); + INFO("Loaded " << inputRestrictions.size() << " restrictions from file"); + } unsigned numberOfThreads = omp_get_num_procs(); if(testDataFile("contractor.ini")) { @@ -84,10 +100,18 @@ int main (int argc, char *argv[]) { if (!in.is_open()) { cerr << "Cannot open " << argv[1] << endl; exit(-1); } + vector edgeList; - const NodeID n = readBinaryOSRMGraphFromStream(in, edgeList, int2ExtNodeMap); + NodeID n = readBinaryOSRMGraphFromStream(in, edgeList, &int2ExtNodeMap, inputRestrictions); in.close(); + EdgeBasedGraphFactory * edgeBasedGraphFactory = new EdgeBasedGraphFactory (n, edgeList, inputRestrictions); + edgeBasedGraphFactory->Run(); + n = edgeBasedGraphFactory->GetNumberOfNodes(); + std::vector edgeBasedEdgeList; + edgeBasedGraphFactory->GetEdges(edgeBasedEdgeList); + DELETE(edgeBasedGraphFactory); + char nodeOut[1024]; char edgeOut[1024]; char ramIndexOut[1024]; @@ -106,8 +130,10 @@ int main (int argc, char *argv[]) { strcat(levelInfoOut, ".levels"); cout << "initializing contractor ..." << flush; - Contractor* contractor = new Contractor( n, edgeList ); + Contractor* contractor = new Contractor( n, edgeBasedEdgeList ); + double contractionStartedTimestamp(get_timestamp()); contractor->Run(); + INFO("Contraction took " << get_timestamp() - contractionStartedTimestamp << " sec"); LevelInformation * levelInfo = contractor->GetLevelInformation(); std::cout << "sorting level info" << std::endl; @@ -179,19 +205,18 @@ int main (int argc, char *argv[]) { std::cout << "writing node map ..." << std::flush; ofstream mapOutFile(nodeOut, ios::binary); - for(NodeID i = 0; i < int2ExtNodeMap->size(); i++) { - mapOutFile.write((char *)&(int2ExtNodeMap->at(i)), sizeof(NodeInfo)); + for(NodeID i = 0; i < int2ExtNodeMap.size(); i++) { + mapOutFile.write((char *)&(int2ExtNodeMap.at(i)), sizeof(NodeInfo)); } mapOutFile.close(); std::cout << "ok" << std::endl; WritableGrid * writeableGrid = new WritableGrid(); cout << "building grid ..." << flush; - writeableGrid->ConstructGrid(edgeList, int2ExtNodeMap, ramIndexOut, fileIndexOut); + writeableGrid->ConstructGrid(edgeList, &int2ExtNodeMap, ramIndexOut, fileIndexOut); delete writeableGrid; - int2ExtNodeMap->clear(); - delete int2ExtNodeMap; + int2ExtNodeMap.clear(); cout << "finished" << endl; return 0; diff --git a/extractor.cpp b/extractor.cpp index a345fb2b4..83376a7ae 100644 --- a/extractor.cpp +++ b/extractor.cpp @@ -220,7 +220,7 @@ int main (int argc, char *argv[]) { cout << "ok, after " << get_timestamp() - time << "s" << endl; cout << "[extractor] Sorting restrctns. by from... " << flush; - stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByFrom(), memory_to_use); + stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionContainerByFrom(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; cout << "[extractor] Fixing restriction starts ... " << flush; @@ -255,7 +255,7 @@ int main (int argc, char *argv[]) { time = get_timestamp(); cout << "[extractor] Sorting restrctns. by to ... " << flush; - stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByTo(), memory_to_use); + stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionContainerByTo(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); diff --git a/server.ini b/server.ini index fbf0108d2..66f6af9c2 100644 --- a/server.ini +++ b/server.ini @@ -2,8 +2,8 @@ Threads = 8 IP = 0.0.0.0 Port = 5000 -hsgrData=/opt/osm/germany.osrm.hsgr -nodesData=/opt/osm/germany.osrm.nodes -ramIndex=/opt/osm/germany.osrm.ramIndex -fileIndex=/opt/osm/germany.osrm.fileIndex -namesData=/opt/osm/germany.osrm.names +hsgrData=/opt/osm/berlin.osrm.hsgr +nodesData=/opt/osm/berlin.osrm.nodes +ramIndex=/opt/osm/berlin.osrm.ramIndex +fileIndex=/opt/osm/berlin.osrm.fileIndex +namesData=/opt/osm/berlin.osrm.names