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

Implementation of internal data storage

Browse Source
This commit is contained in:
Dennis Luxen
2013-09-20 18:30:47 +02:00
parent 101fbcca90
commit 7951795ea4
17 changed files with 340 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Server/DataStructures/BaseDataFacade.h
+3 -1
View File
@@ -23,6 +23,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
//Exposes all data access interfaces to the algorithms via base class ptr
#include "../../Contractor/EdgeBasedGraphFactory.h"
#include "../../DataStructures/Coordinate.h"
#include "../../DataStructures/PhantomNodes.h"
#include "../../DataStructures/TurnInstructions.h"
@@ -35,8 +36,9 @@ or see http://www.gnu.org/licenses/agpl.txt.
template<class EdgeDataT>
class BaseDataFacade {
public:
typedef EdgeBasedGraphFactory::EdgeBasedNode RTreeLeaf;
typedef EdgeDataT EdgeData;
BaseDataFacade() { }
BaseDataFacade( ) { }
virtual ~BaseDataFacade() { }
//search graph access
Server/DataStructures/InternalDataFacade.h
+250 -17
View File
@@ -25,67 +25,300 @@ or see http://www.gnu.org/licenses/agpl.txt.
#include "BaseDataFacade.h"
#include "../../DataStructures/Coordinate.h"
#include "../../DataStructures/QueryNode.h"
#include "../../DataStructures/QueryEdge.h"
#include "../../DataStructures/StaticGraph.h"
#include "../../DataStructures/StaticRTree.h"
#include "../../Util/BoostFilesystemFix.h"
#include "../../Util/GraphLoader.h"
#include "../../Util/IniFile.h"
#include "../../Util/SimpleLogger.h"
template<class EdgeDataT>
class InternalDataFacade : public BaseDataFacade<EdgeDataT> {
private:
typedef BaseDataFacade<EdgeDataT> super;
typedef StaticGraph<typename super::EdgeData> QueryGraph;
typedef typename QueryGraph::InputEdge InputEdge;
typedef typename super::RTreeLeaf RTreeLeaf;
InternalDataFacade() { }
unsigned m_check_sum;
unsigned m_number_of_nodes;
QueryGraph * m_query_graph;
std::string m_timestamp;
std::vector<FixedPointCoordinate> m_coordinate_list;
std::vector<NodeID> m_via_node_list;
std::vector<unsigned> m_name_ID_list;
std::vector<TurnInstruction> m_turn_instruction_list;
StaticRTree<RTreeLeaf> * m_static_rtree;
void LoadTimestamp(const boost::filesystem::path & timestamp_path) {
if( boost::filesystem::exists(timestamp_path) ) {
SimpleLogger().Write() << "Loading Timestamp";
boost::filesystem::ifstream timestampInStream( timestamp_path );
if(!timestampInStream) {
SimpleLogger().Write(logWARNING) << timestamp_path << " not found";
}
getline(timestampInStream, m_timestamp);
timestampInStream.close();
}
if(m_timestamp.empty()) {
m_timestamp = "n/a";
}
if(25 < m_timestamp.length()) {
m_timestamp.resize(25);
}
}
void LoadGraph(const boost::filesystem::path & hsgr_path) {
ShMemVector<typename QueryGraph::_StrNode> node_list;
ShMemVector< typename QueryGraph::_StrEdge> edge_list;
m_number_of_nodes = readHSGRFromStream(
hsgr_path,
node_list,
edge_list,
&m_check_sum
);
BOOST_ASSERT_MSG(0 == node_list.size(), "node list not flushed");
BOOST_ASSERT_MSG(0 == edge_list.size(), "edge list not flushed");
m_query_graph = new QueryGraph(node_list, edge_list);
SimpleLogger().Write() << "Data checksum is " << m_check_sum;
}
void LoadNodeAndEdgeInformation(
const boost::filesystem::path nodes_file,
const boost::filesystem::path edges_file
) {
boost::filesystem::ifstream nodes_input_stream(
nodes_file,
std::ios::binary
);
boost::filesystem::ifstream edges_input_stream(
edges_file,
std::ios::binary
);
SimpleLogger().Write(logDEBUG) << "Loading node data";
NodeInfo current_node;
while(!nodes_input_stream.eof()) {
nodes_input_stream.read((char *)&current_node, sizeof(NodeInfo));
m_coordinate_list.push_back(
FixedPointCoordinate(
current_node.lat,
current_node.lon
)
);
}
std::vector<FixedPointCoordinate>(m_coordinate_list).swap(m_coordinate_list);
nodes_input_stream.close();
SimpleLogger().Write(logDEBUG)
<< "Loading edge data";
unsigned number_of_edges = 0;
edges_input_stream.read((char*)&number_of_edges, sizeof(unsigned));
m_via_node_list.resize(number_of_edges);
m_name_ID_list.resize(number_of_edges);
m_turn_instruction_list.resize(number_of_edges);
OriginalEdgeData current_edge_data;
for(unsigned i = 0; i < number_of_edges; ++i) {
edges_input_stream.read(
(char*)&(current_edge_data),
sizeof(OriginalEdgeData)
);
m_via_node_list[i] = current_edge_data.viaNode;
m_name_ID_list[i] = current_edge_data.nameID;
m_turn_instruction_list[i] = current_edge_data.turnInstruction;
}
edges_input_stream.close();
SimpleLogger().Write(logDEBUG)
<< "Loaded " << number_of_edges << " orig edges";
SimpleLogger().Write(logDEBUG) << "Opening NN indices";
}
void LoadRTree(
const boost::filesystem::path & ram_index_path,
const boost::filesystem::path & file_index_path
) {
m_static_rtree = new StaticRTree<RTreeLeaf>(
ram_index_path,
file_index_path
);
}
public:
~InternalDataFacade() {
delete m_query_graph;
delete m_static_rtree;
}
InternalDataFacade(
const IniFile & server_config,
const boost::filesystem::path & base_path
) {
//check contents of config file
if ( !server_config.Holds("hsgrData")) {
throw OSRMException("no ram index file name in server ini");
}
if ( !server_config.Holds("ramIndex") ) {
throw OSRMException("no mem index file name in server ini");
}
if ( !server_config.Holds("fileIndex") ) {
throw OSRMException("no nodes file name in server ini");
}
if ( !server_config.Holds("nodesData") ) {
throw OSRMException("no nodes file name in server ini");
}
if ( !server_config.Holds("edgesData") ) {
throw OSRMException("no edges file name in server ini");
}
//generate paths of data files
boost::filesystem::path hsgr_path = boost::filesystem::absolute(
server_config.GetParameter("hsgrData"),
base_path
);
boost::filesystem::path ram_index_path = boost::filesystem::absolute(
server_config.GetParameter("ramIndex"),
base_path
);
boost::filesystem::path file_index_path = boost::filesystem::absolute(
server_config.GetParameter("fileIndex"),
base_path
);
boost::filesystem::path node_data_path = boost::filesystem::absolute(
server_config.GetParameter("nodesData"),
base_path
);
boost::filesystem::path edge_data_path = boost::filesystem::absolute(
server_config.GetParameter("edgesData"),
base_path
);
boost::filesystem::path name_data_path = boost::filesystem::absolute(
server_config.GetParameter("namesData"),
base_path
);
boost::filesystem::path timestamp_path = boost::filesystem::absolute(
server_config.GetParameter("timestamp"),
base_path
);
// check if data files empty
if ( 0 == boost::filesystem::file_size( node_data_path ) ) {
throw OSRMException("nodes file is empty");
}
if ( 0 == boost::filesystem::file_size( edge_data_path ) ) {
throw OSRMException("edges file is empty");
}
//load data
SimpleLogger().Write() << "loading graph data";
LoadGraph(hsgr_path);
LoadNodeAndEdgeInformation(node_data_path, edge_data_path);
LoadRTree(ram_index_path, file_index_path);
LoadTimestamp(hsgr_path);
}
//search graph access
unsigned GetNumberOfNodes() const { return 0; }
unsigned GetNumberOfNodes() const {
return m_query_graph->GetNumberOfNodes();
}
unsigned GetNumberOfEdges() const { return 0; }
unsigned GetNumberOfEdges() const {
return m_query_graph->GetNumberOfEdges();
}
unsigned GetOutDegree( const NodeID n ) const { return 0; }
unsigned GetOutDegree( const NodeID n ) const {
return m_query_graph->GetOutDegree(n);
}
NodeID GetTarget( const EdgeID e ) const { return 0; }
NodeID GetTarget( const EdgeID e ) const {
return m_query_graph->GetTarget(e); }
EdgeDataT &GetEdgeData( const EdgeID e ) { return EdgeDataT(); }
EdgeDataT &GetEdgeData( const EdgeID e ) {
return m_query_graph->GetEdgeData(e);
}
const EdgeDataT &GetEdgeData( const EdgeID e ) const { return EdgeDataT(); }
const EdgeDataT &GetEdgeData( const EdgeID e ) const {
return m_query_graph->GetEdgeData(e);
}
EdgeID BeginEdges( const NodeID n ) const { return 0; }
EdgeID BeginEdges( const NodeID n ) const {
return m_query_graph->BeginEdges(n);
}
EdgeID EndEdges( const NodeID n ) const { return 0; }
EdgeID EndEdges( const NodeID n ) const {
return m_query_graph->EndEdges(n);
}
//searches for a specific edge
EdgeID FindEdge( const NodeID from, const NodeID to ) const { return 0; }
EdgeID FindEdge( const NodeID from, const NodeID to ) const {
return m_query_graph->FindEdge(from, to);
}
EdgeID FindEdgeInEitherDirection(
const NodeID from,
const NodeID to
) const { return 0; }
) const {
return m_query_graph->FindEdgeInEitherDirection(from, to);
}
EdgeID FindEdgeIndicateIfReverse(
const NodeID from,
const NodeID to,
bool & result
) const { return 0; }
) const {
return m_query_graph->FindEdgeIndicateIfReverse(from, to, result);
}
//node and edge information access
FixedPointCoordinate GetCoordinateOfNode(
const unsigned id
) const { return FixedPointCoordinate(); };
) const {
const NodeID node = m_via_node_list.at(id);
return m_coordinate_list.at(node);
};
TurnInstruction GetTurnInstructionForEdgeID(
const unsigned id
) const { return 0; }
) const {
return m_turn_instruction_list.at(id);
}
bool LocateClosestEndPointForCoordinate(
const FixedPointCoordinate& input_coordinate,
FixedPointCoordinate& result,
const unsigned zoom_level = 18
) const { return false; }
) const {
return m_static_rtree->LocateClosestEndPointForCoordinate(
input_coordinate,
result,
zoom_level
);
}
bool FindPhantomNodeForCoordinate(
const FixedPointCoordinate & input_coordinate,
PhantomNode & resulting_phantom_node,
const unsigned zoom_level
) const { return false; }
) const {
return m_static_rtree->FindPhantomNodeForCoordinate(
input_coordinate,
resulting_phantom_node,
zoom_level
);
}
unsigned GetCheckSum() const { return 0; }
unsigned GetCheckSum() const { return m_check_sum; }
unsigned GetNameIndexFromEdgeID(const unsigned id) const { return 0; };
@@ -95,7 +328,7 @@ public:
) const { return; };
std::string GetTimestamp() const {
return "";
return m_timestamp;
};
};
Server/DataStructures/SharedDataFacade.h
+10 -1
View File
@@ -26,13 +26,22 @@ or see http://www.gnu.org/licenses/agpl.txt.
#include "BaseDataFacade.h"
#include "../../DataStructures/StaticGraph.h"
#include "../../Util/BoostFilesystemFix.h"
#include "../../Util/IniFile.h"
#include "../../Util/SimpleLogger.h"
template<class EdgeDataT>
class SharedDataFacade : public BaseDataFacade<EdgeDataT> {
private:
SharedDataFacade() { }
public:
SharedDataFacade(
const IniFile & configuration,
const boost::filesystem::path base_path
) {
//TODO: load data
}
//search graph access
unsigned GetNumberOfNodes() const { return 0; }