Multi Source / Multi Target routing

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 2.8.8)
 
-if(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.")
@@ -11,7 +11,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(GetGitRevisionDescription)
 git_describe(GIT_DESCRIPTION)
 
@@ -30,26 +30,26 @@ endif()
 OPTION(WITH_TOOLS "Build OSRM tools" OFF)
 OPTION(BUILD_TOOLS "Build OSRM tools" OFF)
 
-include_directories(${CMAKE_SOURCE_DIR}/Include/)
-include_directories(${CMAKE_SOURCE_DIR}/third_party/)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/Include/)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
 
-add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/Util/finger_print.cpp finger_print.cpp.alwaysbuild
- COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
+add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/Util/finger_print.cpp finger_print.cpp.alwaysbuild
+ COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}
  -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/FingerPrint-Config.cmake
  DEPENDS
- ${CMAKE_SOURCE_DIR}/Util/finger_print.cpp.in
+ ${CMAKE_CURRENT_SOURCE_DIR}/Util/finger_print.cpp.in
  COMMENT "Configuring finger_print.cpp"
  VERBATIM)
 
-add_custom_target(FingerPrintConfigure DEPENDS ${CMAKE_SOURCE_DIR}/Util/finger_print.cpp)
+add_custom_target(FingerPrintConfigure DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Util/finger_print.cpp)
 add_custom_target(tests DEPENDS datastructure-tests algorithm-tests)
 add_custom_target(benchmarks DEPENDS rtree-bench)
 
 set(BOOST_COMPONENTS date_time filesystem iostreams program_options regex system thread unit_test_framework)
 
 configure_file(
- ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp.in
- ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Util/GitDescription.cpp.in
+ ${CMAKE_CURRENT_SOURCE_DIR}/Util/GitDescription.cpp
 )
 file(GLOB ExtractorGlob extractor/*.cpp)
 file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp)
@@ -104,14 +104,7 @@ add_executable(rtree-bench EXCLUDE_FROM_ALL benchmarks/static_rtree.cpp $<TARGET
 if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
  set(CMAKE_BUILD_TYPE Release)
 endif()
-if(CMAKE_BUILD_TYPE MATCHES Debug)
- message(STATUS "Configuring OSRM in debug mode")
- if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
- message(STATUS "adding profiling flags")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
- set(CMAKE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
- endif()
-endif()
+
 if(CMAKE_BUILD_TYPE MATCHES Release)
  message(STATUS "Configuring OSRM in release mode")
  # Check if LTO is available
@@ -337,7 +330,7 @@ foreach (lib ${Boost_LIBRARIES})
  set(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_LISTING} -l${BOOST_LIBRARY_NAME}")
 endforeach ()
 
-configure_file(${CMAKE_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
 install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION lib/pkgconfig)
 
 if(BUILD_DEBIAN_PACKAGE)

Library/OSRM_impl.cpp

@@ -37,6 +37,7 @@ namespace boost { namespace interprocess { class named_mutex; } }
 #include "../plugins/distance_table.hpp"
 #include "../plugins/hello_world.hpp"
 #include "../plugins/locate.hpp"
+#include "../plugins/multi_target.hpp"
 #include "../plugins/nearest.hpp"
 #include "../plugins/timestamp.hpp"
 #include "../plugins/viaroute.hpp"
@@ -72,10 +73,12 @@ OSRM_impl::OSRM_impl(ServerPaths server_paths, const bool use_shared_memory)
  }
 
  // 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));
+ RegisterPlugin(new MultiTargetPlugin<BaseDataFacade<QueryEdge::EdgeData>, false>(query_data_facade));
  RegisterPlugin(new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
+ RegisterPlugin(new DistanceTablePlugin<BaseDataFacade<QueryEdge::EdgeData>, false, false>(query_data_facade));
  RegisterPlugin(new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
  RegisterPlugin(new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
 }

data_structures/search_engine.hpp

@@ -31,6 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "search_engine_data.hpp"
 #include "../routing_algorithms/alternative_path.hpp"
 #include "../routing_algorithms/many_to_many.hpp"
+#include "../routing_algorithms/multi_target.hpp"
 #include "../routing_algorithms/shortest_path.hpp"
 
 #include <type_traits>
@@ -44,11 +45,20 @@ 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)
  {
  static_assert(!std::is_pointer<DataFacadeT>::value, "don't instantiate with ptr type");
  static_assert(std::is_object<DataFacadeT>::value, "don't instantiate with void, function, or reference");

data_structures/search_engine_data.cpp

@@ -29,6 +29,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "binary_heap.hpp"
 
+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())

plugins/distance_table.hpp

@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../data_structures/query_edge.hpp"
 #include "../data_structures/search_engine.hpp"
 #include "../descriptors/descriptor_base.hpp"
+#include "../Util/integer_range.hpp"
 #include "../Util/json_renderer.hpp"
 #include "../Util/make_unique.hpp"
 #include "../Util/StringUtil.h"
@@ -48,7 +49,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>
 
-template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
+template <class DataFacadeT,
+ bool single_source,
+ bool single_target> class DistanceTablePlugin final : public BasePlugin
 {
  private:
  std::unique_ptr<SearchEngine<DataFacadeT>> search_engine_ptr;
@@ -63,19 +66,15 @@ template <class DataFacadeT> class DistanceTablePlugin final : 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)
  {
  if (!check_all_coordinates(route_parameters.coordinates))
- {
- reply = http::Reply::StockReply(http::Reply::badRequest);
- return;
- }
+ return {};
 
  const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum());
- unsigned max_locations =
- std::min(100u, static_cast<unsigned>(route_parameters.coordinates.size()));
- PhantomNodeArray phantom_node_vector(max_locations);
- for (const auto i : osrm::irange(1u, max_locations))
+ PhantomNodeArray phantom_node_vector(route_parameters.coordinates.size());
+ for (const auto i : osrm::irange(0ul, route_parameters.coordinates.size()))
  {
  if (checksum_OK && i < route_parameters.hints.size() &&
  !route_parameters.hints[i].empty())
@@ -96,20 +95,43 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
  BOOST_ASSERT(phantom_node_vector[i].front().is_valid(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);
+ std::shared_ptr<std::vector<EdgeWeight>> result_table;
+
+ TIMER_START(distance_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)
  {
  reply = http::Reply::StockReply(http::Reply::badRequest);
  return;
  }
+
  JSON::Object json_object;
  JSON::Array json_array;
- const unsigned number_of_locations = static_cast<unsigned>(phantom_node_vector.size());
- for (unsigned row = 0; row < number_of_locations; ++row)
+ const auto number_of_locations = route_parameters.coordinates.size();
+ for (const auto row : osrm::irange<std::size_t>(0, number_of_locations))
  {
  JSON::Array json_row;
  auto row_begin_iterator = result_table->begin() + (row * number_of_locations);

plugins/multi_target.hpp

@@ -0,0 +1,140 @@
+/*
+
+Copyright (c) 2014, Project OSRM, Felix Guendling
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef MULTI_TARGET_PLUGIN_H
+#define MULTI_TARGET_PLUGIN_H
+
+#include "plugin_base.hpp"
+
+#include "../Algorithms/object_encoder.hpp"
+#include "../data_structures/search_engine.hpp"
+#include "../Util/json_renderer.hpp"
+#include "../Util/TimingUtil.h"
+
+template <class DataFacadeT, bool forward> class MultiTargetPlugin final : public BasePlugin
+{
+ public:
+ explicit MultiTargetPlugin(DataFacadeT *facade)
+ : facade(facade), search_engine_ptr(std::make_shared<SearchEngine<DataFacadeT>>(facade))
+ {
+ }
+
+ virtual ~MultiTargetPlugin() {}
+
+ 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())
+ {
+ return nullptr;
+ }
+
+ if (std::any_of(begin(route_parameters.coordinates), end(route_parameters.coordinates),
+ [&](FixedPointCoordinate coordinate)
+ {
+ return !coordinate.is_valid();
+ }))
+ {
+ return nullptr;
+ }
+
+ const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum());
+ PhantomNodeArray phantom_node_vector(route_parameters.coordinates.size());
+ for (unsigned i = 0; i < route_parameters.coordinates.size(); ++i)
+ {
+ if (checksum_OK && i < route_parameters.hints.size() &&
+ !route_parameters.hints[i].empty())
+ {
+ PhantomNode current_phantom_node;
+ ObjectEncoder::DecodeFromBase64(route_parameters.hints[i], current_phantom_node);
+ if (current_phantom_node.is_valid(facade->GetNumberOfNodes()))
+ {
+ phantom_node_vector[i].emplace_back(std::move(current_phantom_node));
+ continue;
+ }
+ }
+ facade->IncrementalFindPhantomNodeForCoordinate(route_parameters.coordinates[i],
+ phantom_node_vector[i],
+ route_parameters.zoom_level,
+ 1);
+
+ BOOST_ASSERT(phantom_node_vector[i].front().is_valid(facade->GetNumberOfNodes()));
+ }
+
+ std::shared_ptr<std::vector<std::pair<EdgeWeight, double>>> ret;
+
+ TIMER_START(multi_target);
+ if (forward)
+ {
+ ret = search_engine_ptr->multi_target(phantom_node_vector);
+ }
+ else
+ {
+ 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)
+ {
+ unsigned calctime_in_ms = 0;
+ auto result_table = HandleRequest(route_parameters, calctime_in_ms);
+
+ if (!result_table)
+ {
+ reply = http::Reply::StockReply(http::Reply::badRequest);
+ return;
+ }
+
+ JSON::Object json_object;
+ JSON::Array json_array;
+ for (unsigned column = 0; column < route_parameters.coordinates.size() - 1; ++column)
+ {
+ auto routing_result = result_table->operator[](column);
+
+ JSON::Object result;
+ result.values["time_cost"] = routing_result.first;
+ result.values["distance"] = routing_result.second;
+ json_array.values.emplace_back(result);
+ }
+ json_object.values["distances"] = json_array;
+ JSON::render(reply.content, json_object);
+ }
+
+ const std::string GetDescriptor() const { return forward ? "multitarget" : "multisource"; }
+
+ private:
+ DataFacadeT *facade;
+ std::shared_ptr<SearchEngine<DataFacadeT>> search_engine_ptr;
+};
+
+#endif // MULTI_TARGET_PLUGIN_H