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

move StaticGraph to C++11

Browse Source
This commit is contained in:
Dennis Luxen 2014-05-05 17:19:47 +02:00
parent 7bf74c0917
commit 2d3fb858ad
7 changed files with 162 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
DataStructures/SearchEngineData.h
View File

@ -36,18 +36,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <boost/thread.hpp> #include <boost/thread.hpp>
#include <string>
#include <vector> #include <vector>
struct _HeapData { struct HeapData
{
NodeID parent; NodeID parent;
/* explicit */ _HeapData( NodeID p ) : parent(p) { } /* explicit */ HeapData(NodeID p) : parent(p) {}
}; };
// typedef StaticGraph<QueryEdge::EdgeData> QueryGraph; // typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
struct SearchEngineData { struct SearchEngineData
typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > QueryHeap; {
typedef BinaryHeap<NodeID, NodeID, int, HeapData, UnorderedMapStorage<NodeID, int>> QueryHeap;
typedef boost::thread_specific_ptr<QueryHeap> SearchEngineHeapPtr; typedef boost::thread_specific_ptr<QueryHeap> SearchEngineHeapPtr;
static SearchEngineHeapPtr forwardHeap; static SearchEngineHeapPtr forwardHeap;

200
DataStructures/StaticGraph.h
View File

@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef STATICGRAPH_H_INCLUDED #ifndef STATIC_GRAPH_H
#define STATICGRAPH_H_INCLUDED #define STATIC_GRAPH_H
#include "../DataStructures/Percent.h" #include "../DataStructures/Percent.h"
#include "../DataStructures/SharedMemoryVectorWrapper.h" #include "../DataStructures/SharedMemoryVectorWrapper.h"
@ -34,90 +34,107 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../typedefs.h" #include "../typedefs.h"
#include <algorithm> #include <algorithm>
#include <limits>
#include <vector> #include <vector>
template< typename EdgeDataT, bool UseSharedMemory = false> template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
class StaticGraph { {
public: public:
typedef NodeID NodeIterator; typedef NodeID NodeIterator;
typedef NodeID EdgeIterator; typedef NodeID EdgeIterator;
typedef EdgeDataT EdgeData; typedef EdgeDataT EdgeData;
class InputEdge { class InputEdge
public: {
public:
EdgeDataT data; EdgeDataT data;
NodeIterator source; NodeIterator source;
NodeIterator target; NodeIterator target;
bool operator<( const InputEdge& right ) const { bool operator<(const InputEdge &right) const
if ( source != right.source ) { {
if (source != right.source)
{
return source < right.source; return source < right.source;
} }
return target < right.target; return target < right.target;
} }
}; };
struct _StrNode { struct NodeArrayEntry
//index of the first edge {
// index of the first edge
EdgeIterator firstEdge; EdgeIterator firstEdge;
}; };
struct _StrEdge { struct EdgeArrayEntry
{
NodeID target; NodeID target;
EdgeDataT data; EdgeDataT data;
}; };
StaticGraph( const int nodes, std::vector< InputEdge > &graph ) { StaticGraph(const int nodes, std::vector<InputEdge> &graph)
std::sort( graph.begin(), graph.end() ); {
_numNodes = nodes; std::sort(graph.begin(), graph.end());
_numEdges = ( EdgeIterator ) graph.size(); number_of_nodes = nodes;
_nodes.resize( _numNodes + 1); number_of_edges = (EdgeIterator)graph.size();
node_array.resize(number_of_nodes + 1);
EdgeIterator edge = 0; EdgeIterator edge = 0;
EdgeIterator position = 0; EdgeIterator position = 0;
for ( NodeIterator node = 0; node <= _numNodes; ++node ) { for (NodeIterator node = 0; node <= number_of_nodes; ++node)
{
EdgeIterator lastEdge = edge; EdgeIterator lastEdge = edge;
while ( edge < _numEdges && graph[edge].source == node ) while (edge < number_of_edges && graph[edge].source == node)
++edge; ++edge;
_nodes[node].firstEdge = position; //=edge node_array[node].firstEdge = position; //=edge
position += edge - lastEdge; //remove position += edge - lastEdge; // remove
} }
_edges.resize( position ); //(edge) edge_array.resize(position); //(edge)
edge = 0; edge = 0;
for ( NodeIterator node = 0; node < _numNodes; ++node ) { for (NodeIterator node = 0; node < number_of_nodes; ++node)
for ( EdgeIterator i = _nodes[node].firstEdge, e = _nodes[node+1].firstEdge; i != e; ++i ) { {
_edges[i].target = graph[edge].target; EdgeIterator e = node_array[node + 1].firstEdge;
_edges[i].data = graph[edge].data; for (EdgeIterator i = node_array[node].firstEdge; i != e; ++i)
assert(_edges[i].data.distance > 0); {
edge_array[i].target = graph[edge].target;
edge_array[i].data = graph[edge].data;
assert(edge_array[i].data.distance > 0);
edge++; edge++;
} }
} }
} }
StaticGraph( StaticGraph(typename ShM<NodeArrayEntry, UseSharedMemory>::vector &nodes,
typename ShM<_StrNode, UseSharedMemory>::vector & nodes, typename ShM<EdgeArrayEntry, UseSharedMemory>::vector &edges)
typename ShM<_StrEdge, UseSharedMemory>::vector & edges {
) { number_of_nodes = nodes.size() - 1;
_numNodes = nodes.size()-1; number_of_edges = edges.size();
_numEdges = edges.size();
_nodes.swap(nodes); node_array.swap(nodes);
_edges.swap(edges); edge_array.swap(edges);
#ifndef NDEBUG #ifndef NDEBUG
Percent p(GetNumberOfNodes()); Percent p(GetNumberOfNodes());
for(unsigned u = 0; u < GetNumberOfNodes(); ++u) { for (unsigned u = 0; u < GetNumberOfNodes(); ++u)
for(unsigned eid = BeginEdges(u); eid < EndEdges(u); ++eid) { {
for (unsigned eid = BeginEdges(u); eid < EndEdges(u); ++eid)
{
unsigned v = GetTarget(eid); unsigned v = GetTarget(eid);
EdgeData & data = GetEdgeData(eid); EdgeData &data = GetEdgeData(eid);
if(data.shortcut) { if (data.shortcut)
{
const EdgeID first_edge_id = FindEdgeInEitherDirection(u, data.id); const EdgeID first_edge_id = FindEdgeInEitherDirection(u, data.id);
if (SPECIAL_EDGEID == first_edge_id) if (SPECIAL_EDGEID == first_edge_id)
{ {
SimpleLogger().Write(logWARNING) << "cannot find first segment of edge (" << u << "," << data.id << "," << v << "), eid: " << eid; SimpleLogger().Write(logWARNING) << "cannot find first segment of edge ("
<< u << "," << data.id << "," << v
<< "), eid: " << eid;
BOOST_ASSERT(false); BOOST_ASSERT(false);
} }
const EdgeID second_edge_id = FindEdgeInEitherDirection(data.id, v); const EdgeID second_edge_id = FindEdgeInEitherDirection(data.id, v);
if (SPECIAL_EDGEID == second_edge_id) if (SPECIAL_EDGEID == second_edge_id)
{ {
SimpleLogger().Write(logWARNING) << "cannot find second segment of edge (" << u << "," << data.id << "," << v << "), eid: " << eid; SimpleLogger().Write(logWARNING) << "cannot find second segment of edge ("
<< u << "," << data.id << "," << v
<< "), eid: " << eid;
BOOST_ASSERT(false); BOOST_ASSERT(false);
} }
} }
@ -127,75 +144,76 @@ public:
#endif #endif
} }
unsigned GetNumberOfNodes() const { unsigned GetNumberOfNodes() const { return number_of_nodes; }
return _numNodes;
unsigned GetNumberOfEdges() const { return number_of_edges; }
unsigned GetOutDegree(const NodeIterator n) const { return BeginEdges(n) - EndEdges(n) - 1; }
inline NodeIterator GetTarget(const EdgeIterator e) const
{
return NodeIterator(edge_array[e].target);
} }
unsigned GetNumberOfEdges() const { inline EdgeDataT &GetEdgeData(const EdgeIterator e) { return edge_array[e].data; }
return _numEdges;
const EdgeDataT &GetEdgeData(const EdgeIterator e) const { return edge_array[e].data; }
EdgeIterator BeginEdges(const NodeIterator n) const
{
return EdgeIterator(node_array.at(n).firstEdge);
} }
unsigned GetOutDegree( const NodeIterator n ) const { EdgeIterator EndEdges(const NodeIterator n) const
return BeginEdges(n)-EndEdges(n) - 1; {
return EdgeIterator(node_array.at(n + 1).firstEdge);
} }
inline NodeIterator GetTarget( const EdgeIterator e ) const { // searches for a specific edge
return NodeIterator( _edges[e].target ); EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const
} {
EdgeIterator smallest_edge = SPECIAL_EDGEID;
inline EdgeDataT &GetEdgeData( const EdgeIterator e ) { EdgeWeight smallest_weight = INVALID_EDGE_WEIGHT;
return _edges[e].data; for (EdgeIterator edge = BeginEdges(from); edge < EndEdges(from); edge++)
} {
const EdgeDataT &GetEdgeData( const EdgeIterator e ) const {
return _edges[e].data;
}
EdgeIterator BeginEdges( const NodeIterator n ) const {
return EdgeIterator( _nodes.at(n).firstEdge );
}
EdgeIterator EndEdges( const NodeIterator n ) const {
return EdgeIterator( _nodes.at(n+1).firstEdge );
}
//searches for a specific edge
EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const {
EdgeIterator smallestEdge = SPECIAL_EDGEID;
EdgeWeight smallestWeight = INVALID_EDGE_WEIGHT;
for ( EdgeIterator edge = BeginEdges( from ); edge < EndEdges(from); edge++ ) {
const NodeID target = GetTarget(edge); const NodeID target = GetTarget(edge);
const EdgeWeight weight = GetEdgeData(edge).distance; const EdgeWeight weight = GetEdgeData(edge).distance;
if(target == to && weight < smallestWeight) { if (target == to && weight < smallest_weight)
smallestEdge = edge; smallestWeight = weight; {
smallest_edge = edge;
smallest_weight = weight;
} }
} }
return smallestEdge; return smallest_edge;
} }
EdgeIterator FindEdgeInEitherDirection( const NodeIterator from, const NodeIterator to ) const { EdgeIterator FindEdgeInEitherDirection(const NodeIterator from, const NodeIterator to) const
EdgeIterator tmp = FindEdge( from, to ); {
return (UINT_MAX != tmp ? tmp : FindEdge( to, from )); EdgeIterator tmp = FindEdge(from, to);
return (SPECIAL_NODEID != tmp ? tmp : FindEdge(to, from));
} }
EdgeIterator FindEdgeIndicateIfReverse( const NodeIterator from, const NodeIterator to, bool & result ) const { EdgeIterator
EdgeIterator tmp = FindEdge( from, to ); FindEdgeIndicateIfReverse(const NodeIterator from, const NodeIterator to, bool &result) const
if(UINT_MAX == tmp) { {
tmp = FindEdge( to, from ); EdgeIterator current_iterator = FindEdge(from, to);
if(UINT_MAX != tmp) { if (SPECIAL_NODEID == current_iterator)
{
current_iterator = FindEdge(to, from);
if (SPECIAL_NODEID != current_iterator)
{
result = true; result = true;
} }
} }
return tmp; return current_iterator;
} }
private: private:
NodeIterator number_of_nodes;
EdgeIterator number_of_edges;
NodeIterator _numNodes; typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array;
EdgeIterator _numEdges; typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array;
typename ShM< _StrNode, UseSharedMemory >::vector _nodes;
typename ShM< _StrEdge, UseSharedMemory >::vector _edges;
}; };
#endif // STATICGRAPH_H_INCLUDED #endif // STATIC_GRAPH_H

4
Server/DataStructures/InternalDataFacade.h
View File

@ -102,8 +102,8 @@ private:
} }
void LoadGraph(const boost::filesystem::path & hsgr_path) { void LoadGraph(const boost::filesystem::path & hsgr_path) {
typename ShM<typename QueryGraph::_StrNode, false>::vector node_list; typename ShM<typename QueryGraph::NodeArrayEntry, false>::vector node_list;
typename ShM<typename QueryGraph::_StrEdge, false>::vector edge_list; typename ShM<typename QueryGraph::EdgeArrayEntry, false>::vector edge_list;
SimpleLogger().Write() << "loading graph from " << hsgr_path.string(); SimpleLogger().Write() << "loading graph from " << hsgr_path.string();

12
Server/DataStructures/SharedDataFacade.h
View File

@ -49,12 +49,12 @@ class SharedDataFacade : public BaseDataFacade<EdgeDataT> {
private: private:
typedef EdgeDataT EdgeData; typedef EdgeDataT EdgeData;
typedef BaseDataFacade<EdgeData> super; typedef BaseDataFacade<EdgeData> super;
typedef StaticGraph<EdgeData, true> QueryGraph; typedef StaticGraph<EdgeData, true> QueryGraph;
typedef typename StaticGraph<EdgeData, true>::_StrNode GraphNode; typedef typename StaticGraph<EdgeData, true>::NodeArrayEntry GraphNode;
typedef typename StaticGraph<EdgeData, true>::_StrEdge GraphEdge; typedef typename StaticGraph<EdgeData, true>::EdgeArrayEntry GraphEdge;
typedef typename QueryGraph::InputEdge InputEdge; typedef typename QueryGraph::InputEdge InputEdge;
typedef typename super::RTreeLeaf RTreeLeaf; typedef typename super::RTreeLeaf RTreeLeaf;
typedef typename StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode RTreeNode; typedef typename StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode RTreeNode;
SharedDataLayout * data_layout; SharedDataLayout * data_layout;

62
Server/DataStructures/SharedDataType.h
View File

@ -106,20 +106,20 @@ struct SharedDataLayout {
uint64_t GetSizeOfLayout() const { uint64_t GetSizeOfLayout() const {
uint64_t result = uint64_t result =
(name_index_list_size * sizeof(unsigned) ) + (name_index_list_size * sizeof(unsigned) ) +
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)) + (turn_instruction_list_size * sizeof(TurnInstructionsClass) ) +
(r_search_tree_size * sizeof(RTreeNode) ) + (r_search_tree_size * sizeof(RTreeNode) ) +
(geometries_indicators/32 + 1) * sizeof(unsigned) + (geometries_indicators/32 + 1) * sizeof(unsigned) +
(geometries_index_list_size * sizeof(unsigned) ) + (geometries_index_list_size * sizeof(unsigned) ) +
(geometries_list_size * sizeof(unsigned) ) + (geometries_list_size * sizeof(unsigned) ) +
sizeof(checksum) + sizeof(checksum) +
1024*sizeof(char); 1024*sizeof(char);
return result; return result;
} }
@ -159,7 +159,7 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode)) ; (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) ;
return result; return result;
} }
uint64_t GetTimeStampOffset() const { uint64_t GetTimeStampOffset() const {
@ -168,8 +168,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode)) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge)); (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry));
return result; return result;
} }
uint64_t GetCoordinateListOffset() const { uint64_t GetCoordinateListOffset() const {
@ -178,8 +178,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode)) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry)) +
(timestamp_length * sizeof(char) ); (timestamp_length * sizeof(char) );
return result; return result;
} }
@ -189,8 +189,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode)) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry)) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry)) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate)); (coordinate_list_size * sizeof(FixedPointCoordinate));
return result; return result;
@ -201,8 +201,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)); (turn_instruction_list_size * sizeof(TurnInstructionsClass));
@ -214,8 +214,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
@ -229,8 +229,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
@ -245,8 +245,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +
@ -261,8 +261,8 @@ struct SharedDataLayout {
(name_char_list_size * sizeof(char) ) + (name_char_list_size * sizeof(char) ) +
(name_id_list_size * sizeof(unsigned) ) + (name_id_list_size * sizeof(unsigned) ) +
(via_node_list_size * sizeof(NodeID) ) + (via_node_list_size * sizeof(NodeID) ) +
(graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + (graph_node_list_size * sizeof(QueryGraph::NodeArrayEntry) ) +
(graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + (graph_edge_list_size * sizeof(QueryGraph::EdgeArrayEntry) ) +
(timestamp_length * sizeof(char) ) + (timestamp_length * sizeof(char) ) +
(coordinate_list_size * sizeof(FixedPointCoordinate) ) + (coordinate_list_size * sizeof(FixedPointCoordinate) ) +
(turn_instruction_list_size * sizeof(TurnInstructionsClass)) + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) +

8
datastore.cpp
View File

@ -419,21 +419,21 @@ int main( const int argc, const char * argv[] )
tree_node_file.close(); tree_node_file.close();
// load the nodes of the search graph // load the nodes of the search graph
QueryGraph::_StrNode * graph_node_list_ptr = (QueryGraph::_StrNode*)( QueryGraph::NodeArrayEntry * graph_node_list_ptr = (QueryGraph::NodeArrayEntry*)(
shared_memory_ptr + shared_layout_ptr->GetGraphNodeListOffset() shared_memory_ptr + shared_layout_ptr->GetGraphNodeListOffset()
); );
hsgr_input_stream.read( hsgr_input_stream.read(
(char*) graph_node_list_ptr, (char*) graph_node_list_ptr,
shared_layout_ptr->graph_node_list_size*sizeof(QueryGraph::_StrNode) shared_layout_ptr->graph_node_list_size*sizeof(QueryGraph::NodeArrayEntry)
); );
// load the edges of the search graph // load the edges of the search graph
QueryGraph::_StrEdge * graph_edge_list_ptr = (QueryGraph::_StrEdge *)( QueryGraph::EdgeArrayEntry * graph_edge_list_ptr = (QueryGraph::EdgeArrayEntry *)(
shared_memory_ptr + shared_layout_ptr->GetGraphEdgeListOffset() shared_memory_ptr + shared_layout_ptr->GetGraphEdgeListOffset()
); );
hsgr_input_stream.read( hsgr_input_stream.read(
(char*) graph_edge_list_ptr, (char*) graph_edge_list_ptr,
shared_layout_ptr->graph_edge_list_size*sizeof(QueryGraph::_StrEdge) shared_layout_ptr->graph_edge_list_size*sizeof(QueryGraph::EdgeArrayEntry)
); );
hsgr_input_stream.close(); hsgr_input_stream.close();

8
prepare.cpp
View File

@ -345,7 +345,7 @@ int main (int argc, char *argv[]) {
SimpleLogger().Write(logDEBUG) << "contracted graph has " << max_used_node_id << " nodes"; SimpleLogger().Write(logDEBUG) << "contracted graph has " << max_used_node_id << " nodes";
max_used_node_id+=1; max_used_node_id+=1;
std::vector< StaticGraph<EdgeData>::_StrNode > node_array; std::vector< StaticGraph<EdgeData>::NodeArrayEntry > node_array;
node_array.resize( edgeBasedNodeNumber + 1); node_array.resize( edgeBasedNodeNumber + 1);
SimpleLogger().Write() << "Building node array"; SimpleLogger().Write() << "Building node array";
@ -381,14 +381,14 @@ int main (int argc, char *argv[]) {
//serialize number of edges //serialize number of edges
hsgr_output_stream.write((char*) &contracted_edge_count, sizeof(unsigned)); hsgr_output_stream.write((char*) &contracted_edge_count, sizeof(unsigned));
//serialize all nodes //serialize all nodes
hsgr_output_stream.write((char*) &node_array[0], sizeof(StaticGraph<EdgeData>::_StrNode)*node_array_size); hsgr_output_stream.write((char*) &node_array[0], sizeof(StaticGraph<EdgeData>::NodeArrayEntry)*node_array_size);
//serialize all edges //serialize all edges
SimpleLogger().Write() << "Building edge array"; SimpleLogger().Write() << "Building edge array";
edge = 0; edge = 0;
int usedEdgeCounter = 0; int usedEdgeCounter = 0;
StaticGraph<EdgeData>::_StrEdge currentEdge; StaticGraph<EdgeData>::EdgeArrayEntry currentEdge;
for (unsigned edge = 0; edge < contractedEdgeList.size(); ++edge) for (unsigned edge = 0; edge < contractedEdgeList.size(); ++edge)
{ {
// no eigen loops // no eigen loops
@ -409,7 +409,7 @@ int main (int argc, char *argv[]) {
"Failed at adjacency list of node " << contractedEdgeList[edge].source << "/" << node_array.size()-1; "Failed at adjacency list of node " << contractedEdgeList[edge].source << "/" << node_array.size()-1;
return 1; return 1;
} }
hsgr_output_stream.write((char*) &currentEdge, sizeof(StaticGraph<EdgeData>::_StrEdge)); hsgr_output_stream.write((char*) &currentEdge, sizeof(StaticGraph<EdgeData>::EdgeArrayEntry));
++usedEdgeCounter; ++usedEdgeCounter;
} }
hsgr_output_stream.close(); hsgr_output_stream.close();