table routing vs one-to-many evaluation preparations

felixguendling · Aug 28, 2014 · 769f43f · 769f43f
1 parent 5e5a97b
commit 769f43f
Show file tree

Hide file tree

Showing 9 changed files with 82 additions and 33 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 2.8)
 
-if( CURRENT_CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
+if( CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed.
 Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")

diff --git a/DataStructures/SearchEngine.h b/DataStructures/SearchEngine.h
@@ -45,13 +45,18 @@ template <class DataFacadeT> class SearchEngine
   public:
     ShortestPathRouting<DataFacadeT> shortest_path;
     AlternativeRouting<DataFacadeT> alternative_path;
-    ManyToManyRouting<DataFacadeT> distance_table;
+    ManyToManyRouting<DataFacadeT, false, false> distance_table;
+    ManyToManyRouting<DataFacadeT, true, false> distance_table_single_source;
+    ManyToManyRouting<DataFacadeT, false, true> distance_table_single_target;
     MultiTargetRouting<DataFacadeT, true> multi_target;
     MultiTargetRouting<DataFacadeT, false> multi_source;
 
     explicit SearchEngine(DataFacadeT *facade)
         : facade(facade), shortest_path(facade, engine_working_data),
-          alternative_path(facade, engine_working_data), distance_table(facade, engine_working_data),
+          alternative_path(facade, engine_working_data),
+          distance_table(facade, engine_working_data),
+          distance_table_single_source(facade, engine_working_data),
+          distance_table_single_target(facade, engine_working_data),
           multi_target(facade, engine_working_data),
           multi_source(facade, engine_working_data)
     {

diff --git a/DataStructures/SearchEngineData.cpp b/DataStructures/SearchEngineData.cpp
@@ -29,6 +29,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BinaryHeap.h"
 
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap2;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap2;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap3;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap3;
+
 void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes)
 {
     if (forwardHeap.get())

diff --git a/Library/OSRM_impl.cpp b/Library/OSRM_impl.cpp
@@ -71,7 +71,6 @@ OSRM_impl::OSRM_impl(const ServerPaths &server_paths, const bool use_shared_memo
     }
 
     // The following plugins handle all requests.
-    RegisterPlugin(new DistanceTablePlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
     RegisterPlugin(new HelloWorldPlugin());
     RegisterPlugin(new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
     RegisterPlugin(new MultiTargetPlugin<BaseDataFacade<QueryEdge::EdgeData>, true>(query_data_facade));

diff --git a/Plugins/DistanceTablePlugin.h b/Plugins/DistanceTablePlugin.h
@@ -47,7 +47,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>
 
-template <class DataFacadeT> class DistanceTablePlugin : public BasePlugin
+template <class DataFacadeT,
+          bool single_source,
+          bool single_target> class DistanceTablePlugin : public BasePlugin
 {
   private:
     std::shared_ptr<SearchEngine<DataFacadeT>> search_engine_ptr;
@@ -62,27 +64,25 @@ template <class DataFacadeT> class DistanceTablePlugin : public BasePlugin
 
     const std::string GetDescriptor() const final { return descriptor_string; }
 
-    void HandleRequest(const RouteParameters &route_parameters, http::Reply &reply) final
+    std::shared_ptr<std::vector<EdgeWeight>> HandleRequest(
+        const RouteParameters &route_parameters, unsigned &calctime_in_us)
     {
         // check number of parameters
         if (2 > route_parameters.coordinates.size())
         {
-            reply = http::Reply::StockReply(http::Reply::badRequest);
-            return;
+            return nullptr;
         }
 
         RawRouteData raw_route;
         raw_route.check_sum = facade->GetCheckSum();
 
         if (std::any_of(begin(route_parameters.coordinates),
                         end(route_parameters.coordinates),
-                        [&](FixedPointCoordinate coordinate)
-                        {
-                return !coordinate.isValid();
-            }))
+                        [&](FixedPointCoordinate coordinate) {
+                            return !coordinate.isValid();
+                        }))
         {
-            reply = http::Reply::StockReply(http::Reply::badRequest);
-            return;
+            return nullptr;
         }
 
         for (const FixedPointCoordinate &coordinate : route_parameters.coordinates)
@@ -91,8 +91,7 @@ template <class DataFacadeT> class DistanceTablePlugin : public BasePlugin
         }
 
         const bool checksum_OK = (route_parameters.check_sum == raw_route.check_sum);
-        unsigned max_locations =
-            std::min(100u, static_cast<unsigned>(raw_route.raw_via_node_coordinates.size()));
+        unsigned max_locations = raw_route.raw_via_node_coordinates.size();
         PhantomNodeArray phantom_node_vector(max_locations);
         for (unsigned i = 0; i < max_locations; ++i)
         {
@@ -115,10 +114,32 @@ template <class DataFacadeT> class DistanceTablePlugin : public BasePlugin
             BOOST_ASSERT(phantom_node_vector[i].front().isValid(facade->GetNumberOfNodes()));
         }
 
-        // TIMER_START(distance_table);
-        std::shared_ptr<std::vector<EdgeWeight>> result_table =
-            search_engine_ptr->distance_table(phantom_node_vector);
-        // TIMER_STOP(distance_table);
+        TIMER_START(distance_table);
+        std::shared_ptr<std::vector<EdgeWeight>> result_table;
+
+        if (single_source)
+        {
+            result_table = search_engine_ptr->distance_table_single_source(phantom_node_vector);
+        }
+        else if (single_target)
+        {
+            result_table = search_engine_ptr->distance_table_single_target(phantom_node_vector);
+        }
+        else
+        {
+            result_table = search_engine_ptr->distance_table(phantom_node_vector);
+        }
+
+        TIMER_STOP(distance_table);
+        calctime_in_us = TIMER_USEC(distance_table);
+
+        return result_table;
+    }
+
+    void HandleRequest(const RouteParameters &route_parameters, http::Reply &reply) final
+    {
+        unsigned calctime_in_us = 0;
+        auto result_table = HandleRequest(route_parameters, calctime_in_us);
 
         if (!result_table)
         {
@@ -127,7 +148,7 @@ template <class DataFacadeT> class DistanceTablePlugin : public BasePlugin
         }
         JSON::Object json_object;
         JSON::Array json_array;
-        const unsigned number_of_locations = static_cast<unsigned>(phantom_node_vector.size());
+        const unsigned number_of_locations = route_parameters.coordinates.size();
         for (unsigned row = 0; row < number_of_locations; ++row)
         {
             JSON::Array json_row;

diff --git a/Plugins/MultiTargetPlugin.h b/Plugins/MultiTargetPlugin.h
@@ -33,6 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../Algorithms/ObjectToBase64.h"
 
 #include "../DataStructures/SearchEngine.h"
+#include "../Util/TimingUtil.h"
 
 
 template <class DataFacadeT, bool forward> class MultiTargetPlugin : public BasePlugin
@@ -45,7 +46,8 @@ template <class DataFacadeT, bool forward> class MultiTargetPlugin : public Base
 
     virtual ~MultiTargetPlugin() {}
 
-    std::shared_ptr<std::vector<std::pair<EdgeWeight, double>>> HandleRequest(const RouteParameters &route_parameters)
+    std::shared_ptr<std::vector<std::pair<EdgeWeight, double>>> HandleRequest(const RouteParameters &route_parameters,
+                                                                              unsigned &calctime_in_us)
     {
         // check number of parameters
         if (2 > route_parameters.coordinates.size())
@@ -93,19 +95,27 @@ template <class DataFacadeT, bool forward> class MultiTargetPlugin : public Base
             BOOST_ASSERT(phantom_node_vector[i].front().isValid(facade->GetNumberOfNodes()));
         }
 
+        std::shared_ptr<std::vector<std::pair<EdgeWeight, double>>> ret;
+
+        TIMER_START(multi_target);
         if (forward)
         {
-            return search_engine_ptr->multi_target(phantom_node_vector);
+            ret = search_engine_ptr->multi_target(phantom_node_vector);
         }
         else
         {
-            return search_engine_ptr->multi_source(phantom_node_vector);
+            ret = search_engine_ptr->multi_source(phantom_node_vector);
         }
+        TIMER_STOP(multi_target);
+        calctime_in_us = TIMER_USEC(multi_target);
+
+        return ret;
     }
 
     void HandleRequest(const RouteParameters &route_parameters, http::Reply &reply)
     {
-        std::shared_ptr<std::vector<std::pair<EdgeWeight, double>>> result_table = HandleRequest(route_parameters);
+        unsigned calctime_in_ms = 0;
+        auto result_table = HandleRequest(route_parameters, calctime_in_ms);
 
         if (!result_table)
         {

diff --git a/RoutingAlgorithms/BasicRoutingInterface.h b/RoutingAlgorithms/BasicRoutingInterface.h
@@ -38,13 +38,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stack>
 
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap;
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap;
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap2;
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap2;
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap3;
-SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap3;
-
 template <class DataFacadeT> class BasicRoutingInterface
 {
   private:

diff --git a/RoutingAlgorithms/ManyToManyRouting.h b/RoutingAlgorithms/ManyToManyRouting.h
@@ -39,7 +39,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <unordered_map>
 #include <vector>
 
-template <class DataFacadeT> class ManyToManyRouting : public BasicRoutingInterface<DataFacadeT>
+template <class DataFacadeT,
+          bool single_source,
+          bool single_target> class ManyToManyRouting : public BasicRoutingInterface<DataFacadeT>
 {
     typedef BasicRoutingInterface<DataFacadeT> super;
     typedef SearchEngineData::QueryHeap QueryHeap;
@@ -106,6 +108,12 @@ template <class DataFacadeT> class ManyToManyRouting : public BasicRoutingInterf
             {
                 BackwardRoutingStep(target_id, query_heap, search_space_with_buckets);
             }
+
+            if (single_target)
+            {
+                break;
+            }
+
             ++target_id;
         }
 
@@ -141,6 +149,11 @@ template <class DataFacadeT> class ManyToManyRouting : public BasicRoutingInterf
                                    result_table);
             }
 
+            if (single_source)
+            {
+                break;
+            }
+
             ++source_id;
         }
         BOOST_ASSERT(source_id == target_id);

diff --git a/Util/TimingUtil.h b/Util/TimingUtil.h
@@ -32,6 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #define TIMER_START(_X) auto _X##_start = std::chrono::steady_clock::now(), _X##_stop = _X##_start
 #define TIMER_STOP(_X) _X##_stop = std::chrono::steady_clock::now()
+#define TIMER_USEC(_X) std::chrono::duration_cast<std::chrono::microseconds>(_X##_stop - _X##_start).count()
 #define TIMER_MSEC(_X) std::chrono::duration_cast<std::chrono::milliseconds>(_X##_stop - _X##_start).count()
 #define TIMER_SEC(_X) (0.001*std::chrono::duration_cast<std::chrono::milliseconds>(_X##_stop - _X##_start).count())
 #define TIMER_MIN(_X) std::chrono::duration_cast<std::chrono::minutes>(_X##_stop - _X##_start).count()