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.middleName.nameID = backwardEdge.data.middleName.nameID = middle;
forwardEdge.data.shortcut = backwardEdge.data.shortcut = false; forwardEdge.data.shortcut = backwardEdge.data.shortcut = false;
forwardEdge.data.originalEdges = backwardEdge.data.originalEdges = 1; 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 //remove parallel edges
while ( i < edges.size() && edges[i].source == source && edges[i].target == target ) { while ( i < edges.size() && edges[i].source == source && edges[i].target == target ) {
if ( edges[i].data.forward ) 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 ) 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++; i++;
} }
//merge edges (s,t) and (t,s) into bidirectional edge //merge edges (s,t) and (t,s) into bidirectional edge
if ( forwardEdge.data.distance == backwardEdge.data.distance ) { 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; forwardEdge.data.backward = true;
edges[edge++] = forwardEdge; edges[edge++] = forwardEdge;
} }
} else { //insert seperate edges } 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; 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; 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 ); edges.resize( edge );
_graph = new _DynamicGraph( nodes, edges ); _graph = new _DynamicGraph( nodes, edges );
std::vector< _ImportEdge >().swap( edges ); std::vector< _ImportEdge >().swap( edges );
@ -375,8 +376,6 @@ public:
} }
private: private:
bool _ConstructCH( _DynamicGraph* _graph );
void _Dijkstra( NodeID source, const int maxDistance, const unsigned numTargets, _ThreadData* data ){ void _Dijkstra( NodeID source, const int maxDistance, const unsigned numTargets, _ThreadData* data ){
_Heap& heap = data->heap; _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; 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 > template< class Edge >
bool _CheckCH() bool _CheckCH()
{ {
@ -475,7 +480,6 @@ private:
if ( node != source ) if ( node != source )
heap.Insert( node, inData.distance, _HeapData() ); heap.Insert( node, inData.distance, _HeapData() );
int maxDistance = 0; int maxDistance = 0;
//unsigned numTargets = 0;
for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) { for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
const _EdgeData& outData = _graph->GetEdgeData( 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. or see http://www.gnu.org/licenses/agpl.txt.
*/ */
#include "../typedefs.h" #ifdef _GLIBCXX_PARALLEL
#include "../DataStructures/DynamicGraph.h" #include <parallel/algorithm>
#include "../DataStructures/ImportEdge.h" #else
#include <algorithm>
#endif
#include <boost/foreach.hpp>
#include "EdgeBasedGraphFactory.h" #include "EdgeBasedGraphFactory.h"
#include "../DataStructures/ExtractorStructs.h"
template<> template<>
EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inputEdges) { EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<Edge> & inputEdges, std::vector<_Restriction> & irs) : inputRestrictions(irs) {
std::vector< _ImportEdge > edges;
#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() ); edges.reserve( 2 * inputEdges.size() );
for ( typename std::vector< Edge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) { 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.source = i->source();
edge.target = i->target(); edge.target = i->target();
if(edge.source == edge.target)
continue;
edge.data.distance = (std::max)((int)i->weight(), 1 ); edge.data.distance = (std::max)((int)i->weight(), 1 );
assert( edge.data.distance > 0 ); 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.shortcut = false;
edge.data.middleName.nameID = i->name(); edge.data.middleName.nameID = i->name();
edge.data.type = i->type(); edge.data.type = i->type();
edge.data.forward = i->isForward(); edge.data.forward = i->isForward();
edge.data.backward = i->isBackward(); edge.data.backward = i->isBackward();
edge.data.originalEdges = 1; edge.data.newNodeID = edges.size();
edges.push_back( edge ); edges.push_back( edge );
std::swap( edge.source, edge.target ); std::swap( edge.source, edge.target );
if( edge.data.backward ) {
edge.data.forward = i->isBackward(); edge.data.forward = i->isBackward();
edge.data.backward = i->isForward(); edge.data.backward = i->isForward();
edge.data.newNodeID = edges.size();
edges.push_back( edge ); edges.push_back( edge );
} }
// std::vector< InputEdgeT >().swap( inputEdges ); //free memory }
INFO("edges.size()=" << edges.size());
#ifdef _GLIBCXX_PARALLEL #ifdef _GLIBCXX_PARALLEL
__gnu_parallel::sort( edges.begin(), edges.end() ); __gnu_parallel::sort( edges.begin(), edges.end() );
#else #else
sort( edges.begin(), edges.end() ); sort( edges.begin(), edges.end() );
#endif #endif
NodeID edge = 0;
for ( NodeID i = 0; i < edges.size(); ) { _nodeBasedGraph.reset(new _NodeBasedDynamicGraph( nodes, edges ));
const NodeID source = edges[i].source; INFO("Converted " << inputEdges.size() << " node-based edges into " << _nodeBasedGraph->GetNumberOfEdges() << " edge-based nodes.");
const NodeID target = edges[i].target; }
const NodeID middle = edges[i].data.middleName.nameID;
const short type = edges[i].data.type; template<>
assert(type >= 0); void EdgeBasedGraphFactory::GetEdges( std::vector< ImportEdge >& edges ) {
//remove eigenloops
if ( source == target ) { GUARANTEE(0 == edges.size(), "Vector passed to " << __FUNCTION__ << " is not empty");
i++; GUARANTEE(0 != edgeBasedEdges.size(), "No edges in edge based graph");
continue;
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);
} }
_ImportEdge forwardEdge;
_ImportEdge backwardEdge; #ifdef _GLIBCXX_PARALLEL
forwardEdge.source = backwardEdge.source = source; __gnu_parallel::sort( edges.begin(), edges.end() );
forwardEdge.target = backwardEdge.target = target; #else
forwardEdge.data.forward = backwardEdge.data.backward = true; sort( edges.begin(), edges.end() );
forwardEdge.data.backward = backwardEdge.data.forward = false; #endif
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)(); template< class NodeT>
//remove parallel edges void EdgeBasedGraphFactory::GetNodes( std::vector< NodeT> & nodes) {
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 ) void EdgeBasedGraphFactory::Run() {
backwardEdge.data.distance = (std::min)( edges[i].data.distance, backwardEdge.data.distance ); INFO("Generating Edge based representation of input data");
i++;
_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;
} }
//merge edges (s,t) and (t,s) into bidirectional edge for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
if ( forwardEdge.data.distance == backwardEdge.data.distance ) { ++nodeBasedEdgeCounter;
if ( (int)forwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
forwardEdge.data.backward = true; //loop over all reachable edges (v,w)
edges[edge++] = forwardEdge; 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;
} }
} else { //insert seperate edges ++secondRestrictionIterator;
if ( (int)forwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { } while(u == secondRestrictionIterator->fromNode);
edges[edge++] = forwardEdge;
} }
if ( (int)backwardEdge.data.distance != (std::numeric_limits< int >::max)() ) { if( !isTurnProhibited ) { //only add an edge if turn is not prohibited
edges[edge++] = backwardEdge; //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 ); p.printIncrement();
_graph = new _NodeBasedDynamicGraph( nodes, edges ); }
std::vector< _ImportEdge >().swap( edges ); 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() { EdgeBasedGraphFactory::~EdgeBasedGraphFactory() {
DELETE(_graph);
} }

41
Contractor/EdgeBasedGraphFactory.h
View File

@ -25,8 +25,15 @@
#ifndef EDGEBASEDGRAPHFACTORY_H_ #ifndef EDGEBASEDGRAPHFACTORY_H_
#define EDGEBASEDGRAPHFACTORY_H_ #define EDGEBASEDGRAPHFACTORY_H_
#include <boost/shared_ptr.hpp>
#include <vector> #include <vector>
#include "../typedefs.h"
#include "../DataStructures/DynamicGraph.h"
#include "../DataStructures/ExtractorStructs.h"
#include "../DataStructures/ImportEdge.h"
#include "../DataStructures/Percent.h"
class EdgeBasedGraphFactory { class EdgeBasedGraphFactory {
private: private:
union _MiddleName { union _MiddleName {
@ -36,27 +43,49 @@ private:
struct _NodeBasedEdgeData { struct _NodeBasedEdgeData {
unsigned distance; unsigned distance;
unsigned newNodeID;
unsigned originalEdges : 29; unsigned originalEdges : 29;
bool shortcut : 1; bool shortcut : 1;
bool forward : 1; bool forward : 1;
bool backward : 1; bool backward : 1;
short type:6; short type:6;
bool forwardTurn:1;
bool backwardTurn:1;
_MiddleName middleName; _MiddleName middleName;
} data; } data;
typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; struct _EdgeBasedEdgeData {
typedef typename _NodeBasedDynamicGraph::InputEdge _ImportEdge; 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: public:
template< class InputEdgeT > 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(); 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_ */ #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 ) { 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].target = graph[edge].target;
m_edges[i].data = graph[edge].data; 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++; 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 { struct _RawRestrictionContainer {
_Restriction restriction; _Restriction restriction;
EdgeID fromWay; 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; typedef _RawRestrictionContainer value_type;
bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const {
return a.fromWay < b.fromWay; 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; typedef _RawRestrictionContainer value_type;
bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const {
return a.toWay < b.toWay; 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. 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 VERBOSE(x) x
#define VERBOSE2(x) #define VERBOSE2(x)
@ -43,7 +43,9 @@ or see http://www.gnu.org/licenses/agpl.txt.
#include "typedefs.h" #include "typedefs.h"
#include "Contractor/Contractor.h" #include "Contractor/Contractor.h"
#include "Contractor/ContractionCleanup.h" #include "Contractor/ContractionCleanup.h"
#include "Contractor/EdgeBasedGraphFactory.h"
#include "DataStructures/BinaryHeap.h" #include "DataStructures/BinaryHeap.h"
#include "DataStructures/ExtractorStructs.h"
#include "DataStructures/LevelInformation.h" #include "DataStructures/LevelInformation.h"
#include "DataStructures/NNGrid.h" #include "DataStructures/NNGrid.h"
#include "Util/BaseConfiguration.h" #include "Util/BaseConfiguration.h"
@ -56,13 +58,27 @@ typedef DynamicGraph<EdgeData>::InputEdge InputEdge;
typedef StaticGraph<EdgeData>::InputEdge StaticEdge; typedef StaticGraph<EdgeData>::InputEdge StaticEdge;
typedef BaseConfiguration ContractorConfiguration; typedef BaseConfiguration ContractorConfiguration;
vector<NodeInfo> * int2ExtNodeMap = new vector<NodeInfo>(); vector<NodeInfo> int2ExtNodeMap;
vector<_Restriction> inputRestrictions;
int main (int argc, char *argv[]) { int main (int argc, char *argv[]) {
if(argc <= 1) { if(argc <= 1) {
cerr << "usage: " << endl << argv[0] << " <osrm-data>" << endl; cerr << "usage: " << endl << argv[0] << " <osrm-data>" << endl;
exit(-1); 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(); unsigned numberOfThreads = omp_get_num_procs();
if(testDataFile("contractor.ini")) { if(testDataFile("contractor.ini")) {
@ -84,10 +100,18 @@ int main (int argc, char *argv[]) {
if (!in.is_open()) { if (!in.is_open()) {
cerr << "Cannot open " << argv[1] << endl; exit(-1); cerr << "Cannot open " << argv[1] << endl; exit(-1);
} }
vector<ImportEdge> edgeList; vector<ImportEdge> edgeList;
const NodeID n = readBinaryOSRMGraphFromStream(in, edgeList, int2ExtNodeMap); NodeID n = readBinaryOSRMGraphFromStream(in, edgeList, &int2ExtNodeMap, inputRestrictions);
in.close(); 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 nodeOut[1024];
char edgeOut[1024]; char edgeOut[1024];
char ramIndexOut[1024]; char ramIndexOut[1024];
@ -106,8 +130,10 @@ int main (int argc, char *argv[]) {
strcat(levelInfoOut, ".levels"); strcat(levelInfoOut, ".levels");
cout << "initializing contractor ..." << flush; cout << "initializing contractor ..." << flush;
Contractor* contractor = new Contractor( n, edgeList ); Contractor* contractor = new Contractor( n, edgeBasedEdgeList );
double contractionStartedTimestamp(get_timestamp());
contractor->Run(); contractor->Run();
INFO("Contraction took " << get_timestamp() - contractionStartedTimestamp << " sec");
LevelInformation * levelInfo = contractor->GetLevelInformation(); LevelInformation * levelInfo = contractor->GetLevelInformation();
std::cout << "sorting level info" << std::endl; std::cout << "sorting level info" << std::endl;
@ -179,19 +205,18 @@ int main (int argc, char *argv[]) {
std::cout << "writing node map ..." << std::flush; std::cout << "writing node map ..." << std::flush;
ofstream mapOutFile(nodeOut, ios::binary); ofstream mapOutFile(nodeOut, ios::binary);
for(NodeID i = 0; i < int2ExtNodeMap->size(); i++) { for(NodeID i = 0; i < int2ExtNodeMap.size(); i++) {
mapOutFile.write((char *)&(int2ExtNodeMap->at(i)), sizeof(NodeInfo)); mapOutFile.write((char *)&(int2ExtNodeMap.at(i)), sizeof(NodeInfo));
} }
mapOutFile.close(); mapOutFile.close();
std::cout << "ok" << std::endl; std::cout << "ok" << std::endl;
WritableGrid * writeableGrid = new WritableGrid(); WritableGrid * writeableGrid = new WritableGrid();
cout << "building grid ..." << flush; cout << "building grid ..." << flush;
writeableGrid->ConstructGrid(edgeList, int2ExtNodeMap, ramIndexOut, fileIndexOut); writeableGrid->ConstructGrid(edgeList, &int2ExtNodeMap, ramIndexOut, fileIndexOut);
delete writeableGrid; delete writeableGrid;
int2ExtNodeMap->clear(); int2ExtNodeMap.clear();
delete int2ExtNodeMap;
cout << "finished" << endl; cout << "finished" << endl;
return 0; 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 << "ok, after " << get_timestamp() - time << "s" << endl;
cout << "[extractor] Sorting restrctns. by from... " << flush; 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 << "ok, after " << get_timestamp() - time << "s" << endl;
cout << "[extractor] Fixing restriction starts ... " << flush; cout << "[extractor] Fixing restriction starts ... " << flush;
@ -255,7 +255,7 @@ int main (int argc, char *argv[]) {
time = get_timestamp(); time = get_timestamp();
cout << "[extractor] Sorting restrctns. by to ... " << flush; 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; cout << "ok, after " << get_timestamp() - time << "s" << endl;
time = get_timestamp(); time = get_timestamp();

10
server.ini
View File

@ -2,8 +2,8 @@ Threads = 8
IP = 0.0.0.0 IP = 0.0.0.0
Port = 5000 Port = 5000
hsgrData=/opt/osm/germany.osrm.hsgr hsgrData=/opt/osm/berlin.osrm.hsgr
nodesData=/opt/osm/germany.osrm.nodes nodesData=/opt/osm/berlin.osrm.nodes
ramIndex=/opt/osm/germany.osrm.ramIndex ramIndex=/opt/osm/berlin.osrm.ramIndex
fileIndex=/opt/osm/germany.osrm.fileIndex fileIndex=/opt/osm/berlin.osrm.fileIndex
namesData=/opt/osm/germany.osrm.names namesData=/opt/osm/berlin.osrm.names