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

Port turn duration penalties to tar

Browse Source
This commit is contained in:
Patrick Niklaus 2018-03-19 15:57:57 +00:00
parent 73b3d37837
commit 990e411361
4 changed files with 111 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
include/extractor/files.hpp
View File

@ -269,7 +269,8 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
template <typename TurnLaneDataT> template <typename TurnLaneDataT>
inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data) inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
{ {
static_assert(std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value, static_assert(
std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
""); "");
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint; const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@ -283,7 +284,8 @@ template <typename TurnLaneDataT>
inline void writeTurnLaneData(const boost::filesystem::path &path, inline void writeTurnLaneData(const boost::filesystem::path &path,
const TurnLaneDataT &turn_lane_data) const TurnLaneDataT &turn_lane_data)
{ {
static_assert(std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value, static_assert(
std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
""); "");
const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint; const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -292,7 +294,6 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,
storage::serialization::write(writer, "/common/turn_lanes/data", turn_lane_data); storage::serialization::write(writer, "/common/turn_lanes/data", turn_lane_data);
} }
// reads .osrm.maneuver_overrides // reads .osrm.maneuver_overrides
template <typename StorageManeuverOverrideT, typename NodeSequencesT> template <typename StorageManeuverOverrideT, typename NodeSequencesT>
inline void readManeuverOverrides(const boost::filesystem::path &path, inline void readManeuverOverrides(const boost::filesystem::path &path,
@ -302,8 +303,10 @@ inline void readManeuverOverrides(const boost::filesystem::path &path,
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint; const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
storage::tar::FileReader reader{path, fingerprint}; storage::tar::FileReader reader{path, fingerprint};
storage::serialization::read(reader, "/common/maneuver_overrides/overrides", maneuver_overrides); storage::serialization::read(
storage::serialization::read(reader, "/common/maneuver_overrides/node_sequences", node_sequences); reader, "/common/maneuver_overrides/overrides", maneuver_overrides);
storage::serialization::read(
reader, "/common/maneuver_overrides/node_sequences", node_sequences);
} }
// writes .osrm.maneuver_overrides // writes .osrm.maneuver_overrides
@ -314,8 +317,52 @@ inline void writeManeuverOverrides(const boost::filesystem::path &path,
const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint; const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
storage::tar::FileWriter writer{path, fingerprint}; storage::tar::FileWriter writer{path, fingerprint};
storage::serialization::write(writer, "/common/maneuver_overrides/overrides", maneuver_overrides); storage::serialization::write(
storage::serialization::write(writer, "/common/maneuver_overrides/node_sequences", node_sequences); writer, "/common/maneuver_overrides/overrides", maneuver_overrides);
storage::serialization::write(
writer, "/common/maneuver_overrides/node_sequences", node_sequences);
}
// writes .osrm.turn_weight_penalties
template <typename TurnPenaltyT>
inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
const TurnPenaltyT &turn_penalty)
{
const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
storage::tar::FileWriter writer{path, fingerprint};
storage::serialization::write(writer, "/common/turn_penalty/weight", turn_penalty);
}
// read .osrm.turn_weight_penalties
template <typename TurnPenaltyT>
inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
{
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
storage::tar::FileReader reader{path, fingerprint};
storage::serialization::read(reader, "/common/turn_penalty/weight", turn_penalty);
}
// writes .osrm.turn_duration_penalties
template <typename TurnPenaltyT>
inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
const TurnPenaltyT &turn_penalty)
{
const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
storage::tar::FileWriter writer{path, fingerprint};
storage::serialization::write(writer, "/common/turn_penalty/duration", turn_penalty);
}
// read .osrm.turn_weight_penalties
template <typename TurnPenaltyT>
inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
{
const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
storage::tar::FileReader reader{path, fingerprint};
storage::serialization::read(reader, "/common/turn_penalty/duration", turn_penalty);
} }
} }
} }

13
src/extractor/edge_based_graph_factory.cpp
View File

@ -1138,17 +1138,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
// write weight penalties per turn // write weight penalties per turn
BOOST_ASSERT(turn_weight_penalties.size() == turn_duration_penalties.size()); BOOST_ASSERT(turn_weight_penalties.size() == turn_duration_penalties.size());
{ files::writeTurnWeightPenalty(turn_weight_penalties_filename, turn_weight_penalties);
storage::io::FileWriter writer(turn_weight_penalties_filename, files::writeTurnDurationPenalty(turn_duration_penalties_filename, turn_duration_penalties);
storage::io::FileWriter::GenerateFingerprint);
storage::serialization::write(writer, turn_weight_penalties);
}
{
storage::io::FileWriter writer(turn_duration_penalties_filename,
storage::io::FileWriter::GenerateFingerprint);
storage::serialization::write(writer, turn_duration_penalties);
}
util::Log() << "Generated " << m_edge_based_node_segments.size() << " edge based node segments"; util::Log() << "Generated " << m_edge_based_node_segments.size() << " edge based node segments";
util::Log() << "Node-based graph contains " << node_based_edge_counter << " edges"; util::Log() << "Node-based graph contains " << node_based_edge_counter << " edges";

58
src/storage/storage.cpp
View File

@ -250,7 +250,6 @@ void Storage::PopulateLayout(DataLayout &layout)
layout.SetBlock(DataLayout::NAME_CHAR_DATA, make_block<char>(name_file.GetSize())); layout.SetBlock(DataLayout::NAME_CHAR_DATA, make_block<char>(name_file.GetSize()));
} }
// Loading information for original edges // Loading information for original edges
{ {
io::FileReader edges_file(config.GetPath(".osrm.edges"), io::FileReader::VerifyFingerprint); io::FileReader edges_file(config.GetPath(".osrm.edges"), io::FileReader::VerifyFingerprint);
@ -289,24 +288,6 @@ void Storage::PopulateLayout(DataLayout &layout)
layout.SetBlock(DataLayout::TIMESTAMP, make_block<char>(timestamp_size)); layout.SetBlock(DataLayout::TIMESTAMP, make_block<char>(timestamp_size));
} }
// load turn weight penalties
{
io::FileReader turn_weight_penalties_file(config.GetPath(".osrm.turn_weight_penalties"),
io::FileReader::VerifyFingerprint);
const auto number_of_penalties = turn_weight_penalties_file.ReadElementCount64();
layout.SetBlock(DataLayout::TURN_WEIGHT_PENALTIES,
make_block<TurnPenalty>(number_of_penalties));
}
// load turn duration penalties
{
io::FileReader turn_duration_penalties_file(config.GetPath(".osrm.turn_duration_penalties"),
io::FileReader::VerifyFingerprint);
const auto number_of_penalties = turn_duration_penalties_file.ReadElementCount64();
layout.SetBlock(DataLayout::TURN_DURATION_PENALTIES,
make_block<TurnPenalty>(number_of_penalties));
}
std::unordered_map<std::string, DataLayout::BlockID> name_to_block_id = { std::unordered_map<std::string, DataLayout::BlockID> name_to_block_id = {
{"/mld/multilevelgraph/node_array", DataLayout::MLD_GRAPH_NODE_LIST}, {"/mld/multilevelgraph/node_array", DataLayout::MLD_GRAPH_NODE_LIST},
{"/mld/multilevelgraph/edge_array", DataLayout::MLD_GRAPH_EDGE_LIST}, {"/mld/multilevelgraph/edge_array", DataLayout::MLD_GRAPH_EDGE_LIST},
@ -349,8 +330,10 @@ void Storage::PopulateLayout(DataLayout &layout)
{"/ch/edge_filter/7", DataLayout::CH_EDGE_FILTER_7}, {"/ch/edge_filter/7", DataLayout::CH_EDGE_FILTER_7},
{"/common/intersection_bearings/bearing_values", DataLayout::BEARING_VALUES}, {"/common/intersection_bearings/bearing_values", DataLayout::BEARING_VALUES},
{"/common/intersection_bearings/node_to_class_id", DataLayout::BEARING_CLASSID}, {"/common/intersection_bearings/node_to_class_id", DataLayout::BEARING_CLASSID},
{"/common/intersection_bearings/class_id_to_ranges/block_offsets", DataLayout::BEARING_OFFSETS}, {"/common/intersection_bearings/class_id_to_ranges/block_offsets",
{"/common/intersection_bearings/class_id_to_ranges/diff_blocks", DataLayout::BEARING_BLOCKS}, DataLayout::BEARING_OFFSETS},
{"/common/intersection_bearings/class_id_to_ranges/diff_blocks",
DataLayout::BEARING_BLOCKS},
{"/common/entry_classes", DataLayout::ENTRY_CLASS}, {"/common/entry_classes", DataLayout::ENTRY_CLASS},
{"/common/properties", DataLayout::PROPERTIES}, {"/common/properties", DataLayout::PROPERTIES},
{"/common/coordinates", DataLayout::COORDINATE_LIST}, {"/common/coordinates", DataLayout::COORDINATE_LIST},
@ -371,6 +354,8 @@ void Storage::PopulateLayout(DataLayout &layout)
{"/common/turn_lanes/data", DataLayout::TURN_LANE_DATA}, {"/common/turn_lanes/data", DataLayout::TURN_LANE_DATA},
{"/common/maneuver_overrides/overrides", DataLayout::MANEUVER_OVERRIDES}, {"/common/maneuver_overrides/overrides", DataLayout::MANEUVER_OVERRIDES},
{"/common/maneuver_overrides/node_sequences", DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES}, {"/common/maneuver_overrides/node_sequences", DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES},
{"/common/turn_penalty/weight", DataLayout::TURN_WEIGHT_PENALTIES},
{"/common/turn_penalty/duration", DataLayout::TURN_DURATION_PENALTIES},
}; };
std::vector<NamedBlock> blocks; std::vector<NamedBlock> blocks;
@ -391,6 +376,8 @@ void Storage::PopulateLayout(DataLayout &layout)
{REQUIRED, config.GetPath(".osrm.tls")}, {REQUIRED, config.GetPath(".osrm.tls")},
{REQUIRED, config.GetPath(".osrm.tld")}, {REQUIRED, config.GetPath(".osrm.tld")},
{REQUIRED, config.GetPath(".osrm.maneuver_overrides")}, {REQUIRED, config.GetPath(".osrm.maneuver_overrides")},
{REQUIRED, config.GetPath(".osrm.turn_weight_penalties")},
{REQUIRED, config.GetPath(".osrm.turn_duration_penalties")},
}; };
for (const auto &file : tar_files) for (const auto &file : tar_files)
@ -403,7 +390,8 @@ void Storage::PopulateLayout(DataLayout &layout)
{ {
if (std::get<0>(file) == REQUIRED) if (std::get<0>(file) == REQUIRED)
{ {
throw util::exception("Could not find required filed: " + std::get<1>(file).string()); throw util::exception("Could not find required filed: " +
std::get<1>(file).string());
} }
} }
} }
@ -640,22 +628,24 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
// load turn weight penalties // load turn weight penalties
{ {
io::FileReader turn_weight_penalties_file(config.GetPath(".osrm.turn_weight_penalties"), auto turn_duration_penalties_ptr = layout.GetBlockPtr<TurnPenalty, true>(
io::FileReader::VerifyFingerprint); memory_ptr, storage::DataLayout::TURN_WEIGHT_PENALTIES);
const auto number_of_penalties = turn_weight_penalties_file.ReadElementCount64(); util::vector_view<TurnPenalty> turn_duration_penalties(
const auto turn_weight_penalties_ptr = turn_duration_penalties_ptr,
layout.GetBlockPtr<TurnPenalty, true>(memory_ptr, DataLayout::TURN_WEIGHT_PENALTIES); layout.GetBlockEntries(storage::DataLayout::TURN_WEIGHT_PENALTIES));
turn_weight_penalties_file.ReadInto(turn_weight_penalties_ptr, number_of_penalties); extractor::files::readTurnWeightPenalty(config.GetPath(".osrm.turn_weight_penalties"),
turn_duration_penalties);
} }
// load turn duration penalties // load turn duration penalties
{ {
io::FileReader turn_duration_penalties_file(config.GetPath(".osrm.turn_duration_penalties"), auto turn_duration_penalties_ptr = layout.GetBlockPtr<TurnPenalty, true>(
io::FileReader::VerifyFingerprint); memory_ptr, storage::DataLayout::TURN_DURATION_PENALTIES);
const auto number_of_penalties = turn_duration_penalties_file.ReadElementCount64(); util::vector_view<TurnPenalty> turn_duration_penalties(
const auto turn_duration_penalties_ptr = turn_duration_penalties_ptr,
layout.GetBlockPtr<TurnPenalty, true>(memory_ptr, DataLayout::TURN_DURATION_PENALTIES); layout.GetBlockEntries(storage::DataLayout::TURN_DURATION_PENALTIES));
turn_duration_penalties_file.ReadInto(turn_duration_penalties_ptr, number_of_penalties); extractor::files::readTurnDurationPenalty(config.GetPath(".osrm.turn_duration_penalties"),
turn_duration_penalties);
} }
// store timestamp // store timestamp

70
src/updater/updater.cpp
View File

@ -162,8 +162,10 @@ updateSegmentData(const UpdaterConfig &config,
// closure to convert SpeedSource value to weight and count fallbacks to durations // closure to convert SpeedSource value to weight and count fallbacks to durations
std::atomic<std::uint32_t> fallbacks_to_duration{0}; std::atomic<std::uint32_t> fallbacks_to_duration{0};
auto convertToWeight = [&profile_properties, &fallbacks_to_duration]( auto convertToWeight = [&profile_properties,
const SegmentWeight &existing_weight, const SpeedSource &value, double distance_in_meters) { &fallbacks_to_duration](const SegmentWeight &existing_weight,
const SpeedSource &value,
double distance_in_meters) {
double rate = std::numeric_limits<double>::quiet_NaN(); double rate = std::numeric_limits<double>::quiet_NaN();
@ -571,37 +573,24 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
std::vector<TurnPenalty> turn_duration_penalties; std::vector<TurnPenalty> turn_duration_penalties;
if (update_edge_weights || update_turn_penalties || update_conditional_turns) if (update_edge_weights || update_turn_penalties || update_conditional_turns)
{ {
const auto load_segment_data = [&] { tbb::parallel_invoke(
[&] {
extractor::files::readSegmentData(config.GetPath(".osrm.geometry"), segment_data); extractor::files::readSegmentData(config.GetPath(".osrm.geometry"), segment_data);
}; },
[&] { extractor::files::readNodeData(config.GetPath(".osrm.ebg_nodes"), node_data); },
const auto load_node_data = [&] { [&] {
extractor::files::readNodeData(config.GetPath(".osrm.ebg_nodes"), node_data); extractor::files::readTurnWeightPenalty(
}; config.GetPath(".osrm.turn_weight_penalties"), turn_weight_penalties);
},
const auto load_turn_weight_penalties = [&] { [&] {
using storage::io::FileReader; extractor::files::readTurnDurationPenalty(
FileReader reader(config.GetPath(".osrm.turn_weight_penalties"), config.GetPath(".osrm.turn_duration_penalties"), turn_duration_penalties);
FileReader::VerifyFingerprint); },
storage::serialization::read(reader, turn_weight_penalties); [&] {
}; extractor::files::readProfileProperties(config.GetPath(".osrm.properties"),
profile_properties);
const auto load_turn_duration_penalties = [&] { });
using storage::io::FileReader;
FileReader reader(config.GetPath(".osrm.turn_duration_penalties"),
FileReader::VerifyFingerprint);
storage::serialization::read(reader, turn_duration_penalties);
};
const auto load_profile_properties = [&] {
extractor::files::readProfileProperties(config.GetPath(".osrm.properties"), profile_properties);
};
tbb::parallel_invoke(load_node_data,
load_segment_data,
load_turn_weight_penalties,
load_turn_duration_penalties,
load_profile_properties);
} }
std::vector<extractor::ConditionalTurnPenalty> conditional_turns; std::vector<extractor::ConditionalTurnPenalty> conditional_turns;
@ -777,9 +766,9 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
{ {
if (turn_weight_penalty < 0) if (turn_weight_penalty < 0)
{ {
util::Log(logWARNING) << "turn penalty " << turn_weight_penalty util::Log(logWARNING)
<< " is too negative: clamping turn weight to " << "turn penalty " << turn_weight_penalty
<< weight_min_value; << " is too negative: clamping turn weight to " << weight_min_value;
turn_weight_penalty = weight_min_value - new_weight; turn_weight_penalty = weight_min_value - new_weight;
turn_weight_penalties[edge.data.turn_id] = turn_weight_penalty; turn_weight_penalties[edge.data.turn_id] = turn_weight_penalty;
} }
@ -808,19 +797,14 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
if (update_turn_penalties || update_conditional_turns) if (update_turn_penalties || update_conditional_turns)
{ {
const auto save_penalties = [](const auto &filename, const auto &data) -> void {
storage::io::FileWriter writer(filename, storage::io::FileWriter::GenerateFingerprint);
storage::serialization::write(writer, data);
};
tbb::parallel_invoke( tbb::parallel_invoke(
[&] { [&] {
save_penalties(config.GetPath(".osrm.turn_weight_penalties"), extractor::files::writeTurnWeightPenalty(
turn_weight_penalties); config.GetPath(".osrm.turn_weight_penalties"), turn_weight_penalties);
}, },
[&] { [&] {
save_penalties(config.GetPath(".osrm.turn_duration_penalties"), extractor::files::writeTurnDurationPenalty(
turn_duration_penalties); config.GetPath(".osrm.turn_duration_penalties"), turn_duration_penalties);
}); });
} }