diff --git a/CHANGELOG.md b/CHANGELOG.md index 32a588a0c..b22cdf75d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,7 @@ - ADDED: Add documentation about OSM node ids in nearest service response [#4436](https://github.com/Project-OSRM/osrm-backend/pull/4436) - Performance - FIXED: Speed up response time when lots of legs exist and geojson is used with `steps=true` [#4936](https://github.com/Project-OSRM/osrm-backend/pull/4936) + - FIXED: Return iterators instead of vectors in datafacade_base functions [#4969](https://github.com/Project-OSRM/osrm-backend/issues/4969) - Misc: - ADDED: expose name for datasource annotations as metadata [#4973](https://github.com/Project-OSRM/osrm-backend/pull/4973) diff --git a/include/engine/api/nearest_api.hpp b/include/engine/api/nearest_api.hpp index 14fa267ef..4aca90d7c 100644 --- a/include/engine/api/nearest_api.hpp +++ b/include/engine/api/nearest_api.hpp @@ -34,56 +34,55 @@ class NearestAPI final : public BaseAPI util::json::Array waypoints; waypoints.values.resize(phantom_nodes.front().size()); - std::transform(phantom_nodes.front().begin(), - phantom_nodes.front().end(), - waypoints.values.begin(), - [this](const PhantomNodeWithDistance &phantom_with_distance) { - auto &phantom_node = phantom_with_distance.phantom_node; - auto waypoint = MakeWaypoint(phantom_node); - waypoint.values["distance"] = phantom_with_distance.distance; + std::transform( + phantom_nodes.front().begin(), + phantom_nodes.front().end(), + waypoints.values.begin(), + [this](const PhantomNodeWithDistance &phantom_with_distance) { + auto &phantom_node = phantom_with_distance.phantom_node; + auto waypoint = MakeWaypoint(phantom_node); + waypoint.values["distance"] = phantom_with_distance.distance; - util::json::Array nodes; + util::json::Array nodes; - std::uint64_t from_node = 0; - std::uint64_t to_node = 0; + std::uint64_t from_node = 0; + std::uint64_t to_node = 0; - std::vector forward_geometry; - if (phantom_node.forward_segment_id.enabled) - { - auto segment_id = phantom_node.forward_segment_id.id; - const auto geometry_id = facade.GetGeometryIndex(segment_id).id; - forward_geometry = - facade.GetUncompressedForwardGeometry(geometry_id); + datafacade::BaseDataFacade::NodesIDRangeT forward_geometry; + if (phantom_node.forward_segment_id.enabled) + { + auto segment_id = phantom_node.forward_segment_id.id; + const auto geometry_id = facade.GetGeometryIndex(segment_id).id; + forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id); - auto osm_node_id = facade.GetOSMNodeIDOfNode( - forward_geometry[phantom_node.fwd_segment_position]); - to_node = static_cast(osm_node_id); - } + auto osm_node_id = facade.GetOSMNodeIDOfNode( + forward_geometry[phantom_node.fwd_segment_position]); + to_node = static_cast(osm_node_id); + } - if (phantom_node.reverse_segment_id.enabled) - { - auto segment_id = phantom_node.reverse_segment_id.id; - const auto geometry_id = facade.GetGeometryIndex(segment_id).id; - std::vector geometry = - facade.GetUncompressedForwardGeometry(geometry_id); - auto osm_node_id = facade.GetOSMNodeIDOfNode( - geometry[phantom_node.fwd_segment_position + 1]); - from_node = static_cast(osm_node_id); - } - else if (phantom_node.forward_segment_id.enabled && - phantom_node.fwd_segment_position > 0) - { - // In the case of one way, rely on forward segment only - auto osm_node_id = facade.GetOSMNodeIDOfNode( - forward_geometry[phantom_node.fwd_segment_position - 1]); - from_node = static_cast(osm_node_id); - } - nodes.values.push_back(from_node); - nodes.values.push_back(to_node); - waypoint.values["nodes"] = std::move(nodes); + if (phantom_node.reverse_segment_id.enabled) + { + auto segment_id = phantom_node.reverse_segment_id.id; + const auto geometry_id = facade.GetGeometryIndex(segment_id).id; + const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id); + auto osm_node_id = + facade.GetOSMNodeIDOfNode(geometry[phantom_node.fwd_segment_position + 1]); + from_node = static_cast(osm_node_id); + } + else if (phantom_node.forward_segment_id.enabled && + phantom_node.fwd_segment_position > 0) + { + // In the case of one way, rely on forward segment only + auto osm_node_id = facade.GetOSMNodeIDOfNode( + forward_geometry[phantom_node.fwd_segment_position - 1]); + from_node = static_cast(osm_node_id); + } + nodes.values.push_back(from_node); + nodes.values.push_back(to_node); + waypoint.values["nodes"] = std::move(nodes); - return waypoint; - }); + return waypoint; + }); response.values["code"] = "Ok"; response.values["waypoints"] = std::move(waypoints); diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp index ca0725f51..b84df9d24 100644 --- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp +++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp @@ -239,72 +239,57 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade return m_osmnodeid_list[id]; } - std::vector GetUncompressedForwardGeometry(const EdgeID id) const override final + NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID id) const override final { - - auto range = segment_data.GetForwardGeometry(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetForwardGeometry(id); } - virtual std::vector GetUncompressedReverseGeometry(const EdgeID id) const override final + NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID id) const override final { - auto range = segment_data.GetReverseGeometry(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetReverseGeometry(id); } - virtual std::vector - GetUncompressedForwardDurations(const EdgeID id) const override final + DurationsRangeT GetUncompressedForwardDurations(const EdgeID id) const override final { - auto range = segment_data.GetForwardDurations(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetForwardDurations(id); } - virtual std::vector - GetUncompressedReverseDurations(const EdgeID id) const override final + DurationsRangeT GetUncompressedReverseDurations(const EdgeID id) const override final { - auto range = segment_data.GetReverseDurations(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetReverseDurations(id); } - virtual std::vector - GetUncompressedForwardWeights(const EdgeID id) const override final + WeightsRangeT GetUncompressedForwardWeights(const EdgeID id) const override final { - auto range = segment_data.GetForwardWeights(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetForwardWeights(id); } - virtual std::vector - GetUncompressedReverseWeights(const EdgeID id) const override final + WeightsRangeT GetUncompressedReverseWeights(const EdgeID id) const override final { - auto range = segment_data.GetReverseWeights(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetReverseWeights(id); } // Returns the data source ids that were used to supply the edge // weights. - virtual std::vector - GetUncompressedForwardDatasources(const EdgeID id) const override final + DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID id) const override final { - auto range = segment_data.GetForwardDatasources(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetForwardDatasources(id); } // Returns the data source ids that were used to supply the edge // weights. - virtual std::vector - GetUncompressedReverseDatasources(const EdgeID id) const override final + DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID id) const override final { - auto range = segment_data.GetReverseDatasources(id); - return std::vector{range.begin(), range.end()}; + return segment_data.GetReverseDatasources(id); } - virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final + TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final { BOOST_ASSERT(m_turn_weight_penalties.size() > id); return m_turn_weight_penalties[id]; } - virtual TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const override final + TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const override final { BOOST_ASSERT(m_turn_duration_penalties.size() > id); return m_turn_duration_penalties[id]; diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp index ed40533c8..dea7abd9d 100644 --- a/include/engine/datafacade/datafacade_base.hpp +++ b/include/engine/datafacade/datafacade_base.hpp @@ -10,9 +10,7 @@ #include "extractor/class_data.hpp" #include "extractor/edge_based_node_segment.hpp" -//#include "extractor/guidance/turn_lane_types.hpp" #include "extractor/maneuver_override.hpp" -//#include "extractor/original_edge_data.hpp" #include "extractor/query_node.hpp" #include "extractor/travel_mode.hpp" #include "extractor/turn_lane_types.hpp" @@ -31,6 +29,8 @@ #include "osrm/coordinate.hpp" +#include + #include #include @@ -50,6 +50,14 @@ class BaseDataFacade { public: using RTreeLeaf = extractor::EdgeBasedNodeSegment; + + template + using RangeT = boost::any_range; + using NodesIDRangeT = RangeT; + using WeightsRangeT = RangeT; + using DurationsRangeT = RangeT; + using DatasourceIDRangeT = RangeT; + BaseDataFacade() {} virtual ~BaseDataFacade() {} @@ -64,9 +72,8 @@ class BaseDataFacade virtual ComponentID GetComponentID(const NodeID id) const = 0; - virtual std::vector GetUncompressedForwardGeometry(const EdgeID id) const = 0; - - virtual std::vector GetUncompressedReverseGeometry(const EdgeID id) const = 0; + virtual NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID id) const = 0; + virtual NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID id) const = 0; virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const = 0; @@ -74,18 +81,18 @@ class BaseDataFacade // Gets the weight values for each segment in an uncompressed geometry. // Should always be 1 shorter than GetUncompressedGeometry - virtual std::vector GetUncompressedForwardWeights(const EdgeID id) const = 0; - virtual std::vector GetUncompressedReverseWeights(const EdgeID id) const = 0; + virtual WeightsRangeT GetUncompressedForwardWeights(const EdgeID id) const = 0; + virtual WeightsRangeT GetUncompressedReverseWeights(const EdgeID id) const = 0; // Gets the duration values for each segment in an uncompressed geometry. // Should always be 1 shorter than GetUncompressedGeometry - virtual std::vector GetUncompressedForwardDurations(const EdgeID id) const = 0; - virtual std::vector GetUncompressedReverseDurations(const EdgeID id) const = 0; + virtual DurationsRangeT GetUncompressedForwardDurations(const EdgeID id) const = 0; + virtual DurationsRangeT GetUncompressedReverseDurations(const EdgeID id) const = 0; // Returns the data source ids that were used to supply the edge // weights. Will return an empty array when only the base profile is used. - virtual std::vector GetUncompressedForwardDatasources(const EdgeID id) const = 0; - virtual std::vector GetUncompressedReverseDatasources(const EdgeID id) const = 0; + virtual DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID id) const = 0; + virtual DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID id) const = 0; // Gets the name of a datasource virtual StringView GetDatasourceName(const DatasourceID id) const = 0; diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp index d048268eb..b9a709d0c 100644 --- a/include/engine/geospatial_query.hpp +++ b/include/engine/geospatial_query.hpp @@ -434,11 +434,6 @@ template class GeospatialQuery // Find the node-based-edge that this belongs to, and directly // calculate the forward_weight, forward_offset, reverse_weight, reverse_offset - EdgeWeight forward_weight_offset = 0, forward_weight = 0; - EdgeWeight reverse_weight_offset = 0, reverse_weight = 0; - EdgeDuration forward_duration_offset = 0, forward_duration = 0; - EdgeDuration reverse_duration_offset = 0, reverse_duration = 0; - BOOST_ASSERT(data.forward_segment_id.enabled || data.reverse_segment_id.enabled); BOOST_ASSERT(!data.reverse_segment_id.enabled || datafacade.GetGeometryIndex(data.forward_segment_id.id).id == @@ -446,35 +441,42 @@ template class GeospatialQuery const auto geometry_id = datafacade.GetGeometryIndex(data.forward_segment_id.id).id; const auto component_id = datafacade.GetComponentID(data.forward_segment_id.id); - const std::vector forward_weight_vector = - datafacade.GetUncompressedForwardWeights(geometry_id); - const std::vector reverse_weight_vector = - datafacade.GetUncompressedReverseWeights(geometry_id); - const std::vector forward_duration_vector = - datafacade.GetUncompressedForwardDurations(geometry_id); - const std::vector reverse_duration_vector = - datafacade.GetUncompressedReverseDurations(geometry_id); + const auto forward_weights = datafacade.GetUncompressedForwardWeights(geometry_id); + const auto reverse_weights = datafacade.GetUncompressedReverseWeights(geometry_id); - for (std::size_t i = 0; i < data.fwd_segment_position; i++) - { - forward_weight_offset += forward_weight_vector[i]; - forward_duration_offset += forward_duration_vector[i]; - } - forward_weight = forward_weight_vector[data.fwd_segment_position]; - forward_duration = forward_duration_vector[data.fwd_segment_position]; + const auto forward_durations = datafacade.GetUncompressedForwardDurations(geometry_id); + const auto reverse_durations = datafacade.GetUncompressedReverseDurations(geometry_id); - BOOST_ASSERT(data.fwd_segment_position < reverse_weight_vector.size()); + const auto forward_weight_offset = + std::accumulate(forward_weights.begin(), + forward_weights.begin() + data.fwd_segment_position, + EdgeWeight{0}); - for (std::size_t i = 0; i < reverse_weight_vector.size() - data.fwd_segment_position - 1; - i++) - { - reverse_weight_offset += reverse_weight_vector[i]; - reverse_duration_offset += reverse_duration_vector[i]; - } - reverse_weight = - reverse_weight_vector[reverse_weight_vector.size() - data.fwd_segment_position - 1]; - reverse_duration = - reverse_duration_vector[reverse_duration_vector.size() - data.fwd_segment_position - 1]; + const auto forward_duration_offset = + std::accumulate(forward_durations.begin(), + forward_durations.begin() + data.fwd_segment_position, + EdgeDuration{0}); + + EdgeWeight forward_weight = forward_weights[data.fwd_segment_position]; + EdgeDuration forward_duration = forward_durations[data.fwd_segment_position]; + + BOOST_ASSERT(data.fwd_segment_position < + std::distance(forward_durations.begin(), forward_durations.end())); + + const auto reverse_weight_offset = + std::accumulate(reverse_weights.begin(), + reverse_weights.end() - data.fwd_segment_position - 1, + EdgeWeight{0}); + + const auto reverse_duration_offset = + std::accumulate(reverse_durations.begin(), + reverse_durations.end() - data.fwd_segment_position - 1, + EdgeDuration{0}); + + EdgeWeight reverse_weight = + reverse_weights[reverse_weights.size() - data.fwd_segment_position - 1]; + EdgeDuration reverse_duration = + reverse_durations[reverse_durations.size() - data.fwd_segment_position - 1]; ratio = std::min(1.0, std::max(0.0, ratio)); if (data.forward_segment_id.id != SPECIAL_SEGMENTID) @@ -493,14 +495,13 @@ template class GeospatialQuery return std::find(first, last, INVALID_SEGMENT_WEIGHT) == last; }; bool is_forward_valid_source = - areSegmentsValid(forward_weight_vector.begin(), forward_weight_vector.end()); - bool is_forward_valid_target = - areSegmentsValid(forward_weight_vector.begin(), - forward_weight_vector.begin() + data.fwd_segment_position + 1); + areSegmentsValid(forward_weights.begin(), forward_weights.end()); + bool is_forward_valid_target = areSegmentsValid( + forward_weights.begin(), forward_weights.begin() + data.fwd_segment_position + 1); bool is_reverse_valid_source = - areSegmentsValid(reverse_weight_vector.begin(), reverse_weight_vector.end()); + areSegmentsValid(reverse_weights.begin(), reverse_weights.end()); bool is_reverse_valid_target = areSegmentsValid( - reverse_weight_vector.begin(), reverse_weight_vector.end() - data.fwd_segment_position); + reverse_weights.begin(), reverse_weights.end() - data.fwd_segment_position); auto transformed = PhantomNodeWithDistance{ PhantomNode{data, @@ -605,17 +606,14 @@ template class GeospatialQuery BOOST_ASSERT(data.forward_segment_id.id != SPECIAL_NODEID); const auto geometry_id = datafacade.GetGeometryIndex(data.forward_segment_id.id).id; - const std::vector forward_weight_vector = - datafacade.GetUncompressedForwardWeights(geometry_id); - - if (forward_weight_vector[data.fwd_segment_position] != INVALID_SEGMENT_WEIGHT) + const auto forward_weights = datafacade.GetUncompressedForwardWeights(geometry_id); + if (forward_weights[data.fwd_segment_position] != INVALID_SEGMENT_WEIGHT) { forward_edge_valid = data.forward_segment_id.enabled; } - const std::vector reverse_weight_vector = - datafacade.GetUncompressedReverseWeights(geometry_id); - if (reverse_weight_vector[reverse_weight_vector.size() - data.fwd_segment_position - 1] != + const auto reverse_weights = datafacade.GetUncompressedReverseWeights(geometry_id); + if (reverse_weights[reverse_weights.size() - data.fwd_segment_position - 1] != INVALID_SEGMENT_WEIGHT) { reverse_edge_valid = data.reverse_segment_id.enabled; diff --git a/include/engine/guidance/assemble_geometry.hpp b/include/engine/guidance/assemble_geometry.hpp index d6e913dcb..c076e349f 100644 --- a/include/engine/guidance/assemble_geometry.hpp +++ b/include/engine/guidance/assemble_geometry.hpp @@ -55,7 +55,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade, const auto source_node_id = reversed_source ? source_node.reverse_segment_id.id : source_node.forward_segment_id.id; const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id; - std::vector source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id); + const auto source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id); geometry.osm_node_ids.push_back( facade.GetOSMNodeIDOfNode(source_geometry[source_segment_start_coordinate])); @@ -111,8 +111,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade, const auto target_node_id = reversed_target ? target_node.reverse_segment_id.id : target_node.forward_segment_id.id; const auto target_geometry_id = facade.GetGeometryIndex(target_node_id).id; - const std::vector forward_datasources = - facade.GetUncompressedForwardDatasources(target_geometry_id); + const auto forward_datasources = facade.GetUncompressedForwardDatasources(target_geometry_id); // This happens when the source/target are on the same edge-based-node // There will be no entries in the unpacked path, thus no annotations. @@ -158,8 +157,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade, // target node rev: 1 1 <- 2 <- 3 const auto target_segment_end_coordinate = target_node.fwd_segment_position + (reversed_target ? 0 : 1); - const std::vector target_geometry = - facade.GetUncompressedForwardGeometry(target_geometry_id); + const auto target_geometry = facade.GetUncompressedForwardGeometry(target_geometry_id); geometry.osm_node_ids.push_back( facade.GetOSMNodeIDOfNode(target_geometry[target_segment_end_coordinate])); diff --git a/include/engine/routing_algorithms/routing_base.hpp b/include/engine/routing_algorithms/routing_base.hpp index dbabbf4ae..139afd117 100644 --- a/include/engine/routing_algorithms/routing_base.hpp +++ b/include/engine/routing_algorithms/routing_base.hpp @@ -135,25 +135,25 @@ void annotatePath(const FacadeT &facade, phantom_node_pair.target_phantom.reverse_segment_id.id == target_node_id); // datastructures to hold extracted data from geometry - std::vector id_vector; - std::vector weight_vector; - std::vector duration_vector; - std::vector datasource_vector; + datafacade::ContiguousInternalMemoryDataFacadeBase::NodesIDRangeT id_range; + datafacade::ContiguousInternalMemoryDataFacadeBase::WeightsRangeT weight_range; + datafacade::ContiguousInternalMemoryDataFacadeBase::DurationsRangeT duration_range; + datafacade::ContiguousInternalMemoryDataFacadeBase::DatasourceIDRangeT datasource_range; const auto get_segment_geometry = [&](const auto geometry_index) { if (geometry_index.forward) { - id_vector = facade.GetUncompressedForwardGeometry(geometry_index.id); - weight_vector = facade.GetUncompressedForwardWeights(geometry_index.id); - duration_vector = facade.GetUncompressedForwardDurations(geometry_index.id); - datasource_vector = facade.GetUncompressedForwardDatasources(geometry_index.id); + id_range = facade.GetUncompressedForwardGeometry(geometry_index.id); + weight_range = facade.GetUncompressedForwardWeights(geometry_index.id); + duration_range = facade.GetUncompressedForwardDurations(geometry_index.id); + datasource_range = facade.GetUncompressedForwardDatasources(geometry_index.id); } else { - id_vector = facade.GetUncompressedReverseGeometry(geometry_index.id); - weight_vector = facade.GetUncompressedReverseWeights(geometry_index.id); - duration_vector = facade.GetUncompressedReverseDurations(geometry_index.id); - datasource_vector = facade.GetUncompressedReverseDatasources(geometry_index.id); + id_range = facade.GetUncompressedReverseGeometry(geometry_index.id); + weight_range = facade.GetUncompressedReverseWeights(geometry_index.id); + duration_range = facade.GetUncompressedReverseDurations(geometry_index.id); + datasource_range = facade.GetUncompressedReverseDatasources(geometry_index.id); } }; @@ -172,19 +172,19 @@ void annotatePath(const FacadeT &facade, const auto geometry_index = facade.GetGeometryIndex(node_id); get_segment_geometry(geometry_index); - BOOST_ASSERT(id_vector.size() > 0); - BOOST_ASSERT(datasource_vector.size() > 0); - BOOST_ASSERT(weight_vector.size() == id_vector.size() - 1); - BOOST_ASSERT(duration_vector.size() == id_vector.size() - 1); + BOOST_ASSERT(id_range.size() > 0); + BOOST_ASSERT(datasource_range.size() > 0); + BOOST_ASSERT(weight_range.size() + 1 == id_range.size()); + BOOST_ASSERT(duration_range.size() + 1 == id_range.size()); const bool is_first_segment = unpacked_path.empty(); const std::size_t start_index = (is_first_segment ? ((start_traversed_in_reverse) - ? weight_vector.size() - + ? weight_range.size() - phantom_node_pair.source_phantom.fwd_segment_position - 1 : phantom_node_pair.source_phantom.fwd_segment_position) : 0); - const std::size_t end_index = weight_vector.size(); + const std::size_t end_index = weight_range.size(); bool is_left_hand_driving = facade.IsLeftHandDriving(node_id); @@ -193,19 +193,19 @@ void annotatePath(const FacadeT &facade, for (std::size_t segment_idx = start_index; segment_idx < end_index; ++segment_idx) { unpacked_path.push_back(PathData{*node_from, - id_vector[segment_idx + 1], + id_range[segment_idx + 1], name_index, is_segregated, - weight_vector[segment_idx], + static_cast(weight_range[segment_idx]), 0, - duration_vector[segment_idx], + static_cast(duration_range[segment_idx]), 0, guidance::TurnInstruction::NO_TURN(), {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID}, travel_mode, classes, EMPTY_ENTRY_CLASS, - datasource_vector[segment_idx], + datasource_range[segment_idx], osrm::guidance::TurnBearing(0), osrm::guidance::TurnBearing(0), is_left_hand_driving}); @@ -239,10 +239,9 @@ void annotatePath(const FacadeT &facade, if (is_local_path) { start_index = - weight_vector.size() - phantom_node_pair.source_phantom.fwd_segment_position - 1; + weight_range.size() - phantom_node_pair.source_phantom.fwd_segment_position - 1; } - end_index = - weight_vector.size() - phantom_node_pair.target_phantom.fwd_segment_position - 1; + end_index = weight_range.size() - phantom_node_pair.target_phantom.fwd_segment_position - 1; } else { @@ -264,23 +263,23 @@ void annotatePath(const FacadeT &facade, for (std::size_t segment_idx = start_index; segment_idx != end_index; (start_index < end_index ? ++segment_idx : --segment_idx)) { - BOOST_ASSERT(segment_idx < id_vector.size() - 1); + BOOST_ASSERT(segment_idx < static_cast(id_range.size() - 1)); BOOST_ASSERT(facade.GetTravelMode(target_node_id) > 0); unpacked_path.push_back( PathData{target_node_id, - id_vector[start_index < end_index ? segment_idx + 1 : segment_idx - 1], + id_range[start_index < end_index ? segment_idx + 1 : segment_idx - 1], facade.GetNameIndex(target_node_id), facade.IsSegregated(target_node_id), - weight_vector[segment_idx], + static_cast(weight_range[segment_idx]), 0, - duration_vector[segment_idx], + static_cast(duration_range[segment_idx]), 0, guidance::TurnInstruction::NO_TURN(), {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID}, facade.GetTravelMode(target_node_id), facade.GetClassData(target_node_id), EMPTY_ENTRY_CLASS, - datasource_vector[segment_idx], + datasource_range[segment_idx], guidance::TurnBearing(0), guidance::TurnBearing(0), is_target_left_hand_driving}); diff --git a/include/extractor/segment_data_container.hpp b/include/extractor/segment_data_container.hpp index 7d3c4d9b2..7f4f06c51 100644 --- a/include/extractor/segment_data_container.hpp +++ b/include/extractor/segment_data_container.hpp @@ -56,7 +56,7 @@ template class SegmentDataContainerImpl using DirectionalGeometryID = std::uint32_t; using SegmentOffset = std::uint32_t; using SegmentWeightVector = PackedVector; - using SegmentDurationVector = PackedVector; + using SegmentDurationVector = PackedVector; using SegmentDatasourceVector = Vector; SegmentDataContainerImpl() = default; diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp index ede2ea3a9..9b8ecc82b 100644 --- a/include/util/typedefs.hpp +++ b/include/util/typedefs.hpp @@ -105,9 +105,9 @@ static const NameID INVALID_NAMEID = std::numeric_limits::max(); static const NameID EMPTY_NAMEID = 0; static const unsigned INVALID_COMPONENTID = 0; static const std::size_t SEGMENT_WEIGHT_BITS = 22; -static const std::size_t SEGMENT_DURAITON_BITS = 22; +static const std::size_t SEGMENT_DURATION_BITS = 22; static const SegmentWeight INVALID_SEGMENT_WEIGHT = (1u << SEGMENT_WEIGHT_BITS) - 1; -static const SegmentDuration INVALID_SEGMENT_DURATION = (1u << SEGMENT_DURAITON_BITS) - 1; +static const SegmentDuration INVALID_SEGMENT_DURATION = (1u << SEGMENT_DURATION_BITS) - 1; static const SegmentWeight MAX_SEGMENT_WEIGHT = INVALID_SEGMENT_WEIGHT - 1; static const SegmentDuration MAX_SEGMENT_DURATION = INVALID_SEGMENT_DURATION - 1; static const EdgeWeight INVALID_EDGE_WEIGHT = std::numeric_limits::max(); diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp index c544b3972..8418d62be 100644 --- a/src/engine/plugins/tile.cpp +++ b/src/engine/plugins/tile.cpp @@ -397,16 +397,14 @@ void encodeVectorTile(const DataFacadeBase &facade, const auto &edge = edges[edge_index]; const auto geometry_id = get_geometry_id(edge); - const auto forward_datasource_vector = - facade.GetUncompressedForwardDatasources(geometry_id); - const auto reverse_datasource_vector = - facade.GetUncompressedReverseDatasources(geometry_id); + const auto forward_datasource_range = facade.GetUncompressedForwardDatasources(geometry_id); + const auto reverse_datasource_range = facade.GetUncompressedReverseDatasources(geometry_id); - BOOST_ASSERT(edge.fwd_segment_position < forward_datasource_vector.size()); - const auto forward_datasource = forward_datasource_vector[edge.fwd_segment_position]; - BOOST_ASSERT(edge.fwd_segment_position < reverse_datasource_vector.size()); - const auto reverse_datasource = reverse_datasource_vector[reverse_datasource_vector.size() - - edge.fwd_segment_position - 1]; + BOOST_ASSERT(edge.fwd_segment_position < forward_datasource_range.size()); + const auto forward_datasource = forward_datasource_range[edge.fwd_segment_position]; + BOOST_ASSERT(edge.fwd_segment_position < reverse_datasource_range.size()); + const auto reverse_datasource = reverse_datasource_range[reverse_datasource_range.size() - + edge.fwd_segment_position - 1]; // Keep track of the highest datasource seen so that we don't write unnecessary // data to the layer attribute values @@ -453,13 +451,11 @@ void encodeVectorTile(const DataFacadeBase &facade, const double length = osrm::util::coordinate_calculation::haversineDistance(a, b); // Weight values - const auto forward_weight_vector = - facade.GetUncompressedForwardWeights(geometry_id); - const auto reverse_weight_vector = - facade.GetUncompressedReverseWeights(geometry_id); - const auto forward_weight = forward_weight_vector[edge.fwd_segment_position]; - const auto reverse_weight = reverse_weight_vector[reverse_weight_vector.size() - - edge.fwd_segment_position - 1]; + const auto forward_weight_range = facade.GetUncompressedForwardWeights(geometry_id); + const auto reverse_weight_range = facade.GetUncompressedReverseWeights(geometry_id); + const auto forward_weight = forward_weight_range[edge.fwd_segment_position]; + const auto reverse_weight = reverse_weight_range[reverse_weight_range.size() - + edge.fwd_segment_position - 1]; line_int_index.add(forward_weight); line_int_index.add(reverse_weight); @@ -472,14 +468,14 @@ void encodeVectorTile(const DataFacadeBase &facade, line_int_index.add(reverse_rate); // Duration values - const auto forward_duration_vector = + const auto forward_duration_range = facade.GetUncompressedForwardDurations(geometry_id); - const auto reverse_duration_vector = + const auto reverse_duration_range = facade.GetUncompressedReverseDurations(geometry_id); - const auto forward_duration = forward_duration_vector[edge.fwd_segment_position]; - const auto reverse_duration = - reverse_duration_vector[reverse_duration_vector.size() - - edge.fwd_segment_position - 1]; + const auto forward_duration = forward_duration_range[edge.fwd_segment_position]; + const auto reverse_duration = reverse_duration_range[reverse_duration_range.size() - + edge.fwd_segment_position - 1]; + line_int_index.add(forward_duration); line_int_index.add(reverse_duration); } @@ -500,32 +496,32 @@ void encodeVectorTile(const DataFacadeBase &facade, const double length = osrm::util::coordinate_calculation::haversineDistance(a, b); - const auto forward_weight_vector = + const auto forward_weight_range = facade.GetUncompressedForwardWeights(geometry_id); - const auto reverse_weight_vector = + const auto reverse_weight_range = facade.GetUncompressedReverseWeights(geometry_id); - const auto forward_duration_vector = + const auto forward_duration_range = facade.GetUncompressedForwardDurations(geometry_id); - const auto reverse_duration_vector = + const auto reverse_duration_range = facade.GetUncompressedReverseDurations(geometry_id); - const auto forward_datasource_vector = + const auto forward_datasource_range = facade.GetUncompressedForwardDatasources(geometry_id); - const auto reverse_datasource_vector = + const auto reverse_datasource_range = facade.GetUncompressedReverseDatasources(geometry_id); - const auto forward_weight = forward_weight_vector[edge.fwd_segment_position]; - const auto reverse_weight = - reverse_weight_vector[reverse_weight_vector.size() - - edge.fwd_segment_position - 1]; - const auto forward_duration = - forward_duration_vector[edge.fwd_segment_position]; + const auto forward_weight = forward_weight_range[edge.fwd_segment_position]; + const auto reverse_weight = reverse_weight_range[reverse_weight_range.size() - + edge.fwd_segment_position - 1]; + + const auto forward_duration = forward_duration_range[edge.fwd_segment_position]; const auto reverse_duration = - reverse_duration_vector[reverse_duration_vector.size() - - edge.fwd_segment_position - 1]; + reverse_duration_range[reverse_duration_range.size() - + edge.fwd_segment_position - 1]; + const auto forward_datasource_idx = - forward_datasource_vector[edge.fwd_segment_position]; + forward_datasource_range[edge.fwd_segment_position]; const auto reverse_datasource_idx = - reverse_datasource_vector[reverse_datasource_vector.size() - - edge.fwd_segment_position - 1]; + reverse_datasource_range[reverse_datasource_range.size() - + edge.fwd_segment_position - 1]; const auto component_id = facade.GetComponentID(edge.forward_segment_id.id); const auto name_id = facade.GetNameIndex(edge.forward_segment_id.id); @@ -929,7 +925,7 @@ void encodeVectorTile(const DataFacadeBase &facade, for (auto edgeNodeID : segregated_nodes) { auto const geomIndex = facade.GetGeometryIndex(edgeNodeID); - std::vector geometry; + DataFacadeBase::NodesIDRangeT geometry; if (geomIndex.forward) geometry = facade.GetUncompressedForwardGeometry(geomIndex.id); diff --git a/src/engine/routing_algorithms/tile_turns.cpp b/src/engine/routing_algorithms/tile_turns.cpp index 80939eb3e..dd204f85f 100644 --- a/src/engine/routing_algorithms/tile_turns.cpp +++ b/src/engine/routing_algorithms/tile_turns.cpp @@ -101,8 +101,8 @@ std::vector generateTurns(const datafacade &facade, // w // uv is the "approach" // vw is the "exit" - std::vector approach_weight_vector; - std::vector approach_duration_vector; + typename datafacade::BaseDataFacade::WeightsRangeT approach_weight_range; + typename datafacade::BaseDataFacade::DurationsRangeT approach_duration_range; // Look at every node in the directed graph we created for (const auto &startnode : sorted_startnodes) @@ -151,27 +151,26 @@ std::vector generateTurns(const datafacade &facade, if (edge_based_node_info.find(approachedge.edge_based_node_id) ->second.is_geometry_forward) { - approach_weight_vector = facade.GetUncompressedForwardWeights( + approach_weight_range = facade.GetUncompressedForwardWeights( edge_based_node_info.find(approachedge.edge_based_node_id) ->second.packed_geometry_id); - approach_duration_vector = facade.GetUncompressedForwardDurations( + approach_duration_range = facade.GetUncompressedForwardDurations( edge_based_node_info.find(approachedge.edge_based_node_id) ->second.packed_geometry_id); } else { - approach_weight_vector = facade.GetUncompressedReverseWeights( + approach_weight_range = facade.GetUncompressedReverseWeights( edge_based_node_info.find(approachedge.edge_based_node_id) ->second.packed_geometry_id); - approach_duration_vector = facade.GetUncompressedReverseDurations( + approach_duration_range = facade.GetUncompressedReverseDurations( edge_based_node_info.find(approachedge.edge_based_node_id) ->second.packed_geometry_id); } - const auto sum_node_weight = std::accumulate(approach_weight_vector.begin(), - approach_weight_vector.end(), - EdgeWeight{0}); - const auto sum_node_duration = std::accumulate(approach_duration_vector.begin(), - approach_duration_vector.end(), + const auto sum_node_weight = std::accumulate( + approach_weight_range.begin(), approach_weight_range.end(), EdgeWeight{0}); + const auto sum_node_duration = std::accumulate(approach_duration_range.begin(), + approach_duration_range.end(), EdgeWeight{0}); // The edge.weight is the whole edge weight, which includes the turn diff --git a/unit_tests/engine/offline_facade.cpp b/unit_tests/engine/offline_facade.cpp index a9ef03688..ea404de14 100644 --- a/unit_tests/engine/offline_facade.cpp +++ b/unit_tests/engine/offline_facade.cpp @@ -156,15 +156,9 @@ class ContiguousInternalMemoryDataFacade GeometryID GetGeometryIndex(const NodeID /*id*/) const override { return GeometryID{0, false}; } - std::vector GetUncompressedForwardGeometry(const EdgeID /*id*/) const override - { - return {}; - } + NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID /*id*/) const override { return {}; } - std::vector GetUncompressedReverseGeometry(const EdgeID /*id*/) const override - { - return {}; - } + NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID /*id*/) const override { return {}; } TurnPenalty GetWeightPenaltyForEdgeID(const unsigned /*id*/) const override { @@ -176,32 +170,26 @@ class ContiguousInternalMemoryDataFacade return INVALID_TURN_PENALTY; } - std::vector GetUncompressedForwardWeights(const EdgeID /*id*/) const override + WeightsRangeT GetUncompressedForwardWeights(const EdgeID /*id*/) const override { return {}; } + + WeightsRangeT GetUncompressedReverseWeights(const EdgeID /*id*/) const override { return {}; } + + DurationsRangeT GetUncompressedForwardDurations(const EdgeID /*geomID*/) const override { return {}; } - std::vector GetUncompressedReverseWeights(const EdgeID /*id*/) const override + DurationsRangeT GetUncompressedReverseDurations(const EdgeID /*geomID*/) const override { return {}; } - std::vector GetUncompressedForwardDurations(const EdgeID /*geomID*/) const override + DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID /*id*/) const override { return {}; } - std::vector GetUncompressedReverseDurations(const EdgeID /*geomID*/) const override - { - return {}; - } - - std::vector GetUncompressedForwardDatasources(const EdgeID /*id*/) const override - { - return {}; - } - - std::vector GetUncompressedReverseDatasources(const EdgeID /*id*/) const override + DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID /*id*/) const override { return {}; } @@ -438,4 +426,21 @@ BOOST_AUTO_TEST_CASE(shortest_path) BOOST_CHECK_EQUAL(route.shortest_path_weight, INVALID_EDGE_WEIGHT); } +BOOST_AUTO_TEST_CASE(facade_uncompressed_methods) +{ + using Algorithm = osrm::engine::routing_algorithms::offline::Algorithm; + + osrm::engine::SearchEngineData heaps; + osrm::engine::datafacade::ContiguousInternalMemoryDataFacade facade; + + BOOST_CHECK_EQUAL(facade.GetUncompressedForwardGeometry(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedReverseGeometry(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedForwardWeights(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedReverseWeights(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedForwardDurations(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedReverseDurations(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedForwardDatasources(0).size(), 0); + BOOST_CHECK_EQUAL(facade.GetUncompressedReverseDatasources(0).size(), 0); +} + BOOST_AUTO_TEST_SUITE_END() diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp index f618730af..23b9393ed 100644 --- a/unit_tests/mocks/mock_datafacade.hpp +++ b/unit_tests/mocks/mock_datafacade.hpp @@ -54,38 +54,39 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade { return 0; } - std::vector GetUncompressedForwardGeometry(const EdgeID /* id */) const override + NodesIDRangeT GetUncompressedForwardGeometry(const EdgeID /* id */) const override { return {}; } - std::vector GetUncompressedReverseGeometry(const EdgeID /* id */) const override + NodesIDRangeT GetUncompressedReverseGeometry(const EdgeID /* id */) const override { return {}; } - std::vector GetUncompressedForwardWeights(const EdgeID /* id */) const override + WeightsRangeT GetUncompressedForwardWeights(const EdgeID /* id */) const override { - std::vector result_weights; - result_weights.resize(1); - result_weights[0] = 1; + static const std::vector result_weights{1, 2, 3}; return result_weights; } - std::vector GetUncompressedReverseWeights(const EdgeID id) const override + WeightsRangeT GetUncompressedReverseWeights(const EdgeID id) const override { return GetUncompressedForwardWeights(id); } - std::vector GetUncompressedForwardDurations(const EdgeID id) const override + + DurationsRangeT GetUncompressedForwardDurations(const EdgeID /*id*/) const override { - return GetUncompressedForwardWeights(id); + static const std::vector data{1, 2, 3}; + return data; } - std::vector GetUncompressedReverseDurations(const EdgeID id) const override + DurationsRangeT GetUncompressedReverseDurations(const EdgeID /*id*/) const override { - return GetUncompressedForwardWeights(id); + static const std::vector data{1, 2, 3}; + return data; } - std::vector GetUncompressedForwardDatasources(const EdgeID /*id*/) const override + DatasourceIDRangeT GetUncompressedForwardDatasources(const EdgeID /*id*/) const override { return {}; } - std::vector GetUncompressedReverseDatasources(const EdgeID /*id*/) const override + DatasourceIDRangeT GetUncompressedReverseDatasources(const EdgeID /*id*/) const override { return {}; } diff --git a/unit_tests/util/packed_vector.cpp b/unit_tests/util/packed_vector.cpp index c3833c4d7..f75c4a616 100644 --- a/unit_tests/util/packed_vector.cpp +++ b/unit_tests/util/packed_vector.cpp @@ -1,7 +1,10 @@ #include "util/packed_vector.hpp" #include "util/typedefs.hpp" +#include "common/range_tools.hpp" + #include +#include #include #include #include @@ -203,4 +206,50 @@ BOOST_AUTO_TEST_CASE(packed_vector_33bit_continious) } } +BOOST_AUTO_TEST_CASE(packed_weights_container_with_type_erasure) +{ + using Vector = PackedVector; + using WeightsRangeT = boost::any_range; + + PackedVector vector(7); + + std::iota(vector.begin(), vector.end(), 0); + + auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6); + auto forward_any = WeightsRangeT(forward.begin(), forward.end()); + CHECK_EQUAL_RANGE(forward, 1, 2, 3, 4, 5); + CHECK_EQUAL_RANGE(forward_any, 1, 2, 3, 4, 5); + + auto reverse = boost::adaptors::reverse(forward); + auto reverse_any = WeightsRangeT(reverse); + CHECK_EQUAL_RANGE(reverse, 5, 4, 3, 2, 1); + CHECK_EQUAL_RANGE(reverse_any, 5, 4, 3, 2, 1); +} + +BOOST_AUTO_TEST_CASE(packed_weights_view_with_type_erasure) +{ + using View = PackedVectorView; + using PackedDataWord = std::uint64_t; // PackedVectorView<>::WordT + using WeightsRangeT = boost::any_range; + + PackedDataWord data[] = {0x200000400000, 0xc, 0}; + View view(vector_view(data, 3), 7); + + auto forward = boost::make_iterator_range(view.begin() + 1, view.begin() + 4); + auto forward_any = WeightsRangeT(forward.begin(), forward.end()); + CHECK_EQUAL_RANGE(forward, 1, 2, 3); + CHECK_EQUAL_RANGE(forward_any, 1, 2, 3); + + auto reverse = boost::adaptors::reverse(forward); + auto reverse_any = WeightsRangeT(reverse); + CHECK_EQUAL_RANGE(reverse, 3, 2, 1); + CHECK_EQUAL_RANGE(reverse_any, 3, 2, 1); +} + BOOST_AUTO_TEST_SUITE_END()