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

First take at distance table API re-write

Browse Source
This commit is contained in:
Daniel J. Hofmann 2016-02-12 14:49:28 -08:00 committed by Patrick Niklaus
parent b58edc980c
commit d87a19b2f9
7 changed files with 164 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/engine/api/table_parameters.hpp
View File

@ -36,7 +36,7 @@ struct TableParameters : public BaseParameters
return false;
// 3/ 0 <= index < len(locations)
const auto is_not_in_range = [](const std::size_t x)
const auto not_in_range = [this](const std::size_t x)
{
return x >= coordinates.size();
};

22
include/engine/engine.hpp
View File

@ -26,10 +26,12 @@ struct EngineConfig;
namespace api
{
struct RouteParameters;
struct TableParameters;
}
namespace plugins
{
class ViaRoutePlugin;
class DistanceTablePlugin;
}
namespace datafacade
{
@ -39,26 +41,20 @@ class BaseDataFacade;
class Engine final
{
public:
struct EngineLock
{
// will only be initialized if shared memory is used
storage::SharedBarriers barrier;
// decrease number of concurrent queries
void DecreaseQueryCount();
// increase number of concurrent queries
void IncreaseQueryCount();
};
Engine(EngineConfig &config_);
Engine(EngineConfig &config);
Engine(const Engine &) = delete;
Engine &operator=(const Engine &) = delete;
Status Route(const api::RouteParameters &route_parameters, util::json::Object &json_result);
Status Route(const api::RouteParameters &parameters, util::json::Object &result);
Status Table(const api::TableParameters &parameters, util::json::Object &result);
private:
struct EngineLock;
std::unique_ptr<EngineLock> lock;
std::unique_ptr<plugins::ViaRoutePlugin> route_plugin;
std::unique_ptr<plugins::DistanceTablePlugin> table_plugin;
std::unique_ptr<datafacade::BaseDataFacade> query_data_facade;
};
}

168
include/engine/plugins/distance_table.hpp
View File

@ -3,8 +3,10 @@
#include "engine/plugins/plugin_base.hpp"
#include "engine/api/table_parameters.hpp"
#include "engine/object_encoder.hpp"
#include "engine/search_engine.hpp"
#include "engine/routing_algorithms/many_to_many.hpp"
#include "engine/search_engine_data.hpp"
#include "util/make_unique.hpp"
#include "util/string_util.hpp"
#include "osrm/json_container.hpp"
@ -23,109 +25,57 @@ namespace engine
namespace plugins
{
template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
class DistanceTablePlugin final : public BasePlugin
{
private:
std::unique_ptr<SearchEngine<DataFacadeT>> search_engine_ptr;
SearchEngineData heaps;
routing_algorithms::ManyToManyRouting<datafacade::BaseDataFacade> distance_table;
int max_locations_distance_table;
public:
explicit DistanceTablePlugin(DataFacadeT *facade, const int max_locations_distance_table)
: max_locations_distance_table(max_locations_distance_table), descriptor_string("table"),
facade(facade)
explicit DistanceTablePlugin(datafacade::BaseDataFacade *facade,
const int max_locations_distance_table)
: BasePlugin{*facade}, distance_table(facade, heaps),
max_locations_distance_table(max_locations_distance_table)
{
search_engine_ptr = util::make_unique<SearchEngine<DataFacadeT>>(facade);
}
virtual ~DistanceTablePlugin() {}
const std::string GetDescriptor() const override final { return descriptor_string; }
Status HandleRequest(const RouteParameters &route_parameters,
util::json::Object &json_result) override final
Status HandleRequest(const api::TableParameters &params, util::json::Object &result)
{
return NonConstHandleRequest(route_parameters, json_result);
}
BOOST_ASSERT(params.IsValid());
// XXX: should be const-ref, but we need to artificially source, destination values
// so consider this a hack for 4.9, in 5.0 we refactored and handle it beautifully!
Status NonConstHandleRequest(RouteParameters route_parameters, util::json::Object &json_result)
{
if (!check_all_coordinates(route_parameters.coordinates))
{
json_result.values["status_message"] = "Coordinates are invalid";
return Status::Error;
}
if (!CheckAllCoordinates(params.coordinates))
return Error("invalid-options", "Coordinates are invalid", result);
const auto &input_bearings = route_parameters.bearings;
if (input_bearings.size() > 0 &&
route_parameters.coordinates.size() != input_bearings.size())
{
json_result.values["status_message"] =
"Number of bearings does not match number of coordinates";
return Status::Error;
}
const auto number_of_coordinates = route_parameters.coordinates.size();
BOOST_ASSERT(route_parameters.is_source.size() <= number_of_coordinates);
BOOST_ASSERT(route_parameters.is_destination.size() <= number_of_coordinates);
// The check_all_coordinates guard above makes sure we have at least 2 coordinates.
// This establishes the parallel array invariant for is_source, is_destination, coordinates
if (route_parameters.is_source.size() == 0)
{
const auto where = route_parameters.is_source.end();
const auto n = number_of_coordinates - route_parameters.is_source.size();
route_parameters.is_source.insert(where, n, true);
}
if (route_parameters.is_destination.size() == 0)
{
const auto where = route_parameters.is_destination.end();
const auto n = number_of_coordinates - route_parameters.is_destination.size();
route_parameters.is_destination.insert(where, n, true);
}
// parallel array invariant
BOOST_ASSERT(route_parameters.coordinates.size() == route_parameters.is_source.size());
BOOST_ASSERT(route_parameters.coordinates.size() == route_parameters.is_destination.size());
const auto number_of_sources = std::count(route_parameters.is_source.begin(), //
route_parameters.is_source.end(), true);
const auto number_of_destination = std::count(route_parameters.is_destination.begin(), //
route_parameters.is_destination.end(), true);
if (params.bearings.size() > 0 && params.coordinates.size() != params.bearings.size())
return Error("invalid-options", "Number of bearings does not match number of coordinates", result);
if (max_locations_distance_table > 0 &&
(number_of_sources * number_of_destination >
(params.sources.size() * params.destinations.size() >
max_locations_distance_table * max_locations_distance_table))
{
json_result.values["status_message"] =
"Number of entries " + std::to_string(number_of_sources * number_of_destination) +
return Error("invalid-options", "Number of entries " + std::to_string(params.sources.size() * params.destinations.size()) +
" is higher than current maximum (" +
std::to_string(max_locations_distance_table * max_locations_distance_table) + ")";
return Status::Error;
}
std::to_string(max_locations_distance_table * max_locations_distance_table) + ")", result);
const bool checksum_OK = (route_parameters.check_sum == facade->GetCheckSum());
const bool checksum_OK = (params.check_sum == BasePlugin::facade.GetCheckSum());
std::vector<PhantomNodePair> phantom_node_source_vector(number_of_sources);
std::vector<PhantomNodePair> phantom_node_target_vector(number_of_destination);
std::vector<PhantomNodePair> phantom_node_source_vector(params.sources.size());
std::vector<PhantomNodePair> phantom_node_target_vector(params.destinations.size());
auto phantom_node_source_out_iter = phantom_node_source_vector.begin();
auto phantom_node_target_out_iter = phantom_node_target_vector.begin();
for (const auto i : util::irange<std::size_t>(0u, route_parameters.coordinates.size()))
for (const auto i : util::irange<std::size_t>(0u, params.coordinates.size()))
{
if (checksum_OK && i < route_parameters.hints.size() &&
!route_parameters.hints[i].empty())
if (checksum_OK && i < params.hints.size() && !params.hints[i].empty())
{
auto current_phantom_node = decodeBase64<PhantomNode>(route_parameters.hints[i]);
if (current_phantom_node.IsValid(facade->GetNumberOfNodes()))
PhantomNode current_phantom_node;
ObjectEncoder::DecodeFromBase64(params.hints[i], current_phantom_node);
if (current_phantom_node.IsValid(BasePlugin::facade.GetNumberOfNodes()))
{
if (route_parameters.is_source[i])
if (params.is_source[i])
{
*phantom_node_source_out_iter =
std::make_pair(current_phantom_node, current_phantom_node);
if (route_parameters.is_destination[i])
if (params.is_destination[i])
{
*phantom_node_target_out_iter = *phantom_node_source_out_iter;
phantom_node_target_out_iter++;
@ -134,8 +84,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
}
else
{
BOOST_ASSERT(route_parameters.is_destination[i] &&
!route_parameters.is_source[i]);
BOOST_ASSERT(params.is_destination[i] && !params.is_source[i]);
*phantom_node_target_out_iter =
std::make_pair(current_phantom_node, current_phantom_node);
phantom_node_target_out_iter++;
@ -143,26 +92,26 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
continue;
}
}
const int bearing = input_bearings.size() > 0 ? input_bearings[i].first : 0;
const int range = input_bearings.size() > 0
? (input_bearings[i].second ? *input_bearings[i].second : 10)
const int bearing = params.bearings.size() > 0 ? params.bearings[i].first : 0;
const int range = params.bearings.size() > 0
? (params.bearings[i].second ? *param_bearings[i].second : 10)
: 180;
if (route_parameters.is_source[i])
if (params.is_source[i])
{
*phantom_node_source_out_iter =
facade->NearestPhantomNodeWithAlternativeFromBigComponent(
route_parameters.coordinates[i], bearing, range);
BasePlugin::facade.NearestPhantomNodeWithAlternativeFromBigComponent(
params.coordinates[i], bearing, range);
// we didn't found a fitting node, return error
if (!phantom_node_source_out_iter->first.IsValid(facade->GetNumberOfNodes()))
if (!phantom_node_source_out_iter->first.IsValid(
BasePlugin::facade.GetNumberOfNodes()))
{
json_result.values["status_message"] =
result.values["status_message"] =
std::string("Could not find a matching segment for coordinate ") +
std::to_string(i);
return Status::NoSegment;
}
if (route_parameters.is_destination[i])
if (params.is_destination[i])
{
*phantom_node_target_out_iter = *phantom_node_source_out_iter;
phantom_node_target_out_iter++;
@ -171,15 +120,16 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
}
else
{
BOOST_ASSERT(route_parameters.is_destination[i] && !route_parameters.is_source[i]);
BOOST_ASSERT(params.is_destination[i] && !params.is_source[i]);
*phantom_node_target_out_iter =
facade->NearestPhantomNodeWithAlternativeFromBigComponent(
route_parameters.coordinates[i], bearing, range);
BasePlugin::facade.NearestPhantomNodeWithAlternativeFromBigComponent(
params.coordinates[i], bearing, range);
// we didn't found a fitting node, return error
if (!phantom_node_target_out_iter->first.IsValid(facade->GetNumberOfNodes()))
if (!phantom_node_target_out_iter->first.IsValid(
BasePlugin::facade.GetNumberOfNodes()))
{
json_result.values["status_message"] =
result.values["status_message"] =
std::string("Could not find a matching segment for coordinate ") +
std::to_string(i);
return Status::NoSegment;
@ -189,34 +139,34 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
}
BOOST_ASSERT((phantom_node_source_out_iter - phantom_node_source_vector.begin()) ==
number_of_sources);
params.sources.size());
BOOST_ASSERT((phantom_node_target_out_iter - phantom_node_target_vector.begin()) ==
number_of_destination);
params.destinations.size());
// FIXME we should clear phantom_node_source_vector and phantom_node_target_vector after
// this
auto snapped_source_phantoms = snapPhantomNodes(phantom_node_source_vector);
auto snapped_target_phantoms = snapPhantomNodes(phantom_node_target_vector);
auto result_table =
search_engine_ptr->distance_table(snapped_source_phantoms, snapped_target_phantoms);
auto result_table = distance_table(snapped_source_phantoms, snapped_target_phantoms);
if (!result_table)
{
json_result.values["status_message"] = "No distance table found";
result.values["status_message"] = "No distance table found";
return Status::EmptyResult;
}
util::json::Array matrix_json_array;
for (const auto row : util::irange<std::size_t>(0, number_of_sources))
for (const auto row : util::irange<std::size_t>(0, params.sources.size()))
{
util::json::Array json_row;
auto row_begin_iterator = result_table->begin() + (row * number_of_destination);
auto row_end_iterator = result_table->begin() + ((row + 1) * number_of_destination);
auto row_begin_iterator = result_table->begin() + (row * params.destinations.size());
auto row_end_iterator =
result_table->begin() + ((row + 1) * params.destinations.size());
json_row.values.insert(json_row.values.end(), row_begin_iterator, row_end_iterator);
matrix_json_array.values.push_back(json_row);
}
json_result.values["distance_table"] = std::move(matrix_json_array);
result.values["distance_table"] = matrix_json_array;
util::json::Array target_coord_json_array;
for (const auto &phantom : snapped_target_phantoms)
@ -226,7 +176,7 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION);
target_coord_json_array.values.push_back(json_coord);
}
json_result.values["destination_coordinates"] = std::move(target_coord_json_array);
result.values["destination_coordinates"] = target_coord_json_array;
util::json::Array source_coord_json_array;
for (const auto &phantom : snapped_source_phantoms)
{
@ -235,13 +185,9 @@ template <class DataFacadeT> class DistanceTablePlugin final : public BasePlugin
json_coord.values.push_back(phantom.location.lon / COORDINATE_PRECISION);
source_coord_json_array.values.push_back(json_coord);
}
json_result.values["source_coordinates"] = std::move(source_coord_json_array);
result.values["source_coordinates"] = source_coord_json_array;
return Status::Ok;
}
private:
std::string descriptor_string;
DataFacadeT *facade;
};
}
}

2
include/engine/routing_algorithms/many_to_many.hpp
View File

@ -44,8 +44,6 @@ class ManyToManyRouting final
{
}
~ManyToManyRouting() {}
std::shared_ptr<std::vector<EdgeWeight>>
operator()(const std::vector<PhantomNode> &phantom_sources_array,
const std::vector<PhantomNode> &phantom_targets_array) const

18
include/osrm/osrm.hpp
View File

@ -49,24 +49,30 @@ struct EngineConfig;
namespace api
{
struct RouteParameters;
struct TableParameters;
}
}
using engine::EngineConfig;
using engine::api::RouteParameters;
using engine::api::TableParameters;
namespace json = util::json;
class OSRM
{
public:
explicit OSRM(EngineConfig &config);
~OSRM();
OSRM(OSRM &&) noexcept;
OSRM &operator=(OSRM &&) noexcept;
Status Route(const RouteParameters &parameters, json::Object &result);
Status Table(const TableParameters &parameters, json::Object &result);
private:
std::unique_ptr<engine::Engine> engine_;
public:
OSRM(EngineConfig &lib_config);
~OSRM(); // needed for unique_ptr + impl abstraction
Status Route(const RouteParameters &route_parameters, json::Object &json_result);
};
}
#endif // OSRM_HPP

122
src/engine/engine.cpp
View File

@ -3,7 +3,7 @@
#include "engine/api/route_parameters.hpp"
#include "engine/status.hpp"
//#include "engine/plugins/distance_table.hpp"
#include "engine/plugins/distance_table.hpp"
//#include "engine/plugins/hello_world.hpp"
//#include "engine/plugins/nearest.hpp"
//#include "engine/plugins/timestamp.hpp"
@ -35,59 +35,15 @@ namespace osrm
{
namespace engine
{
// Abstracted away the query locking into a template function
// Works the same for every plugin.
template<typename ParameterT, typename PluginT>
Status RunQuery(const std::unique_ptr<Engine::EngineLock> &lock,
datafacade::BaseDataFacade &facade,
const ParameterT &parameters,
PluginT &plugin,
util::json::Object &json_result)
struct Engine::EngineLock
{
if (!lock)
{
return plugin.HandleRequest(parameters, json_result);
}
BOOST_ASSERT(lock);
lock->IncreaseQueryCount();
auto& shared_facade = static_cast<datafacade::SharedDataFacade &>(facade);
shared_facade.CheckAndReloadFacade();
// Get a shared data lock so that other threads won't update
// things while the query is running
boost::shared_lock<boost::shared_mutex> data_lock{shared_facade.data_mutex};
Status status = plugin.HandleRequest(parameters, json_result);
lock->DecreaseQueryCount();
return status;
}
Engine::Engine(EngineConfig &config)
{
if (config.use_shared_memory)
{
lock = util::make_unique<EngineLock>();
query_data_facade = util::make_unique<datafacade::SharedDataFacade>();
}
else
{
// populate base path
util::populate_base_path(config.server_paths);
query_data_facade = util::make_unique<datafacade::InternalDataFacade>(config.server_paths);
}
route_plugin = util::make_unique<plugins::ViaRoutePlugin>(*query_data_facade, config.max_locations_viaroute);
}
Status Engine::Route(const api::RouteParameters &route_parameters,
util::json::Object &result)
{
return RunQuery(lock, *query_data_facade, route_parameters, *route_plugin, result);
}
// will only be initialized if shared memory is used
storage::SharedBarriers barrier;
// decrease number of concurrent queries
void DecreaseQueryCount();
// increase number of concurrent queries
void IncreaseQueryCount();
};
// decrease number of concurrent queries
void Engine::EngineLock::DecreaseQueryCount()
@ -124,5 +80,65 @@ void Engine::EngineLock::IncreaseQueryCount()
// increment query count
++(barrier.number_of_queries);
}
} // ns engine
} // ns osrm
namespace
{
// Abstracted away the query locking into a template function
// Works the same for every plugin.
template <typename ParameterT, typename PluginT>
osrm::engine::Status RunQuery(const std::unique_ptr<osrm::engine::Engine::EngineLock> &lock,
osrm::engine::datafacade::BaseDataFacade &facade,
const ParameterT &parameters,
PluginT &plugin,
osrm::util::json::Object &json_result)
{
if (!lock)
{
return plugin.HandleRequest(parameters, json_result);
}
BOOST_ASSERT(lock);
lock->IncreaseQueryCount();
auto &shared_facade = static_cast<osrm::engine::datafacade::SharedDataFacade &>(facade);
shared_facade.CheckAndReloadFacade();
// Get a shared data lock so that other threads won't update
// things while the query is running
boost::shared_lock<boost::shared_mutex> data_lock{shared_facade.data_mutex};
osrm::engine::Status status = plugin.HandleRequest(parameters, json_result);
lock->DecreaseQueryCount();
return status;
}
} // anon. ns
namespace osrm
{
namespace engine
{
Engine::Engine(EngineConfig &config)
{
if (config.use_shared_memory)
{
lock = util::make_unique<EngineLock>();
query_data_facade = util::make_unique<datafacade::SharedDataFacade>();
}
else
{
util::populate_base_path(config.server_paths);
query_data_facade = util::make_unique<datafacade::InternalDataFacade>(config.server_paths);
}
route_plugin = util::make_unique<plugins::ViaRoutePlugin>(*query_data_facade,
config.max_locations_viaroute);
}
Status Engine::Route(const api::RouteParameters &route_parameters, util::json::Object &result)
{
return RunQuery(lock, *query_data_facade, route_parameters, *route_plugin, result);
}
} // engine ns
} // osrm ns

24
src/osrm/osrm.cpp
View File

@ -1,23 +1,31 @@
#include "osrm/osrm.hpp"
#include "engine/api/route_parameters.hpp"
#include "engine/api/table_parameters.hpp"
#include "engine/engine.hpp"
#include "engine/status.hpp"
#include "engine/engine_config.hpp"
#include "engine/plugins/viaroute.hpp"
#include "storage/shared_barriers.hpp"
#include "util/make_unique.hpp"
namespace osrm
{
// proxy code for compilation firewall
OSRM::OSRM(engine::EngineConfig &config_) : engine_(util::make_unique<engine::Engine>(config_)) {}
// Pimpl idiom
// needed because unique_ptr needs the size of OSRM_impl for delete
OSRM::~OSRM() {}
OSRM::OSRM(engine::EngineConfig &config) : engine_(util::make_unique<engine::Engine>(config)) {}
OSRM::~OSRM() = default;
OSRM::OSRM(OSRM &&) noexcept = default;
OSRM &OSRM::operator=(OSRM &&) noexcept = default;
engine::Status OSRM::Route(const RouteParameters &route_parameters, util::json::Object &json_result)
// Forward to implementation
engine::Status OSRM::Route(const engine::api::RouteParameters &params, util::json::Object &result)
{
return engine_->Route(route_parameters, json_result);
return engine_->Route(params, result);
}
engine::Status OSRM::Table(const engine::api::TableParameters &params, json::Object &result)
{
return engine_->Table(params, result);
}
} // ns osrm