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

use CRTP instead of virtual functions in routing plugins

Browse Source
This commit is contained in:
Dennis Luxen 2015-03-02 11:55:55 +01:00
parent c2098938f5
commit 73a2a938b4
6 changed files with 75 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
data_structures/search_engine_data.cpp
View File

@ -31,63 +31,63 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes) void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes)
{ {
if (forwardHeap.get()) if (forward_heap_1.get())
{ {
forwardHeap->Clear(); forward_heap_1->Clear();
} }
else else
{ {
forwardHeap.reset(new QueryHeap(number_of_nodes)); forward_heap_1.reset(new QueryHeap(number_of_nodes));
} }
if (backwardHeap.get()) if (reverse_heap_1.get())
{ {
backwardHeap->Clear(); reverse_heap_1->Clear();
} }
else else
{ {
backwardHeap.reset(new QueryHeap(number_of_nodes)); reverse_heap_1.reset(new QueryHeap(number_of_nodes));
} }
} }
void SearchEngineData::InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes) void SearchEngineData::InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes)
{ {
if (forwardHeap2.get()) if (forward_heap_2.get())
{ {
forwardHeap2->Clear(); forward_heap_2->Clear();
} }
else else
{ {
forwardHeap2.reset(new QueryHeap(number_of_nodes)); forward_heap_2.reset(new QueryHeap(number_of_nodes));
} }
if (backwardHeap2.get()) if (reverse_heap_2.get())
{ {
backwardHeap2->Clear(); reverse_heap_2->Clear();
} }
else else
{ {
backwardHeap2.reset(new QueryHeap(number_of_nodes)); reverse_heap_2.reset(new QueryHeap(number_of_nodes));
} }
} }
void SearchEngineData::InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes) void SearchEngineData::InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes)
{ {
if (forwardHeap3.get()) if (forward_heap_3.get())
{ {
forwardHeap3->Clear(); forward_heap_3->Clear();
} }
else else
{ {
forwardHeap3.reset(new QueryHeap(number_of_nodes)); forward_heap_3.reset(new QueryHeap(number_of_nodes));
} }
if (backwardHeap3.get()) if (reverse_heap_3.get())
{ {
backwardHeap3->Clear(); reverse_heap_3->Clear();
} }
else else
{ {
backwardHeap3.reset(new QueryHeap(number_of_nodes)); reverse_heap_3.reset(new QueryHeap(number_of_nodes));
} }
} }

14
data_structures/search_engine_data.hpp
View File

@ -1,6 +1,6 @@
/* /*
Copyright (c) 2014, Project OSRM contributors Copyright (c) 2015, Project OSRM contributors
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, Redistribution and use in source and binary forms, with or without modification,
@ -44,12 +44,12 @@ struct SearchEngineData
using QueryHeap = BinaryHeap<NodeID, NodeID, int, HeapData, UnorderedMapStorage<NodeID, int>>; using QueryHeap = BinaryHeap<NodeID, NodeID, int, HeapData, UnorderedMapStorage<NodeID, int>>;
using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>; using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
static SearchEngineHeapPtr forwardHeap; static SearchEngineHeapPtr forward_heap_1;
static SearchEngineHeapPtr backwardHeap; static SearchEngineHeapPtr reverse_heap_1;
static SearchEngineHeapPtr forwardHeap2; static SearchEngineHeapPtr forward_heap_2;
static SearchEngineHeapPtr backwardHeap2; static SearchEngineHeapPtr reverse_heap_2;
static SearchEngineHeapPtr forwardHeap3; static SearchEngineHeapPtr forward_heap_3;
static SearchEngineHeapPtr backwardHeap3; static SearchEngineHeapPtr reverse_heap_3;
void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes); void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes);

25
routing_algorithms/alternative_path.hpp
View File

@ -45,9 +45,10 @@ const double VIAPATH_EPSILON = 0.15; // alternative at most 15% longer
const double VIAPATH_GAMMA = 0.75; // alternative shares at most 75% with the shortest. const double VIAPATH_GAMMA = 0.75; // alternative shares at most 75% with the shortest.
template <class DataFacadeT> template <class DataFacadeT>
class AlternativeRouting final : private BasicRoutingInterface<DataFacadeT> class AlternativeRouting final
: private BasicRoutingInterface<DataFacadeT, AlternativeRouting<DataFacadeT>>
{ {
using super = BasicRoutingInterface<DataFacadeT>; using super = BasicRoutingInterface<DataFacadeT, AlternativeRouting<DataFacadeT>>;
using EdgeData = typename DataFacadeT::EdgeData; using EdgeData = typename DataFacadeT::EdgeData;
using QueryHeap = SearchEngineData::QueryHeap; using QueryHeap = SearchEngineData::QueryHeap;
using SearchSpaceEdge = std::pair<NodeID, NodeID>; using SearchSpaceEdge = std::pair<NodeID, NodeID>;
@ -94,10 +95,10 @@ class AlternativeRouting final : private BasicRoutingInterface<DataFacadeT>
engine_working_data.InitializeOrClearThirdThreadLocalStorage( engine_working_data.InitializeOrClearThirdThreadLocalStorage(
super::facade->GetNumberOfNodes()); super::facade->GetNumberOfNodes());
QueryHeap &forward_heap1 = *(engine_working_data.forwardHeap); QueryHeap &forward_heap1 = *(engine_working_data.forward_heap_1);
QueryHeap &reverse_heap1 = *(engine_working_data.backwardHeap); QueryHeap &reverse_heap1 = *(engine_working_data.reverse_heap_1);
QueryHeap &forward_heap2 = *(engine_working_data.forwardHeap2); QueryHeap &forward_heap2 = *(engine_working_data.forward_heap_2);
QueryHeap &reverse_heap2 = *(engine_working_data.backwardHeap2); QueryHeap &reverse_heap2 = *(engine_working_data.reverse_heap_2);
int upper_bound_to_shortest_path_distance = INVALID_EDGE_WEIGHT; int upper_bound_to_shortest_path_distance = INVALID_EDGE_WEIGHT;
NodeID middle_node = SPECIAL_NODEID; NodeID middle_node = SPECIAL_NODEID;
@ -384,10 +385,10 @@ class AlternativeRouting final : private BasicRoutingInterface<DataFacadeT>
engine_working_data.InitializeOrClearSecondThreadLocalStorage( engine_working_data.InitializeOrClearSecondThreadLocalStorage(
super::facade->GetNumberOfNodes()); super::facade->GetNumberOfNodes());
QueryHeap &existing_forward_heap = *engine_working_data.forwardHeap; QueryHeap &existing_forward_heap = *engine_working_data.forward_heap_1;
QueryHeap &existing_reverse_heap = *engine_working_data.backwardHeap; QueryHeap &existing_reverse_heap = *engine_working_data.reverse_heap_1;
QueryHeap &new_forward_heap = *engine_working_data.forwardHeap2; QueryHeap &new_forward_heap = *engine_working_data.forward_heap_2;
QueryHeap &new_reverse_heap = *engine_working_data.backwardHeap2; QueryHeap &new_reverse_heap = *engine_working_data.reverse_heap_2;
std::vector<NodeID> packed_s_v_path; std::vector<NodeID> packed_s_v_path;
std::vector<NodeID> packed_v_t_path; std::vector<NodeID> packed_v_t_path;
@ -841,8 +842,8 @@ class AlternativeRouting final : private BasicRoutingInterface<DataFacadeT>
engine_working_data.InitializeOrClearThirdThreadLocalStorage( engine_working_data.InitializeOrClearThirdThreadLocalStorage(
super::facade->GetNumberOfNodes()); super::facade->GetNumberOfNodes());
QueryHeap &forward_heap3 = *engine_working_data.forwardHeap3; QueryHeap &forward_heap3 = *engine_working_data.forward_heap_3;
QueryHeap &reverse_heap3 = *engine_working_data.backwardHeap3; QueryHeap &reverse_heap3 = *engine_working_data.reverse_heap_3;
int upper_bound = INVALID_EDGE_WEIGHT; int upper_bound = INVALID_EDGE_WEIGHT;
NodeID middle = SPECIAL_NODEID; NodeID middle = SPECIAL_NODEID;

7
routing_algorithms/many_to_many.hpp
View File

@ -40,9 +40,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <vector> #include <vector>
template <class DataFacadeT> template <class DataFacadeT>
class ManyToManyRouting final : public BasicRoutingInterface<DataFacadeT> class ManyToManyRouting final
: public BasicRoutingInterface<DataFacadeT, ManyToManyRouting<DataFacadeT>>
{ {
using super = BasicRoutingInterface<DataFacadeT>; using super = BasicRoutingInterface<DataFacadeT, ManyToManyRouting<DataFacadeT>>;
using QueryHeap = SearchEngineData::QueryHeap; using QueryHeap = SearchEngineData::QueryHeap;
SearchEngineData &engine_working_data; SearchEngineData &engine_working_data;
@ -76,7 +77,7 @@ class ManyToManyRouting final : public BasicRoutingInterface<DataFacadeT>
engine_working_data.InitializeOrClearFirstThreadLocalStorage( engine_working_data.InitializeOrClearFirstThreadLocalStorage(
super::facade->GetNumberOfNodes()); super::facade->GetNumberOfNodes());
QueryHeap &query_heap = *(engine_working_data.forwardHeap); QueryHeap &query_heap = *(engine_working_data.forward_heap_1);
SearchSpaceWithBuckets search_space_with_buckets; SearchSpaceWithBuckets search_space_with_buckets;

28
routing_algorithms/routing_base.hpp
View File

@ -37,17 +37,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stack> #include <stack>
SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap; SearchEngineData::SearchEngineHeapPtr SearchEngineData::forward_heap_1;
SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap; SearchEngineData::SearchEngineHeapPtr SearchEngineData::reverse_heap_1;
SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap2; SearchEngineData::SearchEngineHeapPtr SearchEngineData::forward_heap_2;
SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap2; SearchEngineData::SearchEngineHeapPtr SearchEngineData::reverse_heap_2;
SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap3; SearchEngineData::SearchEngineHeapPtr SearchEngineData::forward_heap_3;
SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap3; SearchEngineData::SearchEngineHeapPtr SearchEngineData::reverse_heap_3;
template <class DataFacadeT> class BasicRoutingInterface template <class DataFacadeT, class Derived> class BasicRoutingInterface
{ {
private: private:
typedef typename DataFacadeT::EdgeData EdgeData; using EdgeData = typename DataFacadeT::EdgeData;
protected: protected:
DataFacadeT *facade; DataFacadeT *facade;
@ -56,9 +56,9 @@ template <class DataFacadeT> class BasicRoutingInterface
BasicRoutingInterface() = delete; BasicRoutingInterface() = delete;
BasicRoutingInterface(const BasicRoutingInterface &) = delete; BasicRoutingInterface(const BasicRoutingInterface &) = delete;
explicit BasicRoutingInterface(DataFacadeT *facade) : facade(facade) {} explicit BasicRoutingInterface(DataFacadeT *facade) : facade(facade) {}
virtual ~BasicRoutingInterface() {} ~BasicRoutingInterface() {}
inline void RoutingStep(SearchEngineData::QueryHeap &forward_heap, void RoutingStep(SearchEngineData::QueryHeap &forward_heap,
SearchEngineData::QueryHeap &reverse_heap, SearchEngineData::QueryHeap &reverse_heap,
NodeID *middle_node_id, NodeID *middle_node_id,
int *upper_bound, int *upper_bound,
@ -148,7 +148,7 @@ template <class DataFacadeT> class BasicRoutingInterface
} }
} }
inline void UnpackPath(const std::vector<NodeID> &packed_path, void UnpackPath(const std::vector<NodeID> &packed_path,
const PhantomNodes &phantom_node_pair, const PhantomNodes &phantom_node_pair,
std::vector<PathData> &unpacked_path) const std::vector<PathData> &unpacked_path) const
{ {
@ -331,7 +331,7 @@ template <class DataFacadeT> class BasicRoutingInterface
} }
} }
inline void UnpackEdge(const NodeID s, const NodeID t, std::vector<NodeID> &unpacked_path) const void UnpackEdge(const NodeID s, const NodeID t, std::vector<NodeID> &unpacked_path) const
{ {
std::stack<std::pair<NodeID, NodeID>> recursion_stack; std::stack<std::pair<NodeID, NodeID>> recursion_stack;
recursion_stack.emplace(s, t); recursion_stack.emplace(s, t);
@ -388,7 +388,7 @@ template <class DataFacadeT> class BasicRoutingInterface
unpacked_path.emplace_back(t); unpacked_path.emplace_back(t);
} }
inline void RetrievePackedPathFromHeap(const SearchEngineData::QueryHeap &forward_heap, void RetrievePackedPathFromHeap(const SearchEngineData::QueryHeap &forward_heap,
const SearchEngineData::QueryHeap &reverse_heap, const SearchEngineData::QueryHeap &reverse_heap,
const NodeID middle_node_id, const NodeID middle_node_id,
std::vector<NodeID> &packed_path) const std::vector<NodeID> &packed_path) const
@ -399,7 +399,7 @@ template <class DataFacadeT> class BasicRoutingInterface
RetrievePackedPathFromSingleHeap(reverse_heap, middle_node_id, packed_path); RetrievePackedPathFromSingleHeap(reverse_heap, middle_node_id, packed_path);
} }
inline void RetrievePackedPathFromSingleHeap(const SearchEngineData::QueryHeap &search_heap, void RetrievePackedPathFromSingleHeap(const SearchEngineData::QueryHeap &search_heap,
const NodeID middle_node_id, const NodeID middle_node_id,
std::vector<NodeID> &packed_path) const std::vector<NodeID> &packed_path) const
{ {

13
routing_algorithms/shortest_path.hpp
View File

@ -36,9 +36,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../typedefs.h" #include "../typedefs.h"
template <class DataFacadeT> template <class DataFacadeT>
class ShortestPathRouting final : public BasicRoutingInterface<DataFacadeT> class ShortestPathRouting final
: public BasicRoutingInterface<DataFacadeT, ShortestPathRouting<DataFacadeT>>
{ {
using super = BasicRoutingInterface<DataFacadeT>; using super = BasicRoutingInterface<DataFacadeT, ShortestPathRouting<DataFacadeT>>;
using QueryHeap = SearchEngineData::QueryHeap; using QueryHeap = SearchEngineData::QueryHeap;
SearchEngineData &engine_working_data; SearchEngineData &engine_working_data;
@ -70,10 +71,10 @@ class ShortestPathRouting final : public BasicRoutingInterface<DataFacadeT>
engine_working_data.InitializeOrClearThirdThreadLocalStorage( engine_working_data.InitializeOrClearThirdThreadLocalStorage(
super::facade->GetNumberOfNodes()); super::facade->GetNumberOfNodes());
QueryHeap &forward_heap1 = *(engine_working_data.forwardHeap); QueryHeap &forward_heap1 = *(engine_working_data.forward_heap_1);
QueryHeap &reverse_heap1 = *(engine_working_data.backwardHeap); QueryHeap &reverse_heap1 = *(engine_working_data.reverse_heap_1);
QueryHeap &forward_heap2 = *(engine_working_data.forwardHeap2); QueryHeap &forward_heap2 = *(engine_working_data.forward_heap_2);
QueryHeap &reverse_heap2 = *(engine_working_data.backwardHeap2); QueryHeap &reverse_heap2 = *(engine_working_data.reverse_heap_2);
std::size_t current_leg = 0; std::size_t current_leg = 0;
// Get distance to next pair of target nodes. // Get distance to next pair of target nodes.