diff --git a/include/contractor/files.hpp b/include/contractor/files.hpp index b342c0fdf..7d3c2f7d8 100644 --- a/include/contractor/files.hpp +++ b/include/contractor/files.hpp @@ -5,7 +5,7 @@ #include "util/serialization.hpp" -#include "storage/io.hpp" +#include "storage/tar.hpp" #include "storage/serialization.hpp" namespace osrm @@ -29,18 +29,20 @@ inline void readGraph(const boost::filesystem::path &path, std::is_same>::value, "edge_filter must be a container of vector or vector_view"); - const auto fingerprint = storage::io::FileReader::VerifyFingerprint; - storage::io::FileReader reader{path, fingerprint}; + const auto fingerprint = storage::tar::FileReader::VerifyFingerprint; + storage::tar::FileReader reader{path, fingerprint}; - reader.ReadInto(checksum); - util::serialization::read(reader, graph); - auto count = reader.ReadElementCount64(); + checksum = reader.ReadOne("/ch/checksum"); + util::serialization::read(reader, "/ch/contracted_graph", graph); + + auto count = reader.ReadElementCount64("/ch/edge_filter"); edge_filter.resize(count); for (const auto index : util::irange(0, count)) { - storage::serialization::read(reader, edge_filter[index]); + storage::serialization::read(reader, "/ch/edge_filter/" + std::to_string(index), edge_filter[index]); } - reader.ReadInto(connectivity_checksum); + + connectivity_checksum = reader.ReadOne("/ch/connectivity_checksum"); } // writes .osrm.hsgr file @@ -57,17 +59,22 @@ inline void writeGraph(const boost::filesystem::path &path, static_assert(std::is_same>::value || std::is_same>::value, "edge_filter must be a container of vector or vector_view"); - const auto fingerprint = storage::io::FileWriter::GenerateFingerprint; - storage::io::FileWriter writer{path, fingerprint}; + const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint; + storage::tar::FileWriter writer{path, fingerprint}; - writer.WriteOne(checksum); - util::serialization::write(writer, graph); - writer.WriteElementCount64(edge_filter.size()); + writer.WriteElementCount64("/ch/checksum", 1); + writer.WriteOne("/ch/checksum", checksum); + util::serialization::write(writer, "/ch/contracted_graph", graph); + + writer.WriteElementCount64("/ch/edge_filter", edge_filter.size()); + auto id = 0; for (const auto &filter : edge_filter) { - storage::serialization::write(writer, filter); + storage::serialization::write(writer, "/ch/edge_filter/" + std::to_string(id++), filter); } - writer.WriteOne(connectivity_checksum); + + writer.WriteElementCount64("/ch/connectivity_checksum", 1); + writer.WriteOne("/ch/connectivity_checksum", connectivity_checksum); } } } diff --git a/include/storage/serialization.hpp b/include/storage/serialization.hpp index e542e4559..c8563b4a3 100644 --- a/include/storage/serialization.hpp +++ b/include/storage/serialization.hpp @@ -8,6 +8,9 @@ #include "storage/io.hpp" #include "storage/tar.hpp" +#include +#include + #include #include @@ -87,28 +90,32 @@ inline void write(storage::io::FileWriter &writer, const stxxl::vector &vec) } #endif -template void read(tar::FileReader &reader, const std::string& name, std::vector &data) +template +void read(tar::FileReader &reader, const std::string &name, std::vector &data) { const auto count = reader.ReadElementCount64(name); data.resize(count); reader.ReadInto(name, data.data(), count); } -template void write(tar::FileWriter &writer, const std::string& name, const std::vector &data) +template +void write(tar::FileWriter &writer, const std::string &name, const std::vector &data) { const auto count = data.size(); writer.WriteElementCount64(name, count); writer.WriteFrom(name, data.data(), count); } -template void read(tar::FileReader &reader, const std::string& name, util::vector_view &data) +template +void read(tar::FileReader &reader, const std::string &name, util::vector_view &data) { const auto count = reader.ReadElementCount64(name); BOOST_ASSERT(data.size() == count); reader.ReadInto(name, data.data(), count); } -template void write(tar::FileWriter &writer, const std::string& name, const util::vector_view &data) +template +void write(tar::FileWriter &writer, const std::string &name, const util::vector_view &data) { const auto count = data.size(); writer.WriteElementCount64(name, count); @@ -143,6 +150,8 @@ template void write(io::FileWriter &writer, const util::vector_view writer.WriteFrom(data.data(), count); } +namespace detail +{ template inline unsigned char packBits(const T &data, std::size_t index, std::size_t count) { @@ -162,7 +171,7 @@ inline void unpackBits(T &data, std::size_t index, std::size_t count, unsigned c data[index] = value & mask; } -template <> inline void read(io::FileReader &reader, util::vector_view &data) +template void readBoolVector(io::FileReader &reader, VectorT &data) { const auto count = reader.ReadElementCount64(); BOOST_ASSERT(data.size() == count); @@ -175,7 +184,7 @@ template <> inline void read(io::FileReader &reader, util::vector_view()); } -template <> inline void write(io::FileWriter &writer, const util::vector_view &data) +template void writeBoolVector(io::FileWriter &writer, const VectorT &data) { const auto count = data.size(); writer.WriteElementCount64(count); @@ -188,30 +197,87 @@ template <> inline void write(io::FileWriter &writer, const util::vector_v writer.WriteOne(packBits(data, index, count - index)); } +template +void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &data) +{ + const auto count = reader.ReadElementCount64(name); + BOOST_ASSERT(data.size() == count); + std::uint64_t index = 0; + + const auto decode = [&data, &index, count](const char block) { + auto read_size = std::min(count - index, CHAR_BIT); + unpackBits(data, index, read_size, block); + index += CHAR_BIT; + }; + + reader.ReadStreaming(name, boost::make_function_output_iterator(decode)); +} + +template +void writeBoolVector(tar::FileWriter &writer, const std::string &name, const VectorT &data) +{ + const auto count = data.size(); + writer.WriteElementCount64(name, count); + std::uint64_t index = 0; + + const auto encode = [&]() { + auto write_size = std::min(count - index, CHAR_BIT); + auto packed = packBits(data, CHAR_BIT * index, write_size); + index += CHAR_BIT; + return packed; + }; + + std::uint64_t number_of_blocks = std::ceil(count / CHAR_BIT); + writer.WriteStreaming( + name, boost::make_function_input_iterator(encode, boost::infinite()), number_of_blocks); +} +} + +template <> inline void read(io::FileReader &reader, util::vector_view &data) +{ + detail::readBoolVector(reader, data); +} + +template <> inline void write(io::FileWriter &writer, const util::vector_view &data) +{ + detail::writeBoolVector(writer, data); +} + template <> inline void read(io::FileReader &reader, std::vector &data) { - const auto count = reader.ReadElementCount64(); - data.resize(count); - std::uint64_t index = 0; - for (std::uint64_t next = CHAR_BIT; next < count; index = next, next += CHAR_BIT) - { - unpackBits(data, index, CHAR_BIT, reader.ReadOne()); - } - if (count > index) - unpackBits(data, index, count - index, reader.ReadOne()); + detail::readBoolVector(reader, data); } template <> inline void write(io::FileWriter &writer, const std::vector &data) { - const auto count = data.size(); - writer.WriteElementCount64(count); - std::uint64_t index = 0; - for (std::uint64_t next = CHAR_BIT; next < count; index = next, next += CHAR_BIT) - { - writer.WriteOne(packBits(data, index, CHAR_BIT)); - } - if (count > index) - writer.WriteOne(packBits(data, index, count - index)); + detail::writeBoolVector(writer, data); +} + +template <> +inline void +read(tar::FileReader &reader, const std::string &name, util::vector_view &data) +{ + detail::readBoolVector(reader, name, data); +} + +template <> +inline void +write(tar::FileWriter &writer, const std::string &name, const util::vector_view &data) +{ + detail::writeBoolVector(writer, name, data); +} + +template <> +inline void read(tar::FileReader &reader, const std::string &name, std::vector &data) +{ + detail::readBoolVector(reader, name, data); +} + +template <> +inline void +write(tar::FileWriter &writer, const std::string &name, const std::vector &data) +{ + detail::writeBoolVector(writer, name, data); } } } diff --git a/include/storage/tar.hpp b/include/storage/tar.hpp index 3b5f58041..37069241d 100644 --- a/include/storage/tar.hpp +++ b/include/storage/tar.hpp @@ -4,6 +4,7 @@ #include "util/exception.hpp" #include "util/exception_utils.hpp" #include "util/fingerprint.hpp" +#include "util/integer_range.hpp" #include "util/version.hpp" #include @@ -56,6 +57,36 @@ class FileReader return tmp; } + template void ReadStreaming(const std::string &name, OutIter out) + { + mtar_header_t header; + auto ret = mtar_find(&handle, name.c_str(), &header); + if (ret != MTAR_ESUCCESS) + { + throw util::exception(name + ": " + mtar_strerror(ret)); + } + + auto number_of_elements = header.size / sizeof(T); + auto expected_size = sizeof(T) * number_of_elements; + if (header.size != expected_size) + { + throw util::exception(name + ": Datatype size does not match file size."); + } + + T tmp; + for (auto index : util::irange(0, number_of_elements)) + { + (void) index; + ret = mtar_read_data(&handle, reinterpret_cast(&tmp), sizeof(T)); + if (ret != MTAR_ESUCCESS) + { + throw util::exception(name + ": Failed reading data: " + mtar_strerror(ret)); + } + + *out++ = tmp; + } + } + template void ReadInto(const std::string &name, T *data, const std::size_t number_of_elements) { @@ -160,6 +191,29 @@ class FileWriter WriteFrom(name, &data, 1); } + template + void WriteStreaming(const std::string &name, Iter iter, const std::uint64_t number_of_elements) + { + auto number_of_bytes = number_of_elements * sizeof(T); + + auto ret = mtar_write_file_header(&handle, name.c_str(), number_of_bytes); + if (ret != MTAR_ESUCCESS) + { + throw util::exception(name + ": Error writing header: " + mtar_strerror(ret)); + } + + for (auto index : util::irange(0, number_of_elements)) + { + (void) index; + T tmp = *iter++; + ret = mtar_write_data(&handle, &tmp, sizeof(T)); + if (ret != MTAR_ESUCCESS) + { + throw util::exception(name + ": Error writing data : " + mtar_strerror(ret)); + } + } + } + template void WriteFrom(const std::string &name, const T *data, const std::size_t number_of_elements) { @@ -168,13 +222,13 @@ class FileWriter auto ret = mtar_write_file_header(&handle, name.c_str(), number_of_bytes); if (ret != MTAR_ESUCCESS) { - throw util::exception(name + ": Error reading header: " + mtar_strerror(ret)); + throw util::exception(name + ": Error writing header: " + mtar_strerror(ret)); } ret = mtar_write_data(&handle, reinterpret_cast(data), number_of_bytes); if (ret != MTAR_ESUCCESS) { - throw util::exception(name + ": Error reading data : " + mtar_strerror(ret)); + throw util::exception(name + ": Error writing data : " + mtar_strerror(ret)); } } diff --git a/include/util/serialization.hpp b/include/util/serialization.hpp index ebece1a43..ccb9e7f69 100644 --- a/include/util/serialization.hpp +++ b/include/util/serialization.hpp @@ -86,6 +86,50 @@ inline void write(storage::io::FileWriter &writer, const DynamicGraph writer.WriteOne(graph.edge_list[index]); } } + +template +inline void read(storage::tar::FileReader &reader, + const std::string &name, + StaticGraph &graph) +{ + storage::serialization::read(reader, name + "/node_array", graph.node_array); + storage::serialization::read(reader, name + "/edge_array", graph.edge_array); + graph.number_of_nodes = graph.node_array.size() - 1; + graph.number_of_edges = graph.edge_array.size(); +} + +template +inline void write(storage::tar::FileWriter &writer, + const std::string &name, + const StaticGraph &graph) +{ + storage::serialization::write(writer, name + "/node_array", graph.node_array); + storage::serialization::write(writer, name + "/edge_array", graph.edge_array); +} + +template +inline void +read(storage::tar::FileReader &reader, const std::string &name, DynamicGraph &graph) +{ + storage::serialization::read(reader, name + "/node_array", graph.node_array); + const auto num_edges = reader.ReadElementCount64(name + "/edge_list"); + graph.edge_list.resize(num_edges); + reader.ReadStreaming::Edge>( + name + "/edge_list", graph.edge_list.begin()); + graph.number_of_nodes = graph.node_array.size(); + graph.number_of_edges = num_edges; +} + +template +inline void write(storage::tar::FileWriter &writer, + const std::string &name, + const DynamicGraph &graph) +{ + storage::serialization::write(writer, name + "/node_array", graph.node_array); + writer.WriteElementCount64(name + "/edge_list", graph.number_of_edges); + writer.WriteStreaming::Edge>( + name + "/edge_list", graph.edge_list.begin(), graph.number_of_edges); +} } } } diff --git a/include/util/static_graph.hpp b/include/util/static_graph.hpp index 0f1a744a5..958fdc66f 100644 --- a/include/util/static_graph.hpp +++ b/include/util/static_graph.hpp @@ -10,6 +10,7 @@ #include "storage/io_fwd.hpp" #include "storage/shared_memory_ownership.hpp" +#include "storage/tar_fwd.hpp" #include @@ -32,6 +33,16 @@ void read(storage::io::FileReader &reader, StaticGraph &gr template void write(storage::io::FileWriter &writer, const StaticGraph &graph); + +template +void read(storage::tar::FileReader &reader, + const std::string &name, + StaticGraph &graph); + +template +void write(storage::tar::FileWriter &writer, + const std::string &name, + const StaticGraph &graph); } namespace static_graph_details @@ -278,6 +289,14 @@ class StaticGraph serialization::write(storage::io::FileWriter &writer, const StaticGraph &graph); + friend void serialization::read(storage::tar::FileReader &reader, + const std::string &name, + StaticGraph &graph); + friend void + serialization::write(storage::tar::FileWriter &writer, + const std::string &name, + const StaticGraph &graph); + protected: template void InitializeFromSortedEdgeRange(const std::uint32_t nodes, IterT begin, IterT end) diff --git a/src/storage/storage.cpp b/src/storage/storage.cpp index 9ccab9caa..109388f7d 100644 --- a/src/storage/storage.cpp +++ b/src/storage/storage.cpp @@ -289,52 +289,6 @@ void Storage::PopulateLayout(DataLayout &layout) make_block(annotations_number)); } - if (boost::filesystem::exists(config.GetPath(".osrm.hsgr"))) - { - io::FileReader reader(config.GetPath(".osrm.hsgr"), io::FileReader::VerifyFingerprint); - - reader.Skip(1); // checksum - auto num_nodes = reader.ReadVectorSize(); - auto num_edges = reader.ReadVectorSize(); - auto num_metrics = reader.ReadElementCount64(); - - if (num_metrics > NUM_METRICS) - { - throw util::exception("Only " + std::to_string(NUM_METRICS) + - " metrics are supported at the same time."); - } - - layout.SetBlock(DataLayout::HSGR_CHECKSUM, make_block(1)); - layout.SetBlock(DataLayout::CH_GRAPH_NODE_LIST, - make_block(num_nodes)); - layout.SetBlock(DataLayout::CH_GRAPH_EDGE_LIST, - make_block(num_edges)); - - for (const auto index : util::irange(0, num_metrics)) - { - layout.SetBlock(static_cast(DataLayout::CH_EDGE_FILTER_0 + index), - make_block(num_edges)); - } - for (const auto index : util::irange(num_metrics, NUM_METRICS)) - { - layout.SetBlock(static_cast(DataLayout::CH_EDGE_FILTER_0 + index), - make_block(0)); - } - } - else - { - layout.SetBlock(DataLayout::HSGR_CHECKSUM, make_block(0)); - layout.SetBlock(DataLayout::CH_GRAPH_NODE_LIST, - make_block(0)); - layout.SetBlock(DataLayout::CH_GRAPH_EDGE_LIST, - make_block(0)); - for (const auto index : util::irange(0, NUM_METRICS)) - { - layout.SetBlock(static_cast(DataLayout::CH_EDGE_FILTER_0 + index), - make_block(0)); - } - } - // load rsearch tree size { io::FileReader tree_node_file(config.GetPath(".osrm.ramIndex"), @@ -493,61 +447,83 @@ void Storage::PopulateLayout(DataLayout &layout) make_block(number_of_nodes)); } + std::unordered_map name_to_block_id = { + {"/mld/multilevelgraph/node_array", DataLayout::MLD_GRAPH_NODE_LIST}, + {"/mld/multilevelgraph/edge_array", DataLayout::MLD_GRAPH_EDGE_LIST}, + {"/mld/multilevelgraph/node_to_edge_offset", DataLayout::MLD_GRAPH_NODE_TO_OFFSET}, + {"/mld/multilevelgraph/connectivity_checksum", DataLayout::IGNORE_BLOCK}, + {"/mld/multilevelpartition/level_data", DataLayout::MLD_LEVEL_DATA}, + {"/mld/multilevelpartition/partition", DataLayout::MLD_PARTITION}, + {"/mld/multilevelpartition/cell_to_children", DataLayout::MLD_CELL_TO_CHILDREN}, + {"/mld/cellstorage/source_boundary", DataLayout::MLD_CELL_SOURCE_BOUNDARY}, + {"/mld/cellstorage/destination_boundary", DataLayout::MLD_CELL_DESTINATION_BOUNDARY}, + {"/mld/cellstorage/cells", DataLayout::MLD_CELLS}, + {"/mld/cellstorage/level_to_cell_offset", DataLayout::MLD_CELL_LEVEL_OFFSETS}, + {"/mld/metrics/0/weights", DataLayout::MLD_CELL_WEIGHTS_0}, + {"/mld/metrics/1/weights", DataLayout::MLD_CELL_WEIGHTS_1}, + {"/mld/metrics/2/weights", DataLayout::MLD_CELL_WEIGHTS_2}, + {"/mld/metrics/3/weights", DataLayout::MLD_CELL_WEIGHTS_3}, + {"/mld/metrics/4/weights", DataLayout::MLD_CELL_WEIGHTS_4}, + {"/mld/metrics/5/weights", DataLayout::MLD_CELL_WEIGHTS_5}, + {"/mld/metrics/6/weights", DataLayout::MLD_CELL_WEIGHTS_6}, + {"/mld/metrics/7/weights", DataLayout::MLD_CELL_WEIGHTS_7}, + {"/mld/metrics/0/durations", DataLayout::MLD_CELL_DURATIONS_0}, + {"/mld/metrics/1/durations", DataLayout::MLD_CELL_DURATIONS_1}, + {"/mld/metrics/2/durations", DataLayout::MLD_CELL_DURATIONS_2}, + {"/mld/metrics/3/durations", DataLayout::MLD_CELL_DURATIONS_3}, + {"/mld/metrics/4/durations", DataLayout::MLD_CELL_DURATIONS_4}, + {"/mld/metrics/5/durations", DataLayout::MLD_CELL_DURATIONS_5}, + {"/mld/metrics/6/durations", DataLayout::MLD_CELL_DURATIONS_6}, + {"/mld/metrics/7/durations", DataLayout::MLD_CELL_DURATIONS_7}, + {"/ch/checksum", DataLayout::HSGR_CHECKSUM}, + {"/ch/contracted_graph/node_array", DataLayout::CH_GRAPH_NODE_LIST}, + {"/ch/contracted_graph/edge_array", DataLayout::CH_GRAPH_EDGE_LIST}, + {"/ch/connectivity_checksum", DataLayout::IGNORE_BLOCK}, + {"/ch/edge_filter/0", DataLayout::CH_EDGE_FILTER_0}, + {"/ch/edge_filter/1", DataLayout::CH_EDGE_FILTER_1}, + {"/ch/edge_filter/2", DataLayout::CH_EDGE_FILTER_2}, + {"/ch/edge_filter/3", DataLayout::CH_EDGE_FILTER_3}, + {"/ch/edge_filter/4", DataLayout::CH_EDGE_FILTER_4}, + {"/ch/edge_filter/5", DataLayout::CH_EDGE_FILTER_5}, + {"/ch/edge_filter/6", DataLayout::CH_EDGE_FILTER_6}, + {"/ch/edge_filter/7", DataLayout::CH_EDGE_FILTER_7}, + }; + std::vector blocks; + + constexpr bool REQUIRED = true; + constexpr bool OPTIONAL = false; + std::vector> tar_files = { + {OPTIONAL, config.GetPath(".osrm.mldgr")}, + {OPTIONAL, config.GetPath(".osrm.cells")}, + {OPTIONAL, config.GetPath(".osrm.partition")}, + {OPTIONAL, config.GetPath(".osrm.cell_metrics")}, + {OPTIONAL, config.GetPath(".osrm.hsgr")} + }; + + for (const auto &file : tar_files) { - std::unordered_map name_to_block_id = { - {"/mld/multilevelgraph/node_array", DataLayout::MLD_GRAPH_NODE_LIST}, - {"/mld/multilevelgraph/edge_array", DataLayout::MLD_GRAPH_EDGE_LIST}, - {"/mld/multilevelgraph/node_to_edge_offset", DataLayout::MLD_GRAPH_NODE_TO_OFFSET}, - {"/mld/multilevelgraph/connectivity_checksum", DataLayout::IGNORE_BLOCK}, - {"/mld/multilevelpartition/level_data", DataLayout::MLD_LEVEL_DATA}, - {"/mld/multilevelpartition/partition", DataLayout::MLD_PARTITION}, - {"/mld/multilevelpartition/cell_to_children", DataLayout::MLD_CELL_TO_CHILDREN}, - {"/mld/cellstorage/source_boundary", DataLayout::MLD_CELL_SOURCE_BOUNDARY}, - {"/mld/cellstorage/destination_boundary", DataLayout::MLD_CELL_DESTINATION_BOUNDARY}, - {"/mld/cellstorage/cells", DataLayout::MLD_CELLS}, - {"/mld/cellstorage/level_to_cell_offset", DataLayout::MLD_CELL_LEVEL_OFFSETS}, - {"/mld/metrics/0/weights", DataLayout::MLD_CELL_WEIGHTS_0}, - {"/mld/metrics/1/weights", DataLayout::MLD_CELL_WEIGHTS_1}, - {"/mld/metrics/2/weights", DataLayout::MLD_CELL_WEIGHTS_2}, - {"/mld/metrics/3/weights", DataLayout::MLD_CELL_WEIGHTS_3}, - {"/mld/metrics/4/weights", DataLayout::MLD_CELL_WEIGHTS_4}, - {"/mld/metrics/5/weights", DataLayout::MLD_CELL_WEIGHTS_5}, - {"/mld/metrics/6/weights", DataLayout::MLD_CELL_WEIGHTS_6}, - {"/mld/metrics/7/weights", DataLayout::MLD_CELL_WEIGHTS_7}, - {"/mld/metrics/0/durations", DataLayout::MLD_CELL_DURATIONS_0}, - {"/mld/metrics/1/durations", DataLayout::MLD_CELL_DURATIONS_1}, - {"/mld/metrics/2/durations", DataLayout::MLD_CELL_DURATIONS_2}, - {"/mld/metrics/3/durations", DataLayout::MLD_CELL_DURATIONS_3}, - {"/mld/metrics/4/durations", DataLayout::MLD_CELL_DURATIONS_4}, - {"/mld/metrics/5/durations", DataLayout::MLD_CELL_DURATIONS_5}, - {"/mld/metrics/6/durations", DataLayout::MLD_CELL_DURATIONS_6}, - {"/mld/metrics/7/durations", DataLayout::MLD_CELL_DURATIONS_7}, - }; - std::vector blocks; - - std::vector optional_tar_files = {config.GetPath(".osrm.mldgr"), - config.GetPath(".osrm.cells"), - config.GetPath(".osrm.partition"), - config.GetPath(".osrm.cell_metrics")}; - - for (const auto &path : optional_tar_files) + if (boost::filesystem::exists(std::get<1>(file))) { - if (boost::filesystem::exists(path)) + readBlocks(std::get<1>(file), std::back_inserter(blocks)); + } + else + { + if (std::get<0>(file) == REQUIRED) { - readBlocks(path, std::back_inserter(blocks)); + throw util::exception("Could not find required filed: " + std::get<1>(file).string()); } } + } - for (const auto &block : blocks) + for (const auto &block : blocks) + { + auto id_iter = name_to_block_id.find(std::get<0>(block)); + if (id_iter == name_to_block_id.end()) { - auto id_iter = name_to_block_id.find(std::get<0>(block)); - if (id_iter == name_to_block_id.end()) - { - throw util::exception("Could not map " + std::get<0>(block) + - " to a region in memory."); - } - layout.SetBlock(id_iter->second, std::get<1>(block)); + throw util::exception("Could not map " + std::get<0>(block) + + " to a region in memory."); } + layout.SetBlock(id_iter->second, std::get<1>(block)); } }