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

Store node ID's and weights separately in CompressedEdgeContainer

Browse Source 
Removes CompressedEdges from the extractor and shared data format by
directly serializing vectors of node ID's, forward weights and reverse
weights for each node-based-edge

Refs #2575
This commit is contained in:
jakepruitt
2016-10-06 21:06:33 -07:00
committed by Jake Pruitt
parent ecee13bffa
commit 42271d99b2
7 changed files with 224 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/extractor/compressed_edge_container.cpp
+36 -42
View File
@@ -61,7 +61,7 @@ unsigned CompressedEdgeContainer::GetZippedPositionForForwardID(const EdgeID edg
{
auto map_iterator = m_forward_edge_id_to_zipped_index_map.find(edge_id);
BOOST_ASSERT(map_iterator != m_forward_edge_id_to_zipped_index_map.end());
BOOST_ASSERT(map_iterator->second < m_compressed_geometries.size());
BOOST_ASSERT(map_iterator->second < m_compressed_geometry_nodes.size());
return map_iterator->second;
}
@@ -69,48 +69,34 @@ unsigned CompressedEdgeContainer::GetZippedPositionForReverseID(const EdgeID edg
{
auto map_iterator = m_reverse_edge_id_to_zipped_index_map.find(edge_id);
BOOST_ASSERT(map_iterator != m_reverse_edge_id_to_zipped_index_map.end());
BOOST_ASSERT(map_iterator->second < m_compressed_geometries.size());
BOOST_ASSERT(map_iterator->second < m_compressed_geometry_nodes.size());
return map_iterator->second;
}
void CompressedEdgeContainer::SerializeInternalVector(const std::string &path) const
{
boost::filesystem::fstream geometry_out_stream(path, std::ios::binary | std::ios::out);
const unsigned compressed_geometries = m_compressed_geometries.size() + 1;
BOOST_ASSERT(std::numeric_limits<unsigned>::max() != compressed_geometries);
geometry_out_stream.write((char *)&compressed_geometries, sizeof(unsigned));
const unsigned compressed_geometry_indices = m_compressed_geometry_index.size() + 1;
const unsigned compressed_geometries = m_compressed_geometry_nodes.size();
BOOST_ASSERT(std::numeric_limits<unsigned>::max() != compressed_geometry_indices);
geometry_out_stream.write((char *)&compressed_geometry_indices, sizeof(unsigned));
// write indices array
unsigned prefix_sum_of_list_indices = 0;
for (const auto &elem : m_compressed_geometries)
{
geometry_out_stream.write((char *)&prefix_sum_of_list_indices, sizeof(unsigned));
geometry_out_stream.write((char *)(m_compressed_geometry_index.data()), sizeof(unsigned) * m_compressed_geometry_index.size());
const std::vector<CompressedEdge> &current_vector = elem;
const unsigned unpacked_size = current_vector.size();
BOOST_ASSERT(std::numeric_limits<unsigned>::max() != unpacked_size);
prefix_sum_of_list_indices += unpacked_size;
}
// sentinel element
geometry_out_stream.write((char *)&prefix_sum_of_list_indices, sizeof(unsigned));
geometry_out_stream.write((char *)&(compressed_geometries), sizeof(unsigned));
// number of geometry entries to follow, it is the (inclusive) prefix sum
geometry_out_stream.write((char *)&prefix_sum_of_list_indices, sizeof(unsigned));
// number of geometry entries to follow
geometry_out_stream.write((char *)&(compressed_geometries), sizeof(unsigned));
unsigned control_sum = 0;
// write compressed geometries
for (auto &elem : m_compressed_geometries)
{
const std::vector<CompressedEdge> &current_vector = elem;
const unsigned unpacked_size = current_vector.size();
control_sum += unpacked_size;
BOOST_ASSERT(std::numeric_limits<unsigned>::max() != unpacked_size);
for (const auto &current_node : current_vector)
{
geometry_out_stream.write((char *)&(current_node), sizeof(CompressedEdge));
}
}
BOOST_ASSERT(control_sum == prefix_sum_of_list_indices);
// write compressed geometry node id's
geometry_out_stream.write((char *)(m_compressed_geometry_nodes.data()), sizeof(NodeID) * m_compressed_geometry_nodes.size());
// write compressed geometry forward weights
geometry_out_stream.write((char *)(m_compressed_geometry_fwd_weights.data()), sizeof(EdgeWeight) * m_compressed_geometry_fwd_weights.size());
// write compressed geometry reverse weights
geometry_out_stream.write((char *)(m_compressed_geometry_rev_weights.data()), sizeof(EdgeWeight) * m_compressed_geometry_rev_weights.size());
}
// Adds info for a compressed edge to the container. edge_id_2
@@ -250,7 +236,10 @@ void CompressedEdgeContainer::AddUncompressedEdge(const EdgeID edge_id,
void CompressedEdgeContainer::InitializeBothwayVector()
{
m_compressed_geometries.reserve(m_compressed_oneway_geometries.size() / 2);
m_compressed_geometry_index.reserve(m_compressed_oneway_geometries.size());
m_compressed_geometry_nodes.reserve(m_compressed_oneway_geometries.size());
m_compressed_geometry_fwd_weights.reserve(m_compressed_oneway_geometries.size());
m_compressed_geometry_rev_weights.reserve(m_compressed_oneway_geometries.size());
}
unsigned CompressedEdgeContainer::ZipEdges(const EdgeID f_edge_id, const EdgeID r_edge_id)
@@ -260,14 +249,17 @@ unsigned CompressedEdgeContainer::ZipEdges(const EdgeID f_edge_id, const EdgeID
BOOST_ASSERT(forward_bucket.size() == reverse_bucket.size());
const unsigned zipped_geometry_id = m_compressed_geometries.size();
const unsigned zipped_geometry_id = m_compressed_geometry_index.size();
m_forward_edge_id_to_zipped_index_map[f_edge_id] = zipped_geometry_id;
m_reverse_edge_id_to_zipped_index_map[r_edge_id] = zipped_geometry_id;
std::vector<CompressedEdge> zipped_edge_bucket;
m_compressed_geometry_index.emplace_back(m_compressed_geometry_nodes.size());
const auto &first_node = reverse_bucket.back();
zipped_edge_bucket.emplace_back(
CompressedEdge{first_node.node_id, INVALID_EDGE_WEIGHT, first_node.weight});
m_compressed_geometry_nodes.emplace_back(first_node.node_id);
m_compressed_geometry_fwd_weights.emplace_back(INVALID_EDGE_WEIGHT);
m_compressed_geometry_rev_weights.emplace_back(first_node.weight);
for (std::size_t i = 0; i < forward_bucket.size() - 1; ++i)
{
@@ -276,14 +268,16 @@ unsigned CompressedEdgeContainer::ZipEdges(const EdgeID f_edge_id, const EdgeID
BOOST_ASSERT(fwd_node.node_id == rev_node.node_id);
zipped_edge_bucket.emplace_back(
CompressedEdge{fwd_node.node_id, fwd_node.weight, rev_node.weight});
m_compressed_geometry_nodes.emplace_back(fwd_node.node_id);
m_compressed_geometry_fwd_weights.emplace_back(fwd_node.weight);
m_compressed_geometry_rev_weights.emplace_back(rev_node.weight);
}
const auto &last_node = forward_bucket.back();
zipped_edge_bucket.emplace_back(
CompressedEdge{last_node.node_id, last_node.weight, INVALID_EDGE_WEIGHT});
m_compressed_geometries.emplace_back(std::move(zipped_edge_bucket));
m_compressed_geometry_nodes.emplace_back(last_node.node_id);
m_compressed_geometry_fwd_weights.emplace_back(last_node.weight);
m_compressed_geometry_rev_weights.emplace_back(INVALID_EDGE_WEIGHT);
return zipped_geometry_id;
}