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

First set of changes toward edge-based graph

Browse Source
This commit is contained in:
DennisOSRM 2011-11-09 16:12:05 +01:00
parent 43438dbfab
commit eb9630251f
8 changed files with 217 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Contractor/Contractor.h
View File

@ -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 );

171
Contractor/EdgeBasedGraphFactory.cpp
View File

@ -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 <parallel/algorithm>
#else
#include <algorithm>
#endif
#include <boost/foreach.hpp>
#include "EdgeBasedGraphFactory.h"
#include "../DataStructures/ExtractorStructs.h"
template<>
EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inputEdges) {
std::vector< _ImportEdge > edges;
EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & 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 );
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;
_nodeBasedGraph.reset(new _NodeBasedDynamicGraph( nodes, edges ));
INFO("Converted " << inputEdges.size() << " node-based edges into " << _nodeBasedGraph->GetNumberOfEdges() << " edge-based nodes.");
}
_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++;
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);
}
//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;
#ifdef _GLIBCXX_PARALLEL
__gnu_parallel::sort( edges.begin(), edges.end() );
#else
sort( edges.begin(), edges.end() );
#endif
}
} else { //insert seperate edges
if ( (int)forwardEdge.data.distance != (std::numeric_limits< int >::max)() ) {
edges[edge++] = forwardEdge;
template< class NodeT>
void EdgeBasedGraphFactory::GetNodes( std::vector< NodeT> & nodes) {
}
if ( (int)backwardEdge.data.distance != (std::numeric_limits< int >::max)() ) {
edges[edge++] = backwardEdge;
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;
}
}
}
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 );
}
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);
}

41
Contractor/EdgeBasedGraphFactory.h
View File

@ -25,8 +25,15 @@
#ifndef EDGEBASEDGRAPHFACTORY_H_
#define EDGEBASEDGRAPHFACTORY_H_
#include <boost/shared_ptr.hpp>
#include <vector>
#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<InputEdgeT> & inputEdges);
explicit EdgeBasedGraphFactory(int nodes, std::vector<InputEdgeT> & 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_ */

2
DataStructures/DynamicGraph.h
View File

@ -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++;
}
}

6
DataStructures/ExtractorStructs.h
View File

@ -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;

43
createHierarchy.cpp
View File

@ -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<EdgeData>::InputEdge InputEdge;
typedef StaticGraph<EdgeData>::InputEdge StaticEdge;
typedef BaseConfiguration ContractorConfiguration;
vector<NodeInfo> * int2ExtNodeMap = new vector<NodeInfo>();
vector<NodeInfo> int2ExtNodeMap;
vector<_Restriction> inputRestrictions;
int main (int argc, char *argv[]) {
if(argc <= 1) {
cerr << "usage: " << endl << argv[0] << " <osrm-data>" << 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<ImportEdge> 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<ImportEdge> 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;

4
extractor.cpp
View File

@ -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();

10
server.ini
View File

@ -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