diff --git a/include/contractor/contracted_metric.hpp b/include/contractor/contracted_metric.hpp
new file mode 100644
index 00000000000..f44f49e8320
--- /dev/null
+++ b/include/contractor/contracted_metric.hpp
@@ -0,0 +1,25 @@
+#ifndef OSMR_CONTRACTOR_CONTRACTED_METRIC_HPP
+#define OSMR_CONTRACTOR_CONTRACTED_METRIC_HPP
+
+#include "contractor/query_graph.hpp"
+
+namespace osrm
+{
+namespace contractor
+{
+
+namespace detail
+{
+template <storage::Ownership Ownership> struct ContractedMetric
+{
+    detail::QueryGraph<Ownership> graph;
+    std::vector<util::ViewOrVector<bool, Ownership>> edge_filter;
+};
+}
+
+using ContractedMetric = detail::ContractedMetric<storage::Ownership::Container>;
+using ContractedMetricView = detail::ContractedMetric<storage::Ownership::View>;
+}
+}
+
+#endif
diff --git a/include/contractor/files.hpp b/include/contractor/files.hpp
index 39a15acaa9c..8dcade795d2 100644
--- a/include/contractor/files.hpp
+++ b/include/contractor/files.hpp
@@ -1,12 +1,9 @@
 #ifndef OSRM_CONTRACTOR_FILES_HPP
 #define OSRM_CONTRACTOR_FILES_HPP
 
-#include "contractor/query_graph.hpp"
+#include "contractor/serialization.hpp"
 
-#include "util/serialization.hpp"
-
-#include "storage/serialization.hpp"
-#include "storage/tar.hpp"
+#include <unordered_map>
 
 namespace osrm
 {
@@ -15,67 +12,45 @@ namespace contractor
 namespace files
 {
 // reads .osrm.hsgr file
-template <typename QueryGraphT, typename EdgeFilterT>
+template <typename ContractedMetricT>
 inline void readGraph(const boost::filesystem::path &path,
-                      unsigned &checksum,
-                      QueryGraphT &graph,
-                      std::vector<EdgeFilterT> &edge_filter,
+                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                       std::uint32_t &connectivity_checksum)
 {
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-    static_assert(std::is_same<EdgeFilterT, std::vector<bool>>::value ||
-                      std::is_same<EdgeFilterT, util::vector_view<bool>>::value,
-                  "edge_filter must be a container of vector<bool> or vector_view<bool>");
+    static_assert(std::is_same<ContractedMetric, ContractedMetricT>::value ||
+                      std::is_same<ContractedMetricView, ContractedMetricT>::value,
+                  "metric must be of type ContractedMetric<>");
 
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
 
-    reader.ReadInto("/ch/checksum", checksum);
-    util::serialization::read(reader, "/ch/contracted_graph", graph);
+    reader.ReadInto("/ch/connectivity_checksum", connectivity_checksum);
 
-    auto count = reader.ReadElementCount64("/ch/edge_filter");
-    edge_filter.resize(count);
-    for (const auto index : util::irange<std::size_t>(0, count))
+    for (auto &pair : metrics)
     {
-        storage::serialization::read(
-            reader, "/ch/edge_filter/" + std::to_string(index), edge_filter[index]);
+        serialization::read(reader, "/ch/metrics/" + pair.first, pair.second);
     }
-
-    reader.ReadInto("/ch/connectivity_checksum", connectivity_checksum);
 }
 
 // writes .osrm.hsgr file
-template <typename QueryGraphT, typename EdgeFilterT>
+template <typename ContractedMetricT>
 inline void writeGraph(const boost::filesystem::path &path,
-                       unsigned checksum,
-                       const QueryGraphT &graph,
-                       const std::vector<EdgeFilterT> &edge_filter,
+                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
                        const std::uint32_t connectivity_checksum)
 {
-    static_assert(std::is_same<QueryGraphView, QueryGraphT>::value ||
-                      std::is_same<QueryGraph, QueryGraphT>::value,
-                  "graph must be of type QueryGraph<>");
-    static_assert(std::is_same<EdgeFilterT, std::vector<bool>>::value ||
-                      std::is_same<EdgeFilterT, util::vector_view<bool>>::value,
-                  "edge_filter must be a container of vector<bool> or vector_view<bool>");
+    static_assert(std::is_same<ContractedMetric, ContractedMetricT>::value ||
+                      std::is_same<ContractedMetricView, ContractedMetricT>::value,
+                  "metric must be of type ContractedMetric<>");
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
 
-    writer.WriteElementCount64("/ch/checksum", 1);
-    writer.WriteFrom("/ch/checksum", checksum);
-    util::serialization::write(writer, "/ch/contracted_graph", graph);
+    writer.WriteElementCount64("/ch/connectivity_checksum", 1);
+    writer.WriteFrom("/ch/connectivity_checksum", connectivity_checksum);
 
-    writer.WriteElementCount64("/ch/edge_filter", edge_filter.size());
-    for (const auto index : util::irange<std::size_t>(0, edge_filter.size()))
+    for (const auto &pair : metrics)
     {
-        storage::serialization::write(
-            writer, "/ch/edge_filter/" + std::to_string(index), edge_filter[index]);
+        serialization::write(writer, "/ch/metrics/" + pair.first, pair.second);
     }
-
-    writer.WriteElementCount64("/ch/connectivity_checksum", 1);
-    writer.WriteFrom("/ch/connectivity_checksum", connectivity_checksum);
 }
 }
 }
diff --git a/include/contractor/serialization.hpp b/include/contractor/serialization.hpp
new file mode 100644
index 00000000000..aa86592742d
--- /dev/null
+++ b/include/contractor/serialization.hpp
@@ -0,0 +1,53 @@
+#ifndef OSRM_CONTRACTOR_SERIALIZATION_HPP
+#define OSRM_CONTRACTOR_SERIALIZATION_HPP
+
+#include "contractor/contracted_metric.hpp"
+
+#include "util/serialization.hpp"
+
+#include "storage/serialization.hpp"
+#include "storage/tar.hpp"
+
+namespace osrm
+{
+namespace contractor
+{
+namespace serialization
+{
+
+template <storage::Ownership Ownership>
+void write(storage::tar::FileWriter &writer,
+           const std::string &name,
+           const detail::ContractedMetric<Ownership> &metric)
+{
+    util::serialization::write(writer, name + "/contracted_graph", metric.graph);
+
+    writer.WriteElementCount64(name + "/exclude", metric.edge_filter.size());
+    for (const auto index : util::irange<std::size_t>(0, metric.edge_filter.size()))
+    {
+        storage::serialization::write(writer,
+                                      name + "/exclude/" + std::to_string(index) + "/edge_filter",
+                                      metric.edge_filter[index]);
+    }
+}
+
+template <storage::Ownership Ownership>
+void read(storage::tar::FileReader &reader,
+          const std::string &name,
+          detail::ContractedMetric<Ownership> &metric)
+{
+    util::serialization::read(reader, name + "/contracted_graph", metric.graph);
+
+    metric.edge_filter.resize(reader.ReadElementCount64(name + "/exclude"));
+    for (const auto index : util::irange<std::size_t>(0, metric.edge_filter.size()))
+    {
+        storage::serialization::read(reader,
+                                     name + "/exclude/" + std::to_string(index) + "/edge_filter",
+                                     metric.edge_filter[index]);
+    }
+}
+}
+}
+}
+
+#endif
diff --git a/include/customizer/files.hpp b/include/customizer/files.hpp
index 098752f9c9e..c89b5cb7607 100644
--- a/include/customizer/files.hpp
+++ b/include/customizer/files.hpp
@@ -7,6 +7,8 @@
 
 #include "util/integer_range.hpp"
 
+#include <unordered_map>
+
 namespace osrm
 {
 namespace customizer
@@ -16,7 +18,8 @@ namespace files
 
 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const boost::filesystem::path &path, std::vector<CellMetricT> &metrics)
+inline void readCellMetrics(const boost::filesystem::path &path,
+                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
                       std::is_same<CellMetric, CellMetricT>::value,
@@ -25,20 +28,28 @@ inline void readCellMetrics(const boost::filesystem::path &path, std::vector<Cel
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
 
-    auto num_metrics = reader.ReadElementCount64("/mld/metrics");
-    metrics.resize(num_metrics);
-
-    auto id = 0;
-    for (auto &metric : metrics)
+    for (auto &pair : metrics)
     {
-        serialization::read(reader, "/mld/metrics/" + std::to_string(id++), metric);
+        const auto &metric_name = pair.first;
+        auto &metric_exclude_classes = pair.second;
+
+        auto prefix = "/mld/metrics/" + metric_name + "/exclude";
+        auto num_exclude_classes = reader.ReadElementCount64(prefix);
+        metric_exclude_classes.resize(num_exclude_classes);
+
+        auto id = 0;
+        for (auto &metric : metric_exclude_classes)
+        {
+            serialization::read(reader, prefix + "/" + std::to_string(id++), metric);
+        }
     }
 }
 
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void writeCellMetrics(const boost::filesystem::path &path,
-                             const std::vector<CellMetricT> &metrics)
+inline void
+writeCellMetrics(const boost::filesystem::path &path,
+                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
     static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
                       std::is_same<CellMetric, CellMetricT>::value,
@@ -47,12 +58,19 @@ inline void writeCellMetrics(const boost::filesystem::path &path,
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
 
-    writer.WriteElementCount64("/mld/metrics", metrics.size());
-
-    auto id = 0;
-    for (const auto &metric : metrics)
+    for (const auto &pair : metrics)
     {
-        serialization::write(writer, "/mld/metrics/" + std::to_string(id++), metric);
+        const auto &metric_name = pair.first;
+        const auto &metric_exclude_classes = pair.second;
+
+        auto prefix = "/mld/metrics/" + metric_name + "/exclude";
+        writer.WriteElementCount64(prefix, metric_exclude_classes.size());
+
+        auto id = 0;
+        for (auto &exclude_metric : metric_exclude_classes)
+        {
+            serialization::write(writer, prefix + "/" + std::to_string(id++), exclude_metric);
+        }
     }
 }
 }
diff --git a/include/engine/algorithm.hpp b/include/engine/algorithm.hpp
index 751ef6b9b09..8f48b373005 100644
--- a/include/engine/algorithm.hpp
+++ b/include/engine/algorithm.hpp
@@ -30,6 +30,11 @@ template <typename AlgorithmT> const char *name();
 template <> inline const char *name<ch::Algorithm>() { return "CH"; }
 template <> inline const char *name<mld::Algorithm>() { return "MLD"; }
 
+// Algorithm identifier
+template <typename AlgorithmT> const char *identifier();
+template <> inline const char *identifier<ch::Algorithm>() { return "ch"; }
+template <> inline const char *identifier<mld::Algorithm>() { return "mld"; }
+
 template <typename AlgorithmT> struct HasAlternativePathSearch final : std::false_type
 {
 };
diff --git a/include/engine/datafacade/contiguous_block_allocator.hpp b/include/engine/datafacade/contiguous_block_allocator.hpp
index 0a185202524..cc2dbca5a8d 100644
--- a/include/engine/datafacade/contiguous_block_allocator.hpp
+++ b/include/engine/datafacade/contiguous_block_allocator.hpp
@@ -16,7 +16,7 @@ class ContiguousBlockAllocator
     virtual ~ContiguousBlockAllocator() = default;
 
     // interface to give access to the datafacades
-    virtual storage::DataLayout &GetLayout() = 0;
+    virtual const storage::DataLayout &GetLayout() = 0;
     virtual char *GetMemory() = 0;
 };
 
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index c8785661d25..4281e295ef8 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -9,44 +9,13 @@
 #include "engine/approach.hpp"
 #include "engine/geospatial_query.hpp"
 
-#include "customizer/edge_based_graph.hpp"
-
-#include "extractor/datasources.hpp"
-#include "extractor/edge_based_node.hpp"
-#include "extractor/intersection_bearings_container.hpp"
-#include "extractor/maneuver_override.hpp"
-#include "extractor/name_table.hpp"
-#include "extractor/node_data_container.hpp"
-#include "extractor/packed_osm_ids.hpp"
-#include "extractor/profile_properties.hpp"
-#include "extractor/segment_data_container.hpp"
-#include "extractor/turn_lane_types.hpp"
-
-#include "guidance/turn_bearing.hpp"
-#include "guidance/turn_data_container.hpp"
-#include "guidance/turn_instruction.hpp"
-
-#include "contractor/query_graph.hpp"
-
-#include "partitioner/cell_storage.hpp"
-#include "partitioner/multi_level_partition.hpp"
-
 #include "storage/shared_datatype.hpp"
 #include "storage/shared_memory_ownership.hpp"
+#include "storage/view_factory.hpp"
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
-#include "util/filtered_graph.hpp"
-#include "util/guidance/bearing_class.hpp"
-#include "util/guidance/entry_class.hpp"
-#include "util/guidance/turn_lanes.hpp"
 #include "util/log.hpp"
-#include "util/packed_vector.hpp"
-#include "util/range_table.hpp"
-#include "util/rectangle.hpp"
-#include "util/static_graph.hpp"
-#include "util/static_rtree.hpp"
-#include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
 
@@ -81,45 +50,24 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
 
-    void InitializeGraphPointer(storage::DataLayout &data_layout,
-                                char *memory_block,
-                                const std::size_t exclude_index)
-    {
-        auto graph_nodes_ptr = data_layout.GetBlockPtr<GraphNode>(
-            memory_block, storage::DataLayout::CH_GRAPH_NODE_LIST);
-
-        auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
-            memory_block, storage::DataLayout::CH_GRAPH_EDGE_LIST);
-
-        auto filter_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::CH_EDGE_FILTER_0 + exclude_index);
-
-        auto edge_filter_ptr =
-            data_layout.GetBlockPtr<util::vector_view<bool>::Word>(memory_block, filter_block_id);
-
-        util::vector_view<GraphNode> node_list(
-            graph_nodes_ptr, data_layout.GetBlockEntries(storage::DataLayout::CH_GRAPH_NODE_LIST));
-        util::vector_view<GraphEdge> edge_list(
-            graph_edges_ptr, data_layout.GetBlockEntries(storage::DataLayout::CH_GRAPH_EDGE_LIST));
-
-        util::vector_view<bool> edge_filter(edge_filter_ptr,
-                                            data_layout.GetBlockEntries(filter_block_id));
-        m_query_graph = QueryGraph({node_list, edge_list}, edge_filter);
-    }
-
   public:
     ContiguousInternalMemoryAlgorithmDataFacade(
-        std::shared_ptr<ContiguousBlockAllocator> allocator_, std::size_t exclude_index)
+        std::shared_ptr<ContiguousBlockAllocator> allocator_,
+        const std::string &metric_name,
+        std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(
+            allocator->GetLayout(), allocator->GetMemory(), metric_name, exclude_index);
     }
 
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
+    void InitializeInternalPointers(const storage::DataLayout &data_layout,
                                     char *memory_block,
+                                    const std::string &metric_name,
                                     const std::size_t exclude_index)
     {
-        InitializeGraphPointer(data_layout, memory_block, exclude_index);
+        m_query_graph = make_filtered_graph_view(
+            memory_block, data_layout, "/ch/metrics/" + metric_name, exclude_index);
     }
 
     // search graph access
@@ -191,7 +139,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::ProfileProperties *m_profile_properties;
     extractor::Datasources *m_datasources;
 
-    unsigned m_check_sum;
+    std::uint32_t m_check_sum;
     util::vector_view<util::Coordinate> m_coordinate_list;
     extractor::PackedOSMIDsView m_osmnodeid_list;
     util::vector_view<std::uint32_t> m_lane_description_offsets;
@@ -210,7 +158,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     util::vector_view<extractor::StorageManeuverOverride> m_maneuver_overrides;
     util::vector_view<NodeID> m_maneuver_override_node_sequences;
 
-    std::unique_ptr<SharedRTree> m_static_rtree;
+    SharedRTree m_static_rtree;
     std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
     boost::filesystem::path file_index_path;
 
@@ -224,336 +172,67 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     // allocator that keeps the allocation data
     std::shared_ptr<ContiguousBlockAllocator> allocator;
 
-    void InitializeProfilePropertiesPointer(storage::DataLayout &data_layout,
-                                            char *memory_block,
-                                            const std::size_t exclude_index)
+    void InitializeInternalPointers(const storage::DataLayout &layout,
+                                    char *memory_ptr,
+                                    const std::string &metric_name,
+                                    const std::size_t exclude_index)
     {
-        m_profile_properties = data_layout.GetBlockPtr<extractor::ProfileProperties>(
-            memory_block, storage::DataLayout::PROPERTIES);
+        // TODO: For multi-metric support we need to have separate exclude classes per metric
+        (void)metric_name;
+
+        m_profile_properties =
+            layout.GetBlockPtr<extractor::ProfileProperties>(memory_ptr, "/common/properties");
 
         exclude_mask = m_profile_properties->excludable_classes[exclude_index];
-    }
 
-    void InitializeChecksumPointer(storage::DataLayout &data_layout, char *memory_block)
-    {
         m_check_sum =
-            *data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::HSGR_CHECKSUM);
-        util::Log() << "set checksum: " << m_check_sum;
-    }
+            *layout.GetBlockPtr<std::uint32_t>(memory_ptr, "/common/connectivity_checksum");
 
-    void InitializeRTreePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        BOOST_ASSERT_MSG(!m_coordinate_list.empty(), "coordinates must be loaded before r-tree");
+        std::tie(m_coordinate_list, m_osmnodeid_list) =
+            make_nbn_data_view(memory_ptr, layout, "/common/nbn_data");
 
-        const auto file_index_ptr =
-            data_layout.GetBlockPtr<char>(memory_block, storage::DataLayout::FILE_INDEX_PATH);
-        file_index_path = boost::filesystem::path(file_index_ptr);
-        if (!boost::filesystem::exists(file_index_path))
-        {
-            util::Log(logDEBUG) << "Leaf file name " << file_index_path.string();
-            throw util::exception("Could not load " + file_index_path.string() +
-                                  "Is any data loaded into shared memory?" + SOURCE_REF);
-        }
-
-        const auto rtree_ptr =
-            data_layout.GetBlockPtr<RTreeNode>(memory_block, storage::DataLayout::R_SEARCH_TREE);
-        util::vector_view<RTreeNode> search_tree(
-            rtree_ptr, data_layout.GetBlockEntries(storage::DataLayout::R_SEARCH_TREE));
-
-        const auto rtree_levelstarts_ptr = data_layout.GetBlockPtr<std::uint64_t>(
-            memory_block, storage::DataLayout::R_SEARCH_TREE_LEVEL_STARTS);
-        util::vector_view<std::uint64_t> rtree_level_starts(
-            rtree_levelstarts_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::R_SEARCH_TREE_LEVEL_STARTS));
-
-        m_static_rtree.reset(new SharedRTree{std::move(search_tree),
-                                             std::move(rtree_level_starts),
-                                             file_index_path,
-                                             m_coordinate_list});
+        m_static_rtree = make_search_tree_view(memory_ptr, layout, "/common/rtree");
         m_geospatial_query.reset(
-            new SharedGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
-    }
+            new SharedGeospatialQuery(m_static_rtree, m_coordinate_list, *this));
 
-    void InitializeNodeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
-    {
-        const auto coordinate_list_ptr =
-            layout.GetBlockPtr<util::Coordinate>(memory_ptr, storage::DataLayout::COORDINATE_LIST);
-        m_coordinate_list.reset(coordinate_list_ptr,
-                                layout.GetBlockEntries(storage::DataLayout::COORDINATE_LIST));
+        edge_based_node_data = make_ebn_data_view(memory_ptr, layout, "/common/ebg_node_data");
 
-        const auto osmnodeid_ptr = layout.GetBlockPtr<extractor::PackedOSMIDsView::block_type>(
-            memory_ptr, storage::DataLayout::OSM_NODE_ID_LIST);
-        m_osmnodeid_list = extractor::PackedOSMIDsView(
-            util::vector_view<extractor::PackedOSMIDsView::block_type>(
-                osmnodeid_ptr, layout.GetBlockEntries(storage::DataLayout::OSM_NODE_ID_LIST)),
-            // We (ab)use the number of coordinates here because we know we have the same amount of
-            // ids
-            layout.GetBlockEntries(storage::DataLayout::COORDINATE_LIST));
-    }
+        turn_data = make_turn_data_view(memory_ptr, layout, "/common/turn_data");
 
-    void InitializeEdgeBasedNodeDataInformationPointers(storage::DataLayout &layout,
-                                                        char *memory_ptr)
-    {
-        const auto edge_based_node_list_ptr = layout.GetBlockPtr<extractor::EdgeBasedNode>(
-            memory_ptr, storage::DataLayout::EDGE_BASED_NODE_DATA_LIST);
-        util::vector_view<extractor::EdgeBasedNode> edge_based_node_data_list(
-            edge_based_node_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::EDGE_BASED_NODE_DATA_LIST));
-
-        const auto annotation_data_list_ptr =
-            layout.GetBlockPtr<extractor::NodeBasedEdgeAnnotation>(
-                memory_ptr, storage::DataLayout::ANNOTATION_DATA_LIST);
-        util::vector_view<extractor::NodeBasedEdgeAnnotation> annotation_data(
-            annotation_data_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::ANNOTATION_DATA_LIST));
+        m_name_table = make_name_table_view(memory_ptr, layout, "/common/names");
 
-        edge_based_node_data = extractor::EdgeBasedNodeDataView(
-            std::move(edge_based_node_data_list), std::move(annotation_data));
-    }
-
-    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
-    {
-        const auto lane_data_id_ptr =
-            layout.GetBlockPtr<LaneDataID>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
-        util::vector_view<LaneDataID> lane_data_ids(
-            lane_data_id_ptr, layout.GetBlockEntries(storage::DataLayout::LANE_DATA_ID));
+        std::tie(m_lane_description_offsets, m_lane_description_masks) =
+            make_turn_lane_description_views(memory_ptr, layout, "/common/turn_lanes");
+        m_lane_tupel_id_pairs = make_lane_data_view(memory_ptr, layout, "/common/turn_lanes");
 
-        const auto turn_instruction_list_ptr = layout.GetBlockPtr<guidance::TurnInstruction>(
-            memory_ptr, storage::DataLayout::TURN_INSTRUCTION);
-        util::vector_view<guidance::TurnInstruction> turn_instructions(
-            turn_instruction_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::TURN_INSTRUCTION));
-
-        const auto entry_class_id_list_ptr =
-            layout.GetBlockPtr<EntryClassID>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
-        util::vector_view<EntryClassID> entry_class_ids(
-            entry_class_id_list_ptr, layout.GetBlockEntries(storage::DataLayout::ENTRY_CLASSID));
-
-        const auto pre_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
-            memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> pre_turn_bearings(
-            pre_turn_bearing_ptr, layout.GetBlockEntries(storage::DataLayout::PRE_TURN_BEARING));
-
-        const auto post_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
-            memory_ptr, storage::DataLayout::POST_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> post_turn_bearings(
-            post_turn_bearing_ptr, layout.GetBlockEntries(storage::DataLayout::POST_TURN_BEARING));
-
-        turn_data = guidance::TurnDataView(std::move(turn_instructions),
-                                           std::move(lane_data_ids),
-                                           std::move(entry_class_ids),
-                                           std::move(pre_turn_bearings),
-                                           std::move(post_turn_bearings));
-    }
-
-    void InitializeNamePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        const auto name_blocks_ptr =
-            data_layout.GetBlockPtr<extractor::NameTableView::IndexedData::BlockReference>(
-                memory_block, storage::DataLayout::NAME_BLOCKS);
-        const auto name_values_ptr =
-            data_layout.GetBlockPtr<extractor::NameTableView::IndexedData::ValueType>(
-                memory_block, storage::DataLayout::NAME_VALUES);
-
-        util::vector_view<extractor::NameTableView::IndexedData::BlockReference> blocks(
-            name_blocks_ptr, data_layout.GetBlockEntries(storage::DataLayout::NAME_BLOCKS));
-        util::vector_view<extractor::NameTableView::IndexedData::ValueType> values(
-            name_values_ptr, data_layout.GetBlockEntries(storage::DataLayout::NAME_VALUES));
-
-        extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)};
-        m_name_table = extractor::NameTableView{std::move(index_data_view)};
-    }
-
-    void InitializeTurnLaneDescriptionsPointers(storage::DataLayout &data_layout,
-                                                char *memory_block)
-    {
-        auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
-            memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::vector_view<std::uint32_t> offsets(
-            offsets_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::LANE_DESCRIPTION_OFFSETS));
-        m_lane_description_offsets = std::move(offsets);
-
-        auto masks_ptr = data_layout.GetBlockPtr<extractor::TurnLaneType::Mask>(
-            memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);
-
-        util::vector_view<extractor::TurnLaneType::Mask> masks(
-            masks_ptr, data_layout.GetBlockEntries(storage::DataLayout::LANE_DESCRIPTION_MASKS));
-        m_lane_description_masks = std::move(masks);
-
-        const auto lane_tupel_id_pair_ptr =
-            data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
-                memory_block, storage::DataLayout::TURN_LANE_DATA);
-        util::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
-            lane_tupel_id_pair_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::TURN_LANE_DATA));
-        m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);
-    }
-
-    void InitializeTurnPenalties(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
-            memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES);
-        m_turn_weight_penalties = util::vector_view<TurnPenalty>(
-            turn_weight_penalties_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::TURN_WEIGHT_PENALTIES));
-        auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
-            memory_block, storage::DataLayout::TURN_DURATION_PENALTIES);
-        m_turn_duration_penalties = util::vector_view<TurnPenalty>(
-            turn_duration_penalties_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::TURN_DURATION_PENALTIES));
-    }
-
-    void InitializeGeometryPointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto geometries_index_ptr =
-            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::vector_view<unsigned> geometry_begin_indices(
-            geometries_index_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_INDEX));
-
-        auto num_entries = data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_NODE_LIST);
-        auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
-            memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::vector_view<NodeID> geometry_node_list(geometries_node_list_ptr, num_entries);
-
-        auto geometries_fwd_weight_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_fwd_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_fwd_weight_list_ptr,
-                data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST)),
-            num_entries);
-
-        auto geometries_rev_weight_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_rev_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_rev_weight_list_ptr,
-                data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST)),
-            num_entries);
-
-        auto geometries_fwd_duration_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_fwd_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_fwd_duration_list_ptr,
-                data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST)),
-            num_entries);
-
-        auto geometries_rev_duration_list_ptr =
-            data_layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_rev_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_rev_duration_list_ptr,
-                data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_DURATION_LIST)),
-            num_entries);
-
-        auto geometries_fwd_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
-            memory_block, storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_fwd_datasources_list(
-            geometries_fwd_datasources_list_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST));
-
-        auto geometries_rev_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
-            memory_block, storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_rev_datasources_list(
-            geometries_rev_datasources_list_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST));
-
-        segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
-                                                  std::move(geometry_node_list),
-                                                  std::move(geometry_fwd_weight_list),
-                                                  std::move(geometry_rev_weight_list),
-                                                  std::move(geometry_fwd_duration_list),
-                                                  std::move(geometry_rev_duration_list),
-                                                  std::move(geometry_fwd_datasources_list),
-                                                  std::move(geometry_rev_datasources_list)};
-
-        m_datasources = data_layout.GetBlockPtr<extractor::Datasources>(
-            memory_block, storage::DataLayout::DATASOURCES_NAMES);
-    }
-
-    void InitializeIntersectionClassPointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
-            memory_block, storage::DataLayout::BEARING_CLASSID);
-        util::vector_view<BearingClassID> bearing_class_id(
-            bearing_class_id_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::BEARING_CLASSID));
-
-        auto bearing_values_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
-            memory_block, storage::DataLayout::BEARING_VALUES);
-        util::vector_view<DiscreteBearing> bearing_values(
-            bearing_values_ptr, data_layout.GetBlockEntries(storage::DataLayout::BEARING_VALUES));
-
-        auto offsets_ptr =
-            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS);
-        auto blocks_ptr =
-            data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS);
-        util::vector_view<unsigned> bearing_offsets(
-            offsets_ptr, data_layout.GetBlockEntries(storage::DataLayout::BEARING_OFFSETS));
-        util::vector_view<IndexBlock> bearing_blocks(
-            blocks_ptr, data_layout.GetBlockEntries(storage::DataLayout::BEARING_BLOCKS));
-
-        util::RangeTable<16, storage::Ownership::View> bearing_range_table(
-            bearing_offsets, bearing_blocks, static_cast<unsigned>(bearing_values.size()));
-
-        intersection_bearings_view = extractor::IntersectionBearingsView{
-            std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
-
-        auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
-            memory_block, storage::DataLayout::ENTRY_CLASS);
-        util::vector_view<util::guidance::EntryClass> entry_class_table(
-            entry_class_ptr, data_layout.GetBlockEntries(storage::DataLayout::ENTRY_CLASS));
-        m_entry_class_table = std::move(entry_class_table);
-    }
-
-    void InitializeManeuverOverridePointers(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto maneuver_overrides_ptr = data_layout.GetBlockPtr<extractor::StorageManeuverOverride>(
-            memory_block, storage::DataLayout::MANEUVER_OVERRIDES);
-        m_maneuver_overrides = util::vector_view<extractor::StorageManeuverOverride>(
-            maneuver_overrides_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::MANEUVER_OVERRIDES));
-
-        auto maneuver_override_node_sequences_ptr = data_layout.GetBlockPtr<NodeID>(
-            memory_block, storage::DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES);
-        m_maneuver_override_node_sequences = util::vector_view<NodeID>(
-            maneuver_override_node_sequences_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES));
-    }
-
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
-                                    char *memory_block,
-                                    const std::size_t exclude_index)
-    {
-        InitializeChecksumPointer(data_layout, memory_block);
-        InitializeNodeInformationPointers(data_layout, memory_block);
-        InitializeEdgeBasedNodeDataInformationPointers(data_layout, memory_block);
-        InitializeEdgeInformationPointers(data_layout, memory_block);
-        InitializeTurnPenalties(data_layout, memory_block);
-        InitializeGeometryPointers(data_layout, memory_block);
-        InitializeNamePointers(data_layout, memory_block);
-        InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
-        InitializeProfilePropertiesPointer(data_layout, memory_block, exclude_index);
-        InitializeRTreePointers(data_layout, memory_block);
-        InitializeIntersectionClassPointers(data_layout, memory_block);
-        InitializeManeuverOverridePointers(data_layout, memory_block);
+        m_turn_weight_penalties = make_turn_weight_view(memory_ptr, layout, "/common/turn_penalty");
+        m_turn_duration_penalties =
+            make_turn_duration_view(memory_ptr, layout, "/common/turn_penalty");
+
+        segment_data = make_segment_data_view(memory_ptr, layout, "/common/segment_data");
+
+        m_datasources =
+            layout.GetBlockPtr<extractor::Datasources>(memory_ptr, "/common/data_sources_names");
+
+        intersection_bearings_view =
+            make_intersection_bearings_view(memory_ptr, layout, "/common/intersection_bearings");
+
+        m_entry_class_table = make_entry_classes_view(memory_ptr, layout, "/common/entry_classes");
+
+        std::tie(m_maneuver_overrides, m_maneuver_override_node_sequences) =
+            make_maneuver_overrides_views(memory_ptr, layout, "/common/maneuver_overrides");
     }
 
   public:
     // allows switching between process_memory/shared_memory datafacade, based on the type of
     // allocator
     ContiguousInternalMemoryDataFacadeBase(std::shared_ptr<ContiguousBlockAllocator> allocator_,
+                                           const std::string &metric_name,
                                            const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(
+            allocator->GetLayout(), allocator->GetMemory(), metric_name, exclude_index);
     }
 
     // node and edge information access
@@ -772,7 +451,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             input_coordinate, bearing, bearing_range, approach);
     }
 
-    unsigned GetCheckSum() const override final { return m_check_sum; }
+    std::uint32_t GetCheckSum() const override final { return m_check_sum; }
 
     GeometryID GetGeometryIndex(const NodeID id) const override final
     {
@@ -961,9 +640,10 @@ class ContiguousInternalMemoryDataFacade<CH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+                                       const std::string &metric_name,
                                        const std::size_t exclude_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
-          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator, exclude_index)
+        : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
+          ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator, metric_name, exclude_index)
 
     {
     }
@@ -981,122 +661,16 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
     QueryGraph query_graph;
 
-    void InitializeInternalPointers(storage::DataLayout &data_layout,
-                                    char *memory_block,
+    void InitializeInternalPointers(const storage::DataLayout &layout,
+                                    char *memory_ptr,
+                                    const std::string &metric_name,
                                     const std::size_t exclude_index)
     {
-        InitializeMLDDataPointers(data_layout, memory_block, exclude_index);
-        InitializeGraphPointer(data_layout, memory_block);
-    }
-
-    void InitializeMLDDataPointers(storage::DataLayout &data_layout,
-                                   char *memory_block,
-                                   const std::size_t exclude_index)
-    {
-        if (data_layout.GetBlockSize(storage::DataLayout::MLD_PARTITION) > 0)
-        {
-            BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_LEVEL_DATA) > 0);
-            BOOST_ASSERT(data_layout.GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0);
-
-            auto level_data =
-                data_layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
-                    memory_block, storage::DataLayout::MLD_LEVEL_DATA);
-
-            auto mld_partition_ptr = data_layout.GetBlockPtr<PartitionID>(
-                memory_block, storage::DataLayout::MLD_PARTITION);
-            auto partition_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
-
-            auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
-                memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            auto children_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
-
-            mld_partition =
-                partitioner::MultiLevelPartitionView{level_data, partition, cell_to_children};
-        }
-
-        const auto weights_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_WEIGHTS_0 + exclude_index);
-        const auto durations_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_DURATIONS_0 + exclude_index);
-
-        if (data_layout.GetBlockSize(weights_block_id) > 0)
-        {
-            auto mld_cell_weights_ptr =
-                data_layout.GetBlockPtr<EdgeWeight>(memory_block, weights_block_id);
-            auto mld_cell_durations_ptr =
-                data_layout.GetBlockPtr<EdgeDuration>(memory_block, durations_block_id);
-            auto weight_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_WEIGHTS_0);
-            auto duration_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_DURATIONS_0);
-            BOOST_ASSERT(weight_entries_count == duration_entries_count);
-            util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
-            util::vector_view<EdgeDuration> durations(mld_cell_durations_ptr,
-                                                      duration_entries_count);
-
-            mld_cell_metric = customizer::CellMetricView{std::move(weights), std::move(durations)};
-        }
-
-        if (data_layout.GetBlockSize(storage::DataLayout::MLD_CELLS) > 0)
-        {
-
-            auto mld_source_boundary_ptr = data_layout.GetBlockPtr<NodeID>(
-                memory_block, storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto mld_destination_boundary_ptr = data_layout.GetBlockPtr<NodeID>(
-                memory_block, storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto mld_cells_ptr = data_layout.GetBlockPtr<partitioner::CellStorageView::CellData>(
-                memory_block, storage::DataLayout::MLD_CELLS);
-            auto mld_cell_level_offsets_ptr = data_layout.GetBlockPtr<std::uint64_t>(
-                memory_block, storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            auto source_boundary_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto destination_boundary_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto cells_entries_counts = data_layout.GetBlockEntries(storage::DataLayout::MLD_CELLS);
-            auto cell_level_offsets_entries_count =
-                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
-                                                      source_boundary_entries_count);
-            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
-                                                           destination_boundary_entries_count);
-            util::vector_view<partitioner::CellStorageView::CellData> cells(mld_cells_ptr,
-                                                                            cells_entries_counts);
-            util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
-                                                           cell_level_offsets_entries_count);
-
-            mld_cell_storage = partitioner::CellStorageView{std::move(source_boundary),
-                                                            std::move(destination_boundary),
-                                                            std::move(cells),
-                                                            std::move(level_offsets)};
-        }
-    }
-    void InitializeGraphPointer(storage::DataLayout &data_layout, char *memory_block)
-    {
-        auto graph_nodes_ptr = data_layout.GetBlockPtr<GraphNode>(
-            memory_block, storage::DataLayout::MLD_GRAPH_NODE_LIST);
-
-        auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
-            memory_block, storage::DataLayout::MLD_GRAPH_EDGE_LIST);
-
-        auto graph_node_to_offset_ptr = data_layout.GetBlockPtr<QueryGraph::EdgeOffset>(
-            memory_block, storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET);
-
-        util::vector_view<GraphNode> node_list(
-            graph_nodes_ptr, data_layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_NODE_LIST));
-        util::vector_view<GraphEdge> edge_list(
-            graph_edges_ptr, data_layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_EDGE_LIST));
-        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
-            graph_node_to_offset_ptr,
-            data_layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET));
-
-        query_graph =
-            QueryGraph(std::move(node_list), std::move(edge_list), std::move(node_to_offset));
+        mld_partition = make_partition_view(memory_ptr, layout, "/mld/multilevelpartition");
+        mld_cell_metric = make_filtered_cell_metric_view(
+            memory_ptr, layout, "/mld/metrics/" + metric_name, exclude_index);
+        mld_cell_storage = make_cell_storage_view(memory_ptr, layout, "/mld/cellstorage");
+        query_graph = make_multi_level_graph_view(memory_ptr, layout, "/mld/multilevelgraph");
     }
 
     // allocator that keeps the allocation data
@@ -1104,10 +678,13 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
   public:
     ContiguousInternalMemoryAlgorithmDataFacade(
-        std::shared_ptr<ContiguousBlockAllocator> allocator_, const std::size_t exclude_index)
+        std::shared_ptr<ContiguousBlockAllocator> allocator_,
+        const std::string &metric_name,
+        const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
+        InitializeInternalPointers(
+            allocator->GetLayout(), allocator->GetMemory(), metric_name, exclude_index);
     }
 
     const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const override
@@ -1161,9 +738,10 @@ class ContiguousInternalMemoryDataFacade<MLD> final
   private:
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+                                       const std::string &metric_name,
                                        const std::size_t exclude_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
-          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, exclude_index)
+        : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
+          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, metric_name, exclude_index)
 
     {
     }
diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp
index 46d8e335020..ed40533c81e 100644
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@@ -53,7 +53,7 @@ class BaseDataFacade
     BaseDataFacade() {}
     virtual ~BaseDataFacade() {}
 
-    virtual unsigned GetCheckSum() const = 0;
+    virtual std::uint32_t GetCheckSum() const = 0;
 
     // node and edge information access
     virtual util::Coordinate GetCoordinateOfNode(const NodeID id) const = 0;
diff --git a/include/engine/datafacade/process_memory_allocator.hpp b/include/engine/datafacade/process_memory_allocator.hpp
index aa41dd6e4e8..705ab935e1b 100644
--- a/include/engine/datafacade/process_memory_allocator.hpp
+++ b/include/engine/datafacade/process_memory_allocator.hpp
@@ -27,12 +27,12 @@ class ProcessMemoryAllocator : public ContiguousBlockAllocator
     ~ProcessMemoryAllocator() override final;
 
     // interface to give access to the datafacades
-    storage::DataLayout &GetLayout() override final;
+    const storage::DataLayout &GetLayout() override final;
     char *GetMemory() override final;
 
   private:
+    storage::DataLayout internal_layout;
     std::unique_ptr<char[]> internal_memory;
-    std::unique_ptr<storage::DataLayout> internal_layout;
 };
 
 } // namespace datafacade
diff --git a/include/engine/datafacade/shared_memory_allocator.hpp b/include/engine/datafacade/shared_memory_allocator.hpp
index f69c6f09edf..e201e4ee483 100644
--- a/include/engine/datafacade/shared_memory_allocator.hpp
+++ b/include/engine/datafacade/shared_memory_allocator.hpp
@@ -27,10 +27,12 @@ class SharedMemoryAllocator : public ContiguousBlockAllocator
     ~SharedMemoryAllocator() override final;
 
     // interface to give access to the datafacades
-    storage::DataLayout &GetLayout() override final;
+    const storage::DataLayout &GetLayout() override final;
     char *GetMemory() override final;
 
   private:
+    std::size_t layout_size;
+    storage::DataLayout data_layout;
     std::unique_ptr<storage::SharedMemory> m_large_memory;
 };
 
diff --git a/include/engine/datafacade_factory.hpp b/include/engine/datafacade_factory.hpp
index 92efcf7ee9e..44e1a1f85c7 100644
--- a/include/engine/datafacade_factory.hpp
+++ b/include/engine/datafacade_factory.hpp
@@ -33,6 +33,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator)
         : DataFacadeFactory(allocator, has_exclude_flags)
     {
+        BOOST_ASSERT_MSG(facades.size() >= 1, "At least one datafacade is needed");
     }
 
     template <typename ParameterT> std::shared_ptr<const Facade> Get(const ParameterT &params) const
@@ -45,13 +46,34 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     template <typename AllocatorT>
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator, std::true_type)
     {
-        for (const auto index : util::irange<std::size_t>(0, facades.size()))
+        const auto &layout = allocator->GetLayout();
+        properties = layout.template GetBlockPtr<extractor::ProfileProperties>(
+            allocator->GetMemory(), "/common/properties");
+        const auto &metric_name = properties->GetWeightName();
+
+        std::vector<std::string> exclude_prefixes;
+        auto exclude_path = std::string("/") + routing_algorithms::identifier<AlgorithmT>() +
+                            std::string("/metrics/") + metric_name + "/exclude/";
+        layout.List(exclude_path, std::back_inserter(exclude_prefixes));
+        facades.resize(exclude_prefixes.size());
+
+        if (facades.empty())
         {
-            facades[index] = std::make_shared<const Facade>(allocator, index);
+            throw util::exception(std::string("Could not find any metrics for ") +
+                                  routing_algorithms::name<AlgorithmT>() +
+                                  " in the data. Did you load the right dataset?");
         }
 
-        properties = allocator->GetLayout().template GetBlockPtr<extractor::ProfileProperties>(
-            allocator->GetMemory(), storage::DataLayout::PROPERTIES);
+        for (const auto &exclude_prefix : exclude_prefixes)
+        {
+            auto index_begin = exclude_prefix.find_last_of("/");
+            BOOST_ASSERT_MSG(index_begin != std::string::npos,
+                             "The exclude prefix needs to be a valid data path.");
+            std::size_t index =
+                std::stoi(exclude_prefix.substr(index_begin + 1, exclude_prefix.size()));
+            BOOST_ASSERT(index >= 0 && index < facades.size());
+            facades[index] = std::make_shared<const Facade>(allocator, metric_name, index);
+        }
 
         for (const auto index : util::irange<std::size_t>(0, properties->class_names.size()))
         {
@@ -67,7 +89,11 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     template <typename AllocatorT>
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator, std::false_type)
     {
-        facades[0] = std::make_shared<const Facade>(allocator, 0);
+        const auto &layout = allocator->GetLayout();
+        properties = layout.template GetBlockPtr<extractor::ProfileProperties>(
+            allocator->GetMemory(), "/common/properties");
+        const auto &metric_name = properties->GetWeightName();
+        facades.push_back(std::make_shared<const Facade>(allocator, metric_name, 0));
     }
 
     std::shared_ptr<const Facade> Get(const api::TileParameters &, std::false_type) const
@@ -124,7 +150,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
         return {};
     }
 
-    std::array<std::shared_ptr<const Facade>, extractor::MAX_EXCLUDABLE_CLASSES> facades;
+    std::vector<std::shared_ptr<const Facade>> facades;
     std::unordered_map<std::string, extractor::ClassData> name_to_class;
     const extractor::ProfileProperties *properties = nullptr;
 };
diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index 6e49138e209..97cd65b0251 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -7,8 +7,6 @@
 #include "engine/api/table_parameters.hpp"
 #include "engine/api/tile_parameters.hpp"
 #include "engine/api/trip_parameters.hpp"
-#include "engine/data_watchdog.hpp"
-#include "engine/datafacade/contiguous_block_allocator.hpp"
 #include "engine/datafacade_provider.hpp"
 #include "engine/engine_config.hpp"
 #include "engine/plugins/match.hpp"
@@ -19,9 +17,7 @@
 #include "engine/plugins/viaroute.hpp"
 #include "engine/routing_algorithms.hpp"
 #include "engine/status.hpp"
-#include "util/exception.hpp"
-#include "util/exception_utils.hpp"
-#include "util/fingerprint.hpp"
+
 #include "util/json_container.hpp"
 
 #include <memory>
@@ -123,8 +119,6 @@ template <typename Algorithm> class Engine final : public EngineInterface
         return tile_plugin.HandleRequest(GetAlgorithms(params), params, result);
     }
 
-    static bool CheckCompatibility(const EngineConfig &config);
-
   private:
     template <typename ParametersT> auto GetAlgorithms(const ParametersT &params) const
     {
@@ -140,62 +134,6 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::MatchPlugin match_plugin;
     const plugins::TilePlugin tile_plugin;
 };
-
-template <>
-bool Engine<routing_algorithms::ch::Algorithm>::CheckCompatibility(const EngineConfig &config)
-{
-    if (config.use_shared_memory)
-    {
-        storage::SharedMonitor<storage::SharedDataTimestamp> barrier;
-        using mutex_type = typename decltype(barrier)::mutex_type;
-        boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());
-
-        auto mem = storage::makeSharedMemory(barrier.data().region);
-        auto layout = reinterpret_cast<storage::DataLayout *>(mem->Ptr());
-        return layout->GetBlockSize(storage::DataLayout::CH_GRAPH_NODE_LIST) > 4 &&
-               layout->GetBlockSize(storage::DataLayout::CH_GRAPH_EDGE_LIST) > 4;
-    }
-    else
-    {
-        return boost::filesystem::exists(config.storage_config.GetPath(".osrm.hsgr"));
-    }
-}
-
-template <>
-bool Engine<routing_algorithms::mld::Algorithm>::CheckCompatibility(const EngineConfig &config)
-{
-    if (config.use_shared_memory)
-    {
-        storage::SharedMonitor<storage::SharedDataTimestamp> barrier;
-        using mutex_type = typename decltype(barrier)::mutex_type;
-        boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());
-
-        auto mem = storage::makeSharedMemory(barrier.data().region);
-        auto layout = reinterpret_cast<storage::DataLayout *>(mem->Ptr());
-        // checks that all the needed memory blocks are populated
-        // DataLayout::MLD_CELL_SOURCE_BOUNDARY and DataLayout::MLD_CELL_DESTINATION_BOUNDARY
-        // are not checked, because in situations where there are so few nodes in the graph that
-        // they all fit into one cell, they can be empty.
-        bool empty_data = layout->GetBlockSize(storage::DataLayout::MLD_LEVEL_DATA) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_PARTITION) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_CELLS) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_GRAPH_NODE_LIST) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_GRAPH_EDGE_LIST) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_CELL_WEIGHTS_0) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_CELL_DURATIONS_0) > 0 &&
-                          layout->GetBlockSize(storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET) > 0;
-        return empty_data;
-    }
-    else
-    {
-        return boost::filesystem::exists(config.storage_config.GetPath(".osrm.partition")) &&
-               boost::filesystem::exists(config.storage_config.GetPath(".osrm.cells")) &&
-               boost::filesystem::exists(config.storage_config.GetPath(".osrm.mldgr")) &&
-               boost::filesystem::exists(config.storage_config.GetPath(".osrm.cell_metrics"));
-    }
-}
 }
 }
 
diff --git a/include/extractor/files.hpp b/include/extractor/files.hpp
index 9fa805f6bc0..34ac91c627c 100644
--- a/include/extractor/files.hpp
+++ b/include/extractor/files.hpp
@@ -122,8 +122,8 @@ inline void readNodes(const boost::filesystem::path &path,
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
 
-    storage::serialization::read(reader, "/common/coordinates", coordinates);
-    util::serialization::read(reader, "/common/osm_node_ids", osm_node_ids);
+    storage::serialization::read(reader, "/common/nbn_data/coordinates", coordinates);
+    util::serialization::read(reader, "/common/nbn_data/osm_node_ids", osm_node_ids);
 }
 
 // reads only coordinates from .osrm.nbg_nodes
@@ -135,7 +135,7 @@ inline void readNodeCoordinates(const boost::filesystem::path &path, Coordinates
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
 
-    storage::serialization::read(reader, "/common/coordinates", coordinates);
+    storage::serialization::read(reader, "/common/nbn_data/coordinates", coordinates);
 }
 
 // writes .osrm.nbg_nodes
@@ -150,8 +150,8 @@ inline void writeNodes(const boost::filesystem::path &path,
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
 
-    storage::serialization::write(writer, "/common/coordinates", coordinates);
-    util::serialization::write(writer, "/common/osm_node_ids", osm_node_ids);
+    storage::serialization::write(writer, "/common/nbn_data/coordinates", coordinates);
+    util::serialization::write(writer, "/common/nbn_data/osm_node_ids", osm_node_ids);
 }
 
 // reads .osrm.cnbg_to_ebg
diff --git a/include/guidance/files.hpp b/include/guidance/files.hpp
index 5fd77479d24..c0d1f54e294 100644
--- a/include/guidance/files.hpp
+++ b/include/guidance/files.hpp
@@ -30,7 +30,8 @@ inline void readTurnData(const boost::filesystem::path &path,
     const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
     storage::tar::FileReader reader{path, fingerprint};
 
-    serialization::read(reader, "/common/turn_data", turn_data, connectivity_checksum);
+    reader.ReadInto("/common/connectivity_checksum", connectivity_checksum);
+    serialization::read(reader, "/common/turn_data", turn_data);
 }
 
 // writes .osrm.edges
@@ -46,7 +47,9 @@ inline void writeTurnData(const boost::filesystem::path &path,
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
 
-    serialization::write(writer, "/common/turn_data", turn_data, connectivity_checksum);
+    writer.WriteElementCount64("/common/connectivity_checksum", 1);
+    writer.WriteFrom("/common/connectivity_checksum", connectivity_checksum);
+    serialization::write(writer, "/common/turn_data", turn_data);
 }
 }
 }
diff --git a/include/guidance/serialization.hpp b/include/guidance/serialization.hpp
index 2b8ac66f496..6917cb02e5d 100644
--- a/include/guidance/serialization.hpp
+++ b/include/guidance/serialization.hpp
@@ -19,8 +19,7 @@ namespace serialization
 template <storage::Ownership Ownership>
 inline void read(storage::tar::FileReader &reader,
                  const std::string &name,
-                 guidance::detail::TurnDataContainerImpl<Ownership> &turn_data_container,
-                 std::uint32_t &connectivity_checksum)
+                 guidance::detail::TurnDataContainerImpl<Ownership> &turn_data_container)
 {
     storage::serialization::read(
         reader, name + "/turn_instructions", turn_data_container.turn_instructions);
@@ -32,14 +31,12 @@ inline void read(storage::tar::FileReader &reader,
         reader, name + "/pre_turn_bearings", turn_data_container.pre_turn_bearings);
     storage::serialization::read(
         reader, name + "/post_turn_bearings", turn_data_container.post_turn_bearings);
-    reader.ReadInto(name + "/connectivity_checksum", connectivity_checksum);
 }
 
 template <storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
-                  const guidance::detail::TurnDataContainerImpl<Ownership> &turn_data_container,
-                  const std::uint32_t connectivity_checksum)
+                  const guidance::detail::TurnDataContainerImpl<Ownership> &turn_data_container)
 {
     storage::serialization::write(
         writer, name + "/turn_instructions", turn_data_container.turn_instructions);
@@ -51,8 +48,6 @@ inline void write(storage::tar::FileWriter &writer,
         writer, name + "/pre_turn_bearings", turn_data_container.pre_turn_bearings);
     storage::serialization::write(
         writer, name + "/post_turn_bearings", turn_data_container.post_turn_bearings);
-    writer.WriteElementCount64(name + "/connectivity_checksum", 1);
-    writer.WriteFrom(name + "/connectivity_checksum", connectivity_checksum);
 }
 }
 }
diff --git a/include/guidance/turn_data_container.hpp b/include/guidance/turn_data_container.hpp
index 2f4b68643f8..ae4ecc1737e 100644
--- a/include/guidance/turn_data_container.hpp
+++ b/include/guidance/turn_data_container.hpp
@@ -26,14 +26,12 @@ namespace serialization
 template <storage::Ownership Ownership>
 void read(storage::tar::FileReader &reader,
           const std::string &name,
-          detail::TurnDataContainerImpl<Ownership> &turn_data,
-          std::uint32_t &connectivity_checksum);
+          detail::TurnDataContainerImpl<Ownership> &turn_data);
 
 template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
-           const detail::TurnDataContainerImpl<Ownership> &turn_data,
-           const std::uint32_t connectivity_checksum);
+           const detail::TurnDataContainerImpl<Ownership> &turn_data);
 }
 
 struct TurnData
@@ -101,12 +99,10 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
 
     friend void serialization::read<Ownership>(storage::tar::FileReader &reader,
                                                const std::string &name,
-                                               TurnDataContainerImpl &turn_data_container,
-                                               std::uint32_t &connectivity_checksum);
+                                               TurnDataContainerImpl &turn_data_container);
     friend void serialization::write<Ownership>(storage::tar::FileWriter &writer,
                                                 const std::string &name,
-                                                const TurnDataContainerImpl &turn_data_container,
-                                                const std::uint32_t connectivity_checksum);
+                                                const TurnDataContainerImpl &turn_data_container);
 
   private:
     Vector<TurnInstruction> turn_instructions;
diff --git a/include/partitioner/files.hpp b/include/partitioner/files.hpp
index 0414ee3c83c..3a85a8fb0f7 100644
--- a/include/partitioner/files.hpp
+++ b/include/partitioner/files.hpp
@@ -26,7 +26,8 @@ inline void readGraph(const boost::filesystem::path &path,
 
     storage::tar::FileReader reader{path, storage::tar::FileReader::VerifyFingerprint};
 
-    serialization::read(reader, "/mld/multilevelgraph", graph, connectivity_checksum);
+    reader.ReadInto("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::read(reader, "/mld/multilevelgraph", graph);
 }
 
 // writes .osrm.mldgr file
@@ -41,7 +42,9 @@ inline void writeGraph(const boost::filesystem::path &path,
 
     storage::tar::FileWriter writer{path, storage::tar::FileWriter::GenerateFingerprint};
 
-    serialization::write(writer, "/mld/multilevelgraph", graph, connectivity_checksum);
+    writer.WriteElementCount64("/mld/connectivity_checksum", 1);
+    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::write(writer, "/mld/multilevelgraph", graph);
 }
 
 // read .osrm.partition file
diff --git a/include/partitioner/multi_level_graph.hpp b/include/partitioner/multi_level_graph.hpp
index 4b952b4608e..2c8c7204cba 100644
--- a/include/partitioner/multi_level_graph.hpp
+++ b/include/partitioner/multi_level_graph.hpp
@@ -26,14 +26,12 @@ namespace serialization
 template <typename EdgeDataT, storage::Ownership Ownership>
 void read(storage::tar::FileReader &reader,
           const std::string &name,
-          MultiLevelGraph<EdgeDataT, Ownership> &graph,
-          std::uint32_t &connectivity_checksum);
+          MultiLevelGraph<EdgeDataT, Ownership> &graph);
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
-           const MultiLevelGraph<EdgeDataT, Ownership> &graph,
-           const std::uint32_t connectivity_checksum);
+           const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 }
 
 template <typename EdgeDataT, storage::Ownership Ownership>
@@ -206,13 +204,11 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
     friend void
     serialization::read<EdgeDataT, Ownership>(storage::tar::FileReader &reader,
                                               const std::string &name,
-                                              MultiLevelGraph<EdgeDataT, Ownership> &graph,
-                                              std::uint32_t &connectivity_checksum);
+                                              MultiLevelGraph<EdgeDataT, Ownership> &graph);
     friend void
     serialization::write<EdgeDataT, Ownership>(storage::tar::FileWriter &writer,
                                                const std::string &name,
-                                               const MultiLevelGraph<EdgeDataT, Ownership> &graph,
-                                               const std::uint32_t connectivity_checksum);
+                                               const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 
     Vector<EdgeOffset> node_to_edge_offset;
     std::uint32_t connectivity_checksum;
diff --git a/include/partitioner/serialization.hpp b/include/partitioner/serialization.hpp
index 4fefefa7b7a..b8d57bb6dbc 100644
--- a/include/partitioner/serialization.hpp
+++ b/include/partitioner/serialization.hpp
@@ -22,26 +22,21 @@ namespace serialization
 template <typename EdgeDataT, storage::Ownership Ownership>
 inline void read(storage::tar::FileReader &reader,
                  const std::string &name,
-                 MultiLevelGraph<EdgeDataT, Ownership> &graph,
-                 std::uint32_t &connectivity_checksum)
+                 MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
     storage::serialization::read(reader, name + "/node_array", graph.node_array);
     storage::serialization::read(reader, name + "/edge_array", graph.edge_array);
     storage::serialization::read(reader, name + "/node_to_edge_offset", graph.node_to_edge_offset);
-    reader.ReadInto(name + "/connectivity_checksum", connectivity_checksum);
 }
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
-                  const MultiLevelGraph<EdgeDataT, Ownership> &graph,
-                  const std::uint32_t connectivity_checksum)
+                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
     storage::serialization::write(writer, name + "/node_array", graph.node_array);
     storage::serialization::write(writer, name + "/edge_array", graph.edge_array);
     storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
-    writer.WriteElementCount64(name + "/connectivity_checksum", 1);
-    writer.WriteFrom(name + "/connectivity_checksum", connectivity_checksum);
 }
 
 template <storage::Ownership Ownership>
diff --git a/include/storage/io.hpp b/include/storage/io.hpp
index eadf93e9bb4..7702c0ddb77 100644
--- a/include/storage/io.hpp
+++ b/include/storage/io.hpp
@@ -11,7 +11,9 @@
 #include "util/version.hpp"
 
 #include <boost/filesystem/fstream.hpp>
+#include <boost/iostreams/device/array.hpp>
 #include <boost/iostreams/seek.hpp>
+#include <boost/iostreams/stream.hpp>
 
 #include <cerrno>
 #include <cstring>
@@ -294,7 +296,10 @@ class FileWriter
 class BufferReader
 {
   public:
-    BufferReader(const std::string &buffer) : input_stream(buffer, std::ios::binary)
+    BufferReader(const std::string &buffer) : BufferReader(buffer.data(), buffer.size()) {}
+
+    BufferReader(const char *buffer, const std::size_t size)
+        : input_stream(boost::iostreams::array_source(buffer, size))
     {
         if (!input_stream)
         {
@@ -303,6 +308,8 @@ class BufferReader
         }
     }
 
+    std::size_t GetPosition() { return input_stream.tellg(); }
+
     template <typename T> void ReadInto(T *dest, const std::size_t count)
     {
 #if !defined(__GNUC__) || (__GNUC__ > 4)
@@ -338,7 +345,7 @@ class BufferReader
     }
 
   private:
-    std::istringstream input_stream;
+    boost::iostreams::stream<boost::iostreams::array_source> input_stream;
 };
 
 class BufferWriter
diff --git a/include/storage/serialization.hpp b/include/storage/serialization.hpp
index 35a4d1a7759..92ee9600c0d 100644
--- a/include/storage/serialization.hpp
+++ b/include/storage/serialization.hpp
@@ -6,6 +6,7 @@
 #include "util/vector_view.hpp"
 
 #include "storage/io.hpp"
+#include "storage/shared_datatype.hpp"
 #include "storage/tar.hpp"
 
 #include <boost/function_output_iterator.hpp>
@@ -13,6 +14,7 @@
 
 #include <cmath>
 #include <cstdint>
+#include <tuple>
 
 #if USE_STXXL_LIBRARY
 #include <stxxl/vector>
@@ -25,6 +27,71 @@ namespace storage
 namespace serialization
 {
 
+namespace detail
+{
+template <typename T, typename BlockT = unsigned char>
+inline BlockT packBits(const T &data, std::size_t index, std::size_t count)
+{
+    static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
+    BlockT value = 0;
+    for (std::size_t bit = 0; bit < count; ++bit, ++index)
+        value = (value << 1) | data[index];
+    return value;
+}
+
+template <typename T, typename BlockT = unsigned char>
+inline void unpackBits(T &data, std::size_t index, std::size_t count, BlockT value)
+{
+    static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
+    const BlockT mask = BlockT{1} << (count - 1);
+    for (std::size_t bit = 0; bit < count; value <<= 1, ++bit, ++index)
+        data[index] = value & mask;
+}
+
+template <typename VectorT>
+void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &data)
+{
+    const auto count = reader.ReadElementCount64(name);
+    data.resize(count);
+    std::uint64_t index = 0;
+
+    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
+
+    const auto decode = [&](const std::uint64_t block) {
+        auto read_size = std::min<std::size_t>(count - index, WORD_BITS);
+        unpackBits<VectorT, std::uint64_t>(data, index, read_size, block);
+        index += WORD_BITS;
+    };
+
+    reader.ReadStreaming<std::uint64_t>(name, boost::make_function_output_iterator(decode));
+}
+
+template <typename VectorT>
+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;
+
+    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
+
+    // FIXME on old boost version the function_input_iterator does not work with lambdas
+    // so we need to wrap it in a function here.
+    const std::function<std::uint64_t()> encode_function = [&]() -> std::uint64_t {
+        auto write_size = std::min<std::size_t>(count - index, WORD_BITS);
+        auto packed = packBits<VectorT, std::uint64_t>(data, index, write_size);
+        index += WORD_BITS;
+        return packed;
+    };
+
+    std::uint64_t number_of_blocks = (count + WORD_BITS - 1) / WORD_BITS;
+    writer.WriteStreaming<std::uint64_t>(
+        name,
+        boost::make_function_input_iterator(encode_function, boost::infinite()),
+        number_of_blocks);
+}
+}
+
 /* All vector formats here use the same on-disk format.
  * This is important because we want to be able to write from a vector
  * of one kind, but read it into a vector of another kind.
@@ -81,6 +148,27 @@ template <typename T> void write(io::BufferWriter &writer, const std::vector<T>
     writer.WriteFrom(data.data(), count);
 }
 
+template <typename T> inline void write(io::BufferWriter &writer, const T &data)
+{
+    writer.WriteFrom(data);
+}
+
+template <typename T> inline void read(io::BufferReader &reader, T &data) { reader.ReadInto(data); }
+
+inline void write(io::BufferWriter &writer, const std::string &data)
+{
+    const auto count = data.size();
+    writer.WriteElementCount64(count);
+    writer.WriteFrom(data.data(), count);
+}
+
+inline void read(io::BufferReader &reader, std::string &data)
+{
+    const auto count = reader.ReadElementCount64();
+    data.resize(count);
+    reader.ReadInto(const_cast<char *>(data.data()), count);
+}
+
 inline void write(tar::FileWriter &writer, const std::string &name, const std::string &data)
 {
     const auto count = data.size();
@@ -127,71 +215,6 @@ void write(tar::FileWriter &writer, const std::string &name, const util::vector_
     writer.WriteFrom(name, data.data(), count);
 }
 
-namespace detail
-{
-template <typename T, typename BlockT = unsigned char>
-inline BlockT packBits(const T &data, std::size_t index, std::size_t count)
-{
-    static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
-    BlockT value = 0;
-    for (std::size_t bit = 0; bit < count; ++bit, ++index)
-        value = (value << 1) | data[index];
-    return value;
-}
-
-template <typename T, typename BlockT = unsigned char>
-inline void unpackBits(T &data, std::size_t index, std::size_t count, BlockT value)
-{
-    static_assert(std::is_same<typename T::value_type, bool>::value, "value_type is not bool");
-    const BlockT mask = BlockT{1} << (count - 1);
-    for (std::size_t bit = 0; bit < count; value <<= 1, ++bit, ++index)
-        data[index] = value & mask;
-}
-
-template <typename VectorT>
-void readBoolVector(tar::FileReader &reader, const std::string &name, VectorT &data)
-{
-    const auto count = reader.ReadElementCount64(name);
-    data.resize(count);
-    std::uint64_t index = 0;
-
-    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
-
-    const auto decode = [&](const std::uint64_t block) {
-        auto read_size = std::min<std::size_t>(count - index, WORD_BITS);
-        unpackBits<VectorT, std::uint64_t>(data, index, read_size, block);
-        index += WORD_BITS;
-    };
-
-    reader.ReadStreaming<std::uint64_t>(name, boost::make_function_output_iterator(decode));
-}
-
-template <typename VectorT>
-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;
-
-    constexpr std::uint64_t WORD_BITS = CHAR_BIT * sizeof(std::uint64_t);
-
-    // FIXME on old boost version the function_input_iterator does not work with lambdas
-    // so we need to wrap it in a function here.
-    const std::function<std::uint64_t()> encode_function = [&]() -> std::uint64_t {
-        auto write_size = std::min<std::size_t>(count - index, WORD_BITS);
-        auto packed = packBits<VectorT, std::uint64_t>(data, index, write_size);
-        index += WORD_BITS;
-        return packed;
-    };
-
-    std::uint64_t number_of_blocks = (count + WORD_BITS - 1) / WORD_BITS;
-    writer.WriteStreaming<std::uint64_t>(
-        name,
-        boost::make_function_input_iterator(encode_function, boost::infinite()),
-        number_of_blocks);
-}
-}
-
 template <>
 inline void
 read<bool>(tar::FileReader &reader, const std::string &name, util::vector_view<bool> &data)
@@ -218,6 +241,37 @@ write<bool>(tar::FileWriter &writer, const std::string &name, const std::vector<
 {
     detail::writeBoolVector(writer, name, data);
 }
+
+template <typename K, typename V> void read(io::BufferReader &reader, std::map<K, V> &data)
+{
+    const auto count = reader.ReadElementCount64();
+    for (auto index : util::irange<std::size_t>(0, count))
+    {
+        (void)index;
+        std::pair<K, V> pair;
+        read(reader, pair.first);
+        read(reader, pair.second);
+        data.insert(pair);
+    }
+}
+
+template <typename K, typename V> void write(io::BufferWriter &writer, const std::map<K, V> &data)
+{
+    const auto count = data.size();
+    writer.WriteElementCount64(count);
+    for (const auto &pair : data)
+    {
+        write(writer, pair.first);
+        write(writer, pair.second);
+    }
+}
+
+inline void read(io::BufferReader &reader, DataLayout &layout) { read(reader, layout.blocks); }
+
+inline void write(io::BufferWriter &writer, const DataLayout &layout)
+{
+    write(writer, layout.blocks);
+}
 }
 }
 }
diff --git a/include/storage/shared_datatype.hpp b/include/storage/shared_datatype.hpp
index 56e6c99ba65..7c3e561d387 100644
--- a/include/storage/shared_datatype.hpp
+++ b/include/storage/shared_datatype.hpp
@@ -2,6 +2,7 @@
 #define SHARED_DATA_TYPE_HPP
 
 #include "storage/block.hpp"
+#include "storage/io_fwd.hpp"
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
@@ -11,226 +12,124 @@
 
 #include <array>
 #include <cstdint>
+#include <map>
+#include <unordered_set>
 
 namespace osrm
 {
 namespace storage
 {
 
-// Added at the start and end of each block as sanity check
-const constexpr char CANARY[4] = {'O', 'S', 'R', 'M'};
-
-const constexpr char *block_id_to_name[] = {"IGNORE_BLOCK",
-                                            "NAME_BLOCKS",
-                                            "NAME_VALUES",
-                                            "EDGE_BASED_NODE_DATA",
-                                            "ANNOTATION_DATA",
-                                            "CH_GRAPH_NODE_LIST",
-                                            "CH_GRAPH_EDGE_LIST",
-                                            "CH_EDGE_FILTER_0",
-                                            "CH_EDGE_FILTER_1",
-                                            "CH_EDGE_FILTER_2",
-                                            "CH_EDGE_FILTER_3",
-                                            "CH_EDGE_FILTER_4",
-                                            "CH_EDGE_FILTER_5",
-                                            "CH_EDGE_FILTER_6",
-                                            "CH_EDGE_FILTER_7",
-                                            "COORDINATE_LIST",
-                                            "OSM_NODE_ID_LIST",
-                                            "TURN_INSTRUCTION",
-                                            "ENTRY_CLASSID",
-                                            "R_SEARCH_TREE",
-                                            "R_SEARCH_TREE_LEVEL_STARTS",
-                                            "GEOMETRIES_INDEX",
-                                            "GEOMETRIES_NODE_LIST",
-                                            "GEOMETRIES_FWD_WEIGHT_LIST",
-                                            "GEOMETRIES_REV_WEIGHT_LIST",
-                                            "GEOMETRIES_FWD_DURATION_LIST",
-                                            "GEOMETRIES_REV_DURATION_LIST",
-                                            "GEOMETRIES_FWD_DATASOURCES_LIST",
-                                            "GEOMETRIES_REV_DATASOURCES_LIST",
-                                            "HSGR_CHECKSUM",
-                                            "FILE_INDEX_PATH",
-                                            "DATASOURCES_NAMES",
-                                            "PROPERTIES",
-                                            "BEARING_CLASSID",
-                                            "BEARING_OFFSETS",
-                                            "BEARING_BLOCKS",
-                                            "BEARING_VALUES",
-                                            "ENTRY_CLASS",
-                                            "LANE_DATA_ID",
-                                            "PRE_TURN_BEARING",
-                                            "POST_TURN_BEARING",
-                                            "TURN_LANE_DATA",
-                                            "LANE_DESCRIPTION_OFFSETS",
-                                            "LANE_DESCRIPTION_MASKS",
-                                            "TURN_WEIGHT_PENALTIES",
-                                            "TURN_DURATION_PENALTIES",
-                                            "MLD_LEVEL_DATA",
-                                            "MLD_PARTITION",
-                                            "MLD_CELL_TO_CHILDREN",
-                                            "MLD_CELL_WEIGHTS_0",
-                                            "MLD_CELL_WEIGHTS_1",
-                                            "MLD_CELL_WEIGHTS_2",
-                                            "MLD_CELL_WEIGHTS_3",
-                                            "MLD_CELL_WEIGHTS_4",
-                                            "MLD_CELL_WEIGHTS_5",
-                                            "MLD_CELL_WEIGHTS_6",
-                                            "MLD_CELL_WEIGHTS_7",
-                                            "MLD_CELL_DURATIONS_0",
-                                            "MLD_CELL_DURATIONS_1",
-                                            "MLD_CELL_DURATIONS_2",
-                                            "MLD_CELL_DURATIONS_3",
-                                            "MLD_CELL_DURATIONS_4",
-                                            "MLD_CELL_DURATIONS_5",
-                                            "MLD_CELL_DURATIONS_6",
-                                            "MLD_CELL_DURATIONS_7",
-                                            "MLD_CELL_SOURCE_BOUNDARY",
-                                            "MLD_CELL_DESTINATION_BOUNDARY",
-                                            "MLD_CELLS",
-                                            "MLD_CELL_LEVEL_OFFSETS",
-                                            "MLD_GRAPH_NODE_LIST",
-                                            "MLD_GRAPH_EDGE_LIST",
-                                            "MLD_GRAPH_NODE_TO_OFFSET",
-                                            "MANEUVER_OVERRIDES",
-                                            "MANEUVER_OVERRIDE_NODE_SEQUENCES"};
+class DataLayout;
+namespace serialization
+{
+inline void read(io::BufferReader &reader, DataLayout &layout);
 
-class DataLayout
+inline void write(io::BufferWriter &writer, const DataLayout &layout);
+}
+
+namespace detail
 {
-  public:
-    enum BlockID
+// Removes the file name if name_prefix is a directory and name is not a file in that directory
+inline std::string trimName(const std::string &name_prefix, const std::string &name)
+{
+    // list directory and
+    if (!name_prefix.empty() && name_prefix.back() == '/')
+    {
+        auto directory_position = name.find_first_of("/", name_prefix.length());
+        // this is a "file" in the directory of name_prefix
+        if (directory_position == std::string::npos)
+        {
+            return name;
+        }
+        else
+        {
+            return name.substr(0, directory_position);
+        }
+    }
+    else
     {
-        IGNORE_BLOCK = 0,
-        NAME_BLOCKS,
-        NAME_VALUES,
-        EDGE_BASED_NODE_DATA_LIST,
-        ANNOTATION_DATA_LIST,
-        CH_GRAPH_NODE_LIST,
-        CH_GRAPH_EDGE_LIST,
-        CH_EDGE_FILTER_0,
-        CH_EDGE_FILTER_1,
-        CH_EDGE_FILTER_2,
-        CH_EDGE_FILTER_3,
-        CH_EDGE_FILTER_4,
-        CH_EDGE_FILTER_5,
-        CH_EDGE_FILTER_6,
-        CH_EDGE_FILTER_7,
-        COORDINATE_LIST,
-        OSM_NODE_ID_LIST,
-        TURN_INSTRUCTION,
-        ENTRY_CLASSID,
-        R_SEARCH_TREE,
-        R_SEARCH_TREE_LEVEL_STARTS,
-        GEOMETRIES_INDEX,
-        GEOMETRIES_NODE_LIST,
-        GEOMETRIES_FWD_WEIGHT_LIST,
-        GEOMETRIES_REV_WEIGHT_LIST,
-        GEOMETRIES_FWD_DURATION_LIST,
-        GEOMETRIES_REV_DURATION_LIST,
-        GEOMETRIES_FWD_DATASOURCES_LIST,
-        GEOMETRIES_REV_DATASOURCES_LIST,
-        HSGR_CHECKSUM,
-        FILE_INDEX_PATH,
-        DATASOURCES_NAMES,
-        PROPERTIES,
-        BEARING_CLASSID,
-        BEARING_OFFSETS,
-        BEARING_BLOCKS,
-        BEARING_VALUES,
-        ENTRY_CLASS,
-        LANE_DATA_ID,
-        PRE_TURN_BEARING,
-        POST_TURN_BEARING,
-        TURN_LANE_DATA,
-        LANE_DESCRIPTION_OFFSETS,
-        LANE_DESCRIPTION_MASKS,
-        TURN_WEIGHT_PENALTIES,
-        TURN_DURATION_PENALTIES,
-        MLD_LEVEL_DATA,
-        MLD_PARTITION,
-        MLD_CELL_TO_CHILDREN,
-        MLD_CELL_WEIGHTS_0,
-        MLD_CELL_WEIGHTS_1,
-        MLD_CELL_WEIGHTS_2,
-        MLD_CELL_WEIGHTS_3,
-        MLD_CELL_WEIGHTS_4,
-        MLD_CELL_WEIGHTS_5,
-        MLD_CELL_WEIGHTS_6,
-        MLD_CELL_WEIGHTS_7,
-        MLD_CELL_DURATIONS_0,
-        MLD_CELL_DURATIONS_1,
-        MLD_CELL_DURATIONS_2,
-        MLD_CELL_DURATIONS_3,
-        MLD_CELL_DURATIONS_4,
-        MLD_CELL_DURATIONS_5,
-        MLD_CELL_DURATIONS_6,
-        MLD_CELL_DURATIONS_7,
-        MLD_CELL_SOURCE_BOUNDARY,
-        MLD_CELL_DESTINATION_BOUNDARY,
-        MLD_CELLS,
-        MLD_CELL_LEVEL_OFFSETS,
-        MLD_GRAPH_NODE_LIST,
-        MLD_GRAPH_EDGE_LIST,
-        MLD_GRAPH_NODE_TO_OFFSET,
-        MANEUVER_OVERRIDES,
-        MANEUVER_OVERRIDE_NODE_SEQUENCES,
-        NUM_BLOCKS
-    };
+        return name;
+    }
+}
+}
 
+class DataLayout
+{
+  public:
     DataLayout() : blocks{} {}
 
-    inline void SetBlock(BlockID bid, Block block) { blocks[bid] = std::move(block); }
+    inline void SetBlock(const std::string &name, Block block) { blocks[name] = std::move(block); }
 
-    inline uint64_t GetBlockEntries(BlockID bid) const { return blocks[bid].num_entries; }
+    inline uint64_t GetBlockEntries(const std::string &name) const
+    {
+        return GetBlock(name).num_entries;
+    }
+
+    inline uint64_t GetBlockSize(const std::string &name) const { return GetBlock(name).byte_size; }
 
-    inline uint64_t GetBlockSize(BlockID bid) const { return blocks[bid].byte_size; }
+    inline bool HasBlock(const std::string &name) const
+    {
+        return blocks.find(name) != blocks.end();
+    }
 
     inline uint64_t GetSizeOfLayout() const
     {
         uint64_t result = 0;
-        for (auto i = 0; i < NUM_BLOCKS; i++)
+        for (const auto &name_and_block : blocks)
         {
-            result += 2 * sizeof(CANARY) + GetBlockSize(static_cast<BlockID>(i)) + BLOCK_ALIGNMENT;
+            result += GetBlockSize(name_and_block.first) + BLOCK_ALIGNMENT;
         }
         return result;
     }
 
-    template <typename T, bool WRITE_CANARY = false>
-    inline T *GetBlockPtr(char *shared_memory, BlockID bid) const
+    template <typename T> inline T *GetBlockPtr(char *shared_memory, const std::string &name) const
     {
         static_assert(BLOCK_ALIGNMENT % std::alignment_of<T>::value == 0,
                       "Datatype does not fit alignment constraints.");
 
-        char *ptr = (char *)GetAlignedBlockPtr(shared_memory, bid);
-        if (WRITE_CANARY)
-        {
-            char *start_canary_ptr = ptr - sizeof(CANARY);
-            char *end_canary_ptr = ptr + GetBlockSize(bid);
-            std::copy(CANARY, CANARY + sizeof(CANARY), start_canary_ptr);
-            std::copy(CANARY, CANARY + sizeof(CANARY), end_canary_ptr);
-        }
-        else
+        char *ptr = (char *)GetAlignedBlockPtr(shared_memory, name);
+        return (T *)ptr;
+    }
+
+    // Depending on the name prefix this function either lists all blocks with the same prefix
+    // or all entries in the sub-directory.
+    // '/ch/edge' -> '/ch/edge_filter/0/blocks', '/ch/edge_filter/1/blocks'
+    // '/ch/edge_filters/' -> '/ch/edge_filter/0', '/ch/edge_filter/1'
+    template <typename OutIter> void List(const std::string &name_prefix, OutIter out) const
+    {
+        std::unordered_set<std::string> returned_name;
+
+        for (const auto &pair : blocks)
         {
-            char *start_canary_ptr = ptr - sizeof(CANARY);
-            char *end_canary_ptr = ptr + GetBlockSize(bid);
-            bool start_canary_alive = std::equal(CANARY, CANARY + sizeof(CANARY), start_canary_ptr);
-            bool end_canary_alive = std::equal(CANARY, CANARY + sizeof(CANARY), end_canary_ptr);
-            if (!start_canary_alive)
+            // check if string begins with the name prefix
+            if (pair.first.find(name_prefix) == 0)
             {
-                throw util::exception("Start canary of block corrupted. (" +
-                                      std::string(block_id_to_name[bid]) + ")" + SOURCE_REF);
-            }
-            if (!end_canary_alive)
-            {
-                throw util::exception("End canary of block corrupted. (" +
-                                      std::string(block_id_to_name[bid]) + ")" + SOURCE_REF);
+                auto trimmed_name = detail::trimName(name_prefix, pair.first);
+                auto ret = returned_name.insert(trimmed_name);
+                if (ret.second)
+                {
+                    *out++ = trimmed_name;
+                }
             }
         }
-
-        return (T *)ptr;
     }
 
   private:
+    friend void serialization::read(io::BufferReader &reader, DataLayout &layout);
+    friend void serialization::write(io::BufferWriter &writer, const DataLayout &layout);
+
+    const Block &GetBlock(const std::string &name) const
+    {
+        auto iter = blocks.find(name);
+        if (iter == blocks.end())
+        {
+            throw util::exception("Could not find block " + name);
+        }
+
+        return iter->second;
+    }
+
     // Fit aligned storage in buffer to 64 bytes to conform with AVX 512 types
     inline void *align(void *&ptr) const noexcept
     {
@@ -239,29 +138,26 @@ class DataLayout
         return ptr = reinterpret_cast<void *>(aligned);
     }
 
-    inline void *GetAlignedBlockPtr(void *ptr, BlockID bid) const
+    inline void *GetAlignedBlockPtr(void *ptr, const std::string &name) const
     {
-        for (auto i = 0; i < bid; i++)
+        auto block_iter = blocks.find(name);
+        if (block_iter == blocks.end())
+        {
+            throw util::exception("Could not find block " + name);
+        }
+
+        for (auto iter = blocks.begin(); iter != block_iter; ++iter)
         {
-            ptr = static_cast<char *>(ptr) + sizeof(CANARY);
             ptr = align(ptr);
-            ptr = static_cast<char *>(ptr) + GetBlockSize((BlockID)i);
-            ptr = static_cast<char *>(ptr) + sizeof(CANARY);
+            ptr = static_cast<char *>(ptr) + iter->second.byte_size;
         }
 
-        ptr = static_cast<char *>(ptr) + sizeof(CANARY);
         ptr = align(ptr);
         return ptr;
     }
 
-    template <typename T> inline T *GetBlockEnd(char *shared_memory, BlockID bid) const
-    {
-        auto begin = GetBlockPtr<T>(shared_memory, bid);
-        return begin + GetBlockEntries(bid);
-    }
-
     static constexpr std::size_t BLOCK_ALIGNMENT = 64;
-    std::array<Block, NUM_BLOCKS> blocks;
+    std::map<std::string, Block> blocks;
 };
 
 enum SharedDataType
@@ -298,9 +194,6 @@ inline std::string regionToString(const SharedDataType region)
         return "INVALID_REGION";
     }
 }
-
-static_assert(sizeof(block_id_to_name) / sizeof(*block_id_to_name) == DataLayout::NUM_BLOCKS,
-              "Number of blocks needs to match the number of Block names.");
 }
 }
 
diff --git a/include/storage/shared_memory.hpp b/include/storage/shared_memory.hpp
index a3ced80d2e0..86dc3fe556d 100644
--- a/include/storage/shared_memory.hpp
+++ b/include/storage/shared_memory.hpp
@@ -47,6 +47,7 @@ class SharedMemory
 {
   public:
     void *Ptr() const { return region.get_address(); }
+    std::size_t Size() const { return region.get_size(); }
 
     SharedMemory(const SharedMemory &) = delete;
     SharedMemory &operator=(const SharedMemory &) = delete;
@@ -200,6 +201,7 @@ class SharedMemory
 
   public:
     void *Ptr() const { return region.get_address(); }
+    std::size_t Size() const { return region.get_size(); }
 
     SharedMemory(const boost::filesystem::path &lock_file, const int id, const uint64_t size = 0)
     {
diff --git a/include/storage/view_factory.hpp b/include/storage/view_factory.hpp
new file mode 100644
index 00000000000..d39dfbc6255
--- /dev/null
+++ b/include/storage/view_factory.hpp
@@ -0,0 +1,394 @@
+#ifndef OSRM_STOARGE_VIEW_FACTORY_HPP
+#define OSRM_STOARGE_VIEW_FACTORY_HPP
+
+#include "storage/shared_datatype.hpp"
+
+#include "contractor/contracted_metric.hpp"
+#include "contractor/query_graph.hpp"
+
+#include "customizer/edge_based_graph.hpp"
+
+#include "extractor/class_data.hpp"
+#include "extractor/compressed_edge_container.hpp"
+#include "extractor/edge_based_edge.hpp"
+#include "extractor/edge_based_node.hpp"
+#include "extractor/edge_based_node_segment.hpp"
+#include "extractor/maneuver_override.hpp"
+#include "extractor/name_table.hpp"
+#include "extractor/packed_osm_ids.hpp"
+#include "extractor/query_node.hpp"
+#include "extractor/travel_mode.hpp"
+
+#include "guidance/turn_bearing.hpp"
+#include "guidance/turn_data_container.hpp"
+#include "guidance/turn_instruction.hpp"
+
+#include "partitioner/cell_storage.hpp"
+#include "partitioner/edge_based_graph_reader.hpp"
+#include "partitioner/multi_level_partition.hpp"
+
+#include "util/coordinate.hpp"
+#include "util/packed_vector.hpp"
+#include "util/range_table.hpp"
+#include "util/static_graph.hpp"
+#include "util/static_rtree.hpp"
+#include "util/typedefs.hpp"
+#include "util/vector_view.hpp"
+
+#include "util/filtered_graph.hpp"
+#include "util/packed_vector.hpp"
+#include "util/vector_view.hpp"
+
+namespace osrm
+{
+namespace storage
+{
+
+template <typename T>
+util::vector_view<T>
+make_vector_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return util::vector_view<T>(layout.GetBlockPtr<T>(memory_ptr, name),
+                                layout.GetBlockEntries(name));
+}
+
+template <>
+inline util::vector_view<bool>
+make_vector_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return util::vector_view<bool>(
+        layout.GetBlockPtr<util::vector_view<bool>::Word>(memory_ptr, name),
+        layout.GetBlockEntries(name));
+}
+
+template <typename T, std::size_t Bits>
+util::PackedVectorView<T, Bits>
+make_packed_vector_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    using V = util::PackedVectorView<T, Bits>;
+    auto packed_internal = util::vector_view<typename V::block_type>(
+        layout.GetBlockPtr<typename V::block_type>(memory_ptr, name + "/packed"),
+        layout.GetBlockEntries(name + "/packed"));
+    // the real size needs to come from an external source
+    return V{packed_internal, std::numeric_limits<std::size_t>::max()};
+}
+
+inline auto
+make_name_table_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto blocks = make_vector_view<extractor::NameTableView::IndexedData::BlockReference>(
+        memory_ptr, layout, name + "/blocks");
+    auto values = make_vector_view<extractor::NameTableView::IndexedData::ValueType>(
+        memory_ptr, layout, name + "/values");
+
+    extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)};
+    return extractor::NameTableView{index_data_view};
+}
+
+inline auto make_lane_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_vector_view<util::guidance::LaneTupleIdPair>(memory_ptr, layout, name + "/data");
+}
+
+inline auto make_turn_lane_description_views(char *memory_ptr,
+                                             const DataLayout &layout,
+                                             const std::string &name)
+{
+    auto offsets = make_vector_view<std::uint32_t>(memory_ptr, layout, name + "/offsets");
+    auto masks =
+        make_vector_view<extractor::TurnLaneType::Mask>(memory_ptr, layout, name + "/masks");
+
+    return std::make_tuple(offsets, masks);
+}
+
+inline auto make_ebn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto edge_based_node_data =
+        make_vector_view<extractor::EdgeBasedNode>(memory_ptr, layout, name + "/nodes");
+    auto annotation_data = make_vector_view<extractor::NodeBasedEdgeAnnotation>(
+        memory_ptr, layout, name + "/annotations");
+
+    return extractor::EdgeBasedNodeDataView(std::move(edge_based_node_data),
+                                            std::move(annotation_data));
+}
+
+inline auto make_turn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto lane_data_ids = make_vector_view<LaneDataID>(memory_ptr, layout, name + "/lane_data_ids");
+
+    const auto turn_instructions = make_vector_view<guidance::TurnInstruction>(
+        memory_ptr, layout, name + "/turn_instructions");
+
+    const auto entry_class_ids =
+        make_vector_view<EntryClassID>(memory_ptr, layout, name + "/entry_class_ids");
+
+    const auto pre_turn_bearings =
+        make_vector_view<guidance::TurnBearing>(memory_ptr, layout, name + "/pre_turn_bearings");
+
+    const auto post_turn_bearings =
+        make_vector_view<guidance::TurnBearing>(memory_ptr, layout, name + "/post_turn_bearings");
+
+    return guidance::TurnDataView(std::move(turn_instructions),
+                                  std::move(lane_data_ids),
+                                  std::move(entry_class_ids),
+                                  std::move(pre_turn_bearings),
+                                  std::move(post_turn_bearings));
+}
+
+inline auto
+make_segment_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto geometry_begin_indices = make_vector_view<unsigned>(memory_ptr, layout, name + "/index");
+
+    auto node_list = make_vector_view<NodeID>(memory_ptr, layout, name + "/nodes");
+
+    auto num_entries = layout.GetBlockEntries(name + "/nodes");
+
+    extractor::SegmentDataView::SegmentWeightVector fwd_weight_list(
+        make_vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
+            memory_ptr, layout, name + "/forward_weights/packed"),
+        num_entries);
+
+    extractor::SegmentDataView::SegmentWeightVector rev_weight_list(
+        make_vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
+            memory_ptr, layout, name + "/reverse_weights/packed"),
+        num_entries);
+
+    extractor::SegmentDataView::SegmentDurationVector fwd_duration_list(
+        make_vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
+            memory_ptr, layout, name + "/forward_durations/packed"),
+        num_entries);
+
+    extractor::SegmentDataView::SegmentDurationVector rev_duration_list(
+        make_vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
+            memory_ptr, layout, name + "/reverse_durations/packed"),
+        num_entries);
+
+    auto fwd_datasources_list =
+        make_vector_view<DatasourceID>(memory_ptr, layout, name + "/forward_data_sources");
+
+    auto rev_datasources_list =
+        make_vector_view<DatasourceID>(memory_ptr, layout, name + "/reverse_data_sources");
+
+    return extractor::SegmentDataView{std::move(geometry_begin_indices),
+                                      std::move(node_list),
+                                      std::move(fwd_weight_list),
+                                      std::move(rev_weight_list),
+                                      std::move(fwd_duration_list),
+                                      std::move(rev_duration_list),
+                                      std::move(fwd_datasources_list),
+                                      std::move(rev_datasources_list)};
+}
+
+inline auto
+make_coordinates_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_vector_view<util::Coordinate>(memory_ptr, layout, name);
+}
+
+inline auto make_osm_ids_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_packed_vector_view<extractor::PackedOSMIDsView::value_type,
+                                   extractor::PackedOSMIDsView::value_size>(
+        memory_ptr, layout, name);
+}
+
+inline auto make_nbn_data_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return std::make_tuple(make_coordinates_view(memory_ptr, layout, name + "/coordinates"),
+                           make_osm_ids_view(memory_ptr, layout, name + "/osm_node_ids"));
+}
+
+inline auto
+make_turn_weight_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_vector_view<TurnPenalty>(memory_ptr, layout, name + "/weight");
+}
+
+inline auto
+make_turn_duration_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_vector_view<TurnPenalty>(memory_ptr, layout, name + "/duration");
+}
+
+inline auto
+make_search_tree_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    using RTreeLeaf = extractor::EdgeBasedNodeSegment;
+    using RTreeNode = util::StaticRTree<RTreeLeaf, storage::Ownership::View>::TreeNode;
+
+    const auto search_tree = make_vector_view<RTreeNode>(memory_ptr, layout, name + "/search_tree");
+
+    const auto rtree_level_starts =
+        make_vector_view<std::uint64_t>(memory_ptr, layout, name + "/search_tree_level_starts");
+
+    const auto coordinates =
+        make_coordinates_view(memory_ptr, layout, "/common/nbn_data/coordinates");
+
+    const char *path = layout.GetBlockPtr<char>(memory_ptr, name + "/file_index_path");
+
+    if (!boost::filesystem::exists(boost::filesystem::path{path}))
+    {
+        throw util::exception("Could not load " + std::string(path) + "Does the leaf file exist?" +
+                              SOURCE_REF);
+    }
+
+    return util::StaticRTree<RTreeLeaf, storage::Ownership::View>{
+        std::move(search_tree), std::move(rtree_level_starts), path, std::move(coordinates)};
+}
+
+inline auto
+make_intersection_bearings_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto bearing_offsets =
+        make_vector_view<unsigned>(memory_ptr, layout, name + "/class_id_to_ranges/block_offsets");
+    auto bearing_blocks = make_vector_view<util::RangeTable<16, storage::Ownership::View>::BlockT>(
+        memory_ptr, layout, name + "/class_id_to_ranges/diff_blocks");
+    auto bearing_values =
+        make_vector_view<DiscreteBearing>(memory_ptr, layout, name + "/bearing_values");
+    util::RangeTable<16, storage::Ownership::View> bearing_range_table(
+        std::move(bearing_offsets),
+        std::move(bearing_blocks),
+        static_cast<unsigned>(bearing_values.size()));
+
+    auto bearing_class_id =
+        make_vector_view<BearingClassID>(memory_ptr, layout, name + "/node_to_class_id");
+    return extractor::IntersectionBearingsView{
+        std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
+}
+
+inline auto
+make_entry_classes_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    return make_vector_view<util::guidance::EntryClass>(memory_ptr, layout, name);
+}
+
+inline auto
+make_contracted_metric_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto node_list = make_vector_view<contractor::QueryGraphView::NodeArrayEntry>(
+        memory_ptr, layout, name + "/contracted_graph/node_array");
+    auto edge_list = make_vector_view<contractor::QueryGraphView::EdgeArrayEntry>(
+        memory_ptr, layout, name + "/contracted_graph/edge_array");
+
+    std::vector<util::vector_view<bool>> edge_filter;
+    layout.List(name + "/exclude",
+                boost::make_function_output_iterator([&](const auto &filter_name) {
+                    edge_filter.push_back(make_vector_view<bool>(memory_ptr, layout, filter_name));
+                }));
+
+    return contractor::ContractedMetricView{{std::move(node_list), std::move(edge_list)},
+                                            std::move(edge_filter)};
+}
+
+inline auto make_partition_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto level_data_ptr = layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData>(
+        memory_ptr, name + "/level_data");
+    auto partition = make_vector_view<PartitionID>(memory_ptr, layout, name + "/partition");
+    auto cell_to_children =
+        make_vector_view<CellID>(memory_ptr, layout, name + "/cell_to_children");
+
+    return partitioner::MultiLevelPartitionView{
+        level_data_ptr, std::move(partition), std::move(cell_to_children)};
+}
+
+inline auto
+make_cell_storage_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto source_boundary = make_vector_view<NodeID>(memory_ptr, layout, name + "/source_boundary");
+    auto destination_boundary =
+        make_vector_view<NodeID>(memory_ptr, layout, name + "/destination_boundary");
+    auto cells = make_vector_view<partitioner::CellStorageView::CellData>(
+        memory_ptr, layout, name + "/cells");
+    auto level_offsets =
+        make_vector_view<std::uint64_t>(memory_ptr, layout, name + "/level_to_cell_offset");
+
+    return partitioner::CellStorageView{std::move(source_boundary),
+                                        std::move(destination_boundary),
+                                        std::move(cells),
+                                        std::move(level_offsets)};
+}
+
+inline auto make_filtered_cell_metric_view(char *memory_ptr,
+                                           const DataLayout &layout,
+                                           const std::string &name,
+                                           const std::size_t exclude_index)
+{
+    customizer::CellMetricView cell_metric;
+
+    auto prefix = name + "/exclude/" + std::to_string(exclude_index);
+    auto weights_block_id = prefix + "/weights";
+    auto durations_block_id = prefix + "/durations";
+
+    auto weights = make_vector_view<EdgeWeight>(memory_ptr, layout, weights_block_id);
+    auto durations = make_vector_view<EdgeDuration>(memory_ptr, layout, durations_block_id);
+
+    return customizer::CellMetricView{std::move(weights), std::move(durations)};
+}
+
+inline auto
+make_cell_metric_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    std::vector<customizer::CellMetricView> cell_metric_excludes;
+
+    std::vector<std::string> metric_prefix_names;
+    layout.List(name + "/exclude/", std::back_inserter(metric_prefix_names));
+    for (const auto &prefix : metric_prefix_names)
+    {
+        auto weights_block_id = prefix + "/weights";
+        auto durations_block_id = prefix + "/durations";
+
+        auto weights = make_vector_view<EdgeWeight>(memory_ptr, layout, weights_block_id);
+        auto durations = make_vector_view<EdgeDuration>(memory_ptr, layout, durations_block_id);
+
+        cell_metric_excludes.push_back(
+            customizer::CellMetricView{std::move(weights), std::move(durations)});
+    }
+
+    return cell_metric_excludes;
+}
+
+inline auto
+make_multi_level_graph_view(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto node_list = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry>(
+        memory_ptr, layout, name + "/node_array");
+    auto edge_list = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeArrayEntry>(
+        memory_ptr, layout, name + "/edge_array");
+    auto node_to_offset = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset>(
+        memory_ptr, layout, name + "/node_to_edge_offset");
+
+    return customizer::MultiLevelEdgeBasedGraphView(
+        std::move(node_list), std::move(edge_list), std::move(node_to_offset));
+}
+
+inline auto
+make_maneuver_overrides_views(char *memory_ptr, const DataLayout &layout, const std::string &name)
+{
+    auto maneuver_overrides = make_vector_view<extractor::StorageManeuverOverride>(
+        memory_ptr, layout, name + "/overrides");
+    auto maneuver_override_node_sequences =
+        make_vector_view<NodeID>(memory_ptr, layout, name + "/node_sequences");
+
+    return std::make_tuple(maneuver_overrides, maneuver_override_node_sequences);
+}
+
+inline auto make_filtered_graph_view(char *memory_ptr,
+                                     const DataLayout &layout,
+                                     const std::string &name,
+                                     const std::size_t exclude_index)
+{
+    auto exclude_prefix = name + "/exclude/" + std::to_string(exclude_index);
+    auto edge_filter = make_vector_view<bool>(memory_ptr, layout, exclude_prefix + "/edge_filter");
+    auto node_list = make_vector_view<contractor::QueryGraphView::NodeArrayEntry>(
+        memory_ptr, layout, name + "/contracted_graph/node_array");
+    auto edge_list = make_vector_view<contractor::QueryGraphView::EdgeArrayEntry>(
+        memory_ptr, layout, name + "/contracted_graph/edge_array");
+
+    return util::FilteredGraphView<contractor::QueryGraphView>({node_list, edge_list}, edge_filter);
+}
+}
+}
+
+#endif
diff --git a/include/util/packed_vector.hpp b/include/util/packed_vector.hpp
index a3ca47f7d84..94ee4f19f78 100644
--- a/include/util/packed_vector.hpp
+++ b/include/util/packed_vector.hpp
@@ -243,6 +243,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
 
   public:
     using value_type = T;
+    static constexpr std::size_t value_size = Bits;
     using block_type = WordT;
 
     class internal_reference
diff --git a/include/util/range_table.hpp b/include/util/range_table.hpp
index cceee671378..fcb732b2445 100644
--- a/include/util/range_table.hpp
+++ b/include/util/range_table.hpp
@@ -55,14 +55,12 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
     RangeTable() : sum_lengths(0) {}
 
     // for loading from shared memory
-    explicit RangeTable(OffsetContainerT &external_offsets,
-                        BlockContainerT &external_blocks,
+    explicit RangeTable(OffsetContainerT offsets_,
+                        BlockContainerT blocks_,
                         const unsigned sum_lengths)
-        : sum_lengths(sum_lengths)
+        : block_offsets(std::move(offsets_)), diff_blocks(std::move(blocks_)),
+          sum_lengths(sum_lengths)
     {
-        using std::swap;
-        swap(block_offsets, external_offsets);
-        swap(diff_blocks, external_blocks);
     }
 
     // construct table from length vector
diff --git a/include/util/static_rtree.hpp b/include/util/static_rtree.hpp
index 7ac43e10f56..b0a3c76e32c 100644
--- a/include/util/static_rtree.hpp
+++ b/include/util/static_rtree.hpp
@@ -255,7 +255,7 @@ class StaticRTree
     // Representation of the in-memory search tree
     Vector<TreeNode> m_search_tree;
     // Reference to the actual lon/lat data we need for doing math
-    const Vector<Coordinate> &m_coordinate_list;
+    util::vector_view<const Coordinate> m_coordinate_list;
     // Holds the start indexes of each level in m_search_tree
     Vector<std::uint64_t> m_tree_level_starts;
     // mmap'd .fileIndex file
@@ -264,6 +264,7 @@ class StaticRTree
     util::vector_view<const EdgeDataT> m_objects;
 
   public:
+    StaticRTree() = default;
     StaticRTree(const StaticRTree &) = delete;
     StaticRTree &operator=(const StaticRTree &) = delete;
     StaticRTree(StaticRTree &&) = default;
@@ -273,7 +274,7 @@ class StaticRTree
     explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
                          const Vector<Coordinate> &coordinate_list,
                          const boost::filesystem::path &on_disk_file_name)
-        : m_coordinate_list(coordinate_list)
+        : m_coordinate_list(coordinate_list.data(), coordinate_list.size())
     {
         const auto element_count = input_data_vector.size();
         std::vector<WrappedInputElement> input_wrapper_vector(element_count);
@@ -460,7 +461,7 @@ class StaticRTree
     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
     explicit StaticRTree(const boost::filesystem::path &on_disk_file_name,
                          const Vector<Coordinate> &coordinate_list)
-        : m_coordinate_list(coordinate_list)
+        : m_coordinate_list(coordinate_list.data(), coordinate_list.size())
     {
         m_objects = mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region);
     }
@@ -475,7 +476,8 @@ class StaticRTree
                          Vector<std::uint64_t> tree_level_starts,
                          const boost::filesystem::path &on_disk_file_name,
                          const Vector<Coordinate> &coordinate_list)
-        : m_search_tree(std::move(search_tree_)), m_coordinate_list(coordinate_list),
+        : m_search_tree(std::move(search_tree_)),
+          m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
           m_tree_level_starts(std::move(tree_level_starts))
     {
         BOOST_ASSERT(m_tree_level_starts.size() >= 2);
diff --git a/src/contractor/contractor.cpp b/src/contractor/contractor.cpp
index 45a0ce0361d..416f4a62b06 100644
--- a/src/contractor/contractor.cpp
+++ b/src/contractor/contractor.cpp
@@ -79,6 +79,7 @@ int Contractor::Run()
 
     TIMER_START(contraction);
 
+    std::string metric_name;
     std::vector<std::vector<bool>> node_filters;
     {
         extractor::EdgeBasedNodeDataContainer node_data;
@@ -86,14 +87,12 @@ int Contractor::Run()
 
         extractor::ProfileProperties properties;
         extractor::files::readProfileProperties(config.GetPath(".osrm.properties"), properties);
+        metric_name = properties.GetWeightName();
 
         node_filters =
             util::excludeFlagsToNodeFilter(number_of_edge_based_nodes, node_data, properties);
     }
 
-    RangebasedCRC32 crc32_calculator;
-    const unsigned checksum = crc32_calculator(edge_based_edge_list);
-
     QueryGraph query_graph;
     std::vector<std::vector<bool>> edge_filters;
     std::vector<std::vector<bool>> cores;
@@ -105,8 +104,10 @@ int Contractor::Run()
     util::Log() << "Contracted graph has " << query_graph.GetNumberOfEdges() << " edges.";
     util::Log() << "Contraction took " << TIMER_SEC(contraction) << " sec";
 
-    files::writeGraph(
-        config.GetPath(".osrm.hsgr"), checksum, query_graph, edge_filters, connectivity_checksum);
+    std::unordered_map<std::string, ContractedMetric> metrics = {
+        {metric_name, {std::move(query_graph), std::move(edge_filters)}}};
+
+    files::writeGraph(config.GetPath(".osrm.hsgr"), metrics, connectivity_checksum);
 
     TIMER_STOP(preparing);
 
diff --git a/src/customize/customizer.cpp b/src/customize/customizer.cpp
index 06e6204bfe3..c3292a8127b 100644
--- a/src/customize/customizer.cpp
+++ b/src/customize/customizer.cpp
@@ -153,7 +153,10 @@ int Customizer::Run(const CustomizationConfig &config)
     util::Log() << "Cells customization took " << TIMER_SEC(cell_customize) << " seconds";
 
     TIMER_START(writing_mld_data);
-    files::writeCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
+    std::unordered_map<std::string, std::vector<CellMetric>> metric_exclude_classes = {
+        {properties.GetWeightName(), std::move(metrics)},
+    };
+    files::writeCellMetrics(config.GetPath(".osrm.cell_metrics"), metric_exclude_classes);
     TIMER_STOP(writing_mld_data);
     util::Log() << "MLD customization writing took " << TIMER_SEC(writing_mld_data) << " seconds";
 
diff --git a/src/engine/datafacade/process_memory_allocator.cpp b/src/engine/datafacade/process_memory_allocator.cpp
index fcb88bad520..4c39c5877d1 100644
--- a/src/engine/datafacade/process_memory_allocator.cpp
+++ b/src/engine/datafacade/process_memory_allocator.cpp
@@ -15,17 +15,16 @@ ProcessMemoryAllocator::ProcessMemoryAllocator(const storage::StorageConfig &con
     storage::Storage storage(config);
 
     // Calculate the layout/size of the memory block
-    internal_layout = std::make_unique<storage::DataLayout>();
-    storage.PopulateLayout(*internal_layout);
+    storage.PopulateLayout(internal_layout);
 
     // Allocate the memory block, then load data from files into it
-    internal_memory = std::make_unique<char[]>(internal_layout->GetSizeOfLayout());
-    storage.PopulateData(*internal_layout, internal_memory.get());
+    internal_memory = std::make_unique<char[]>(internal_layout.GetSizeOfLayout());
+    storage.PopulateData(internal_layout, internal_memory.get());
 }
 
 ProcessMemoryAllocator::~ProcessMemoryAllocator() {}
 
-storage::DataLayout &ProcessMemoryAllocator::GetLayout() { return *internal_layout.get(); }
+const storage::DataLayout &ProcessMemoryAllocator::GetLayout() { return internal_layout; }
 char *ProcessMemoryAllocator::GetMemory() { return internal_memory.get(); }
 
 } // namespace datafacade
diff --git a/src/engine/datafacade/shared_memory_allocator.cpp b/src/engine/datafacade/shared_memory_allocator.cpp
index 87814f98727..d6d8be0d2f0 100644
--- a/src/engine/datafacade/shared_memory_allocator.cpp
+++ b/src/engine/datafacade/shared_memory_allocator.cpp
@@ -1,4 +1,7 @@
 #include "engine/datafacade/shared_memory_allocator.hpp"
+
+#include "storage/serialization.hpp"
+
 #include "util/log.hpp"
 
 #include "boost/assert.hpp"
@@ -16,17 +19,20 @@ SharedMemoryAllocator::SharedMemoryAllocator(storage::SharedDataType data_region
 
     BOOST_ASSERT(storage::SharedMemory::RegionExists(data_region));
     m_large_memory = storage::makeSharedMemory(data_region);
+
+    storage::io::BufferReader reader(reinterpret_cast<char *>(m_large_memory->Ptr()),
+                                     m_large_memory->Size());
+    storage::serialization::read(reader, data_layout);
+    layout_size = reader.GetPosition();
+    util::Log(logDEBUG) << "Data layout has size " << layout_size;
 }
 
 SharedMemoryAllocator::~SharedMemoryAllocator() {}
 
-storage::DataLayout &SharedMemoryAllocator::GetLayout()
-{
-    return *reinterpret_cast<storage::DataLayout *>(m_large_memory->Ptr());
-}
+const storage::DataLayout &SharedMemoryAllocator::GetLayout() { return data_layout; }
 char *SharedMemoryAllocator::GetMemory()
 {
-    return reinterpret_cast<char *>(m_large_memory->Ptr()) + sizeof(storage::DataLayout);
+    return reinterpret_cast<char *>(m_large_memory->Ptr()) + layout_size;
 }
 
 } // namespace datafacade
diff --git a/src/osrm/osrm.cpp b/src/osrm/osrm.cpp
index 26f4187b32f..77da7b40e57 100644
--- a/src/osrm/osrm.cpp
+++ b/src/osrm/osrm.cpp
@@ -1,4 +1,5 @@
 #include "osrm/osrm.hpp"
+
 #include "engine/algorithm.hpp"
 #include "engine/api/match_parameters.hpp"
 #include "engine/api/nearest_parameters.hpp"
@@ -32,41 +33,15 @@ OSRM::OSRM(engine::EngineConfig &config)
         storage::SharedMonitor<storage::SharedDataTimestamp> barrier;
         using mutex_type = typename decltype(barrier)::mutex_type;
         boost::interprocess::scoped_lock<mutex_type> current_region_lock(barrier.get_mutex());
-
-        auto mem = storage::makeSharedMemory(barrier.data().region);
-        auto layout = reinterpret_cast<storage::DataLayout *>(mem->Ptr());
-        if (layout->GetBlockSize(storage::DataLayout::NAME_VALUES) == 0)
-            throw util::exception(
-                "No name data loaded, cannot continue.  Have you run osrm-datastore to load data?");
     }
 
     // Now, check that the algorithm requested can be used with the data
     // that's available.
 
-    if (config.algorithm == EngineConfig::Algorithm::CH ||
-        config.algorithm == EngineConfig::Algorithm::CoreCH)
-    {
-        if (config.algorithm == EngineConfig::Algorithm::CoreCH)
-        {
-            util::Log(logWARNING) << "Using CoreCH is deprecated. Falling back to CH";
-            config.algorithm = EngineConfig::Algorithm::CH;
-        }
-        bool ch_compatible = engine::Engine<CH>::CheckCompatibility(config);
-
-        // throw error if dataset is not usable with CH
-        if (config.algorithm == EngineConfig::Algorithm::CH && !ch_compatible)
-        {
-            throw util::exception("Dataset is not compatible with CH");
-        }
-    }
-    else if (config.algorithm == EngineConfig::Algorithm::MLD)
+    if (config.algorithm == EngineConfig::Algorithm::CoreCH)
     {
-        bool mld_compatible = engine::Engine<MLD>::CheckCompatibility(config);
-        // throw error if dataset is not usable with MLD
-        if (!mld_compatible)
-        {
-            throw util::exception("Dataset is not compatible with MLD.");
-        }
+        util::Log(logWARNING) << "Using CoreCH is deprecated. Falling back to CH";
+        config.algorithm = EngineConfig::Algorithm::CH;
     }
 
     switch (config.algorithm)
diff --git a/src/storage/storage.cpp b/src/storage/storage.cpp
index 806f966e2fb..66aca94850e 100644
--- a/src/storage/storage.cpp
+++ b/src/storage/storage.cpp
@@ -5,46 +5,18 @@
 #include "storage/shared_memory.hpp"
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/shared_monitor.hpp"
+#include "storage/view_factory.hpp"
 
 #include "contractor/files.hpp"
-#include "contractor/query_graph.hpp"
-
-#include "customizer/edge_based_graph.hpp"
 #include "customizer/files.hpp"
-
-#include "extractor/class_data.hpp"
-#include "extractor/compressed_edge_container.hpp"
-#include "extractor/edge_based_edge.hpp"
-#include "extractor/edge_based_node.hpp"
 #include "extractor/files.hpp"
-#include "extractor/maneuver_override.hpp"
-#include "extractor/name_table.hpp"
-#include "extractor/packed_osm_ids.hpp"
-#include "extractor/profile_properties.hpp"
-#include "extractor/query_node.hpp"
-#include "extractor/travel_mode.hpp"
-
 #include "guidance/files.hpp"
-#include "guidance/turn_instruction.hpp"
-
-#include "partitioner/cell_storage.hpp"
-#include "partitioner/edge_based_graph_reader.hpp"
 #include "partitioner/files.hpp"
-#include "partitioner/multi_level_partition.hpp"
 
-#include "engine/datafacade/datafacade_base.hpp"
-
-#include "util/coordinate.hpp"
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
 #include "util/fingerprint.hpp"
 #include "util/log.hpp"
-#include "util/packed_vector.hpp"
-#include "util/range_table.hpp"
-#include "util/static_graph.hpp"
-#include "util/static_rtree.hpp"
-#include "util/typedefs.hpp"
-#include "util/vector_view.hpp"
 
 #ifdef __linux__
 #include <sys/mman.h>
@@ -70,7 +42,7 @@ namespace storage
 {
 namespace
 {
-template <typename OutIter> void readBlocks(const boost::filesystem::path &path, OutIter out)
+inline void readBlocks(const boost::filesystem::path &path, DataLayout &layout)
 {
     tar::FileReader reader(path, tar::FileReader::VerifyFingerprint);
 
@@ -83,19 +55,12 @@ template <typename OutIter> void readBlocks(const boost::filesystem::path &path,
         if (name_end == std::string::npos)
         {
             auto number_of_elements = reader.ReadElementCount64(entry.name);
-            *out++ = NamedBlock{entry.name, Block{number_of_elements, entry.size}};
+            layout.SetBlock(entry.name, Block{number_of_elements, entry.size});
         }
     }
 }
 }
 
-static constexpr std::size_t NUM_METRICS = 8;
-
-using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf;
-using RTreeNode = util::StaticRTree<RTreeLeaf, storage::Ownership::View>::TreeNode;
-using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
-using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>;
-
 using Monitor = SharedMonitor<SharedDataTimestamp>;
 
 Storage::Storage(StorageConfig config_) : config(std::move(config_)) {}
@@ -159,15 +124,20 @@ int Storage::Run(int max_wait)
     DataLayout layout;
     PopulateLayout(layout);
 
+    io::BufferWriter writer;
+    serialization::write(writer, layout);
+    auto encoded_layout = writer.GetBuffer();
+
     // Allocate shared memory block
-    auto regions_size = sizeof(layout) + layout.GetSizeOfLayout();
+    auto regions_size = encoded_layout.size() + layout.GetSizeOfLayout();
+    util::Log() << "Data layout has a size of " << encoded_layout.size() << " bytes";
     util::Log() << "Allocating shared memory of " << regions_size << " bytes";
     auto data_memory = makeSharedMemory(next_region, regions_size);
 
     // Copy memory layout to shared memory and populate data
     char *shared_memory_ptr = static_cast<char *>(data_memory->Ptr());
-    memcpy(shared_memory_ptr, &layout, sizeof(layout));
-    PopulateData(layout, shared_memory_ptr + sizeof(layout));
+    std::copy_n(encoded_layout.data(), encoded_layout.size(), shared_memory_ptr);
+    PopulateData(layout, shared_memory_ptr + encoded_layout.size());
 
     { // Lock for write access shared region mutex
         boost::interprocess::scoped_lock<Monitor::mutex_type> lock(monitor.get_mutex(),
@@ -236,91 +206,10 @@ void Storage::PopulateLayout(DataLayout &layout)
         auto absolute_file_index_path =
             boost::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
 
-        layout.SetBlock(DataLayout::FILE_INDEX_PATH,
+        layout.SetBlock("/common/rtree/file_index_path",
                         make_block<char>(absolute_file_index_path.string().length() + 1));
     }
 
-    std::unordered_map<std::string, DataLayout::BlockID> 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},
-        {"/common/intersection_bearings/bearing_values", DataLayout::BEARING_VALUES},
-        {"/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/diff_blocks",
-         DataLayout::BEARING_BLOCKS},
-        {"/common/entry_classes", DataLayout::ENTRY_CLASS},
-        {"/common/properties", DataLayout::PROPERTIES},
-        {"/common/coordinates", DataLayout::COORDINATE_LIST},
-        {"/common/osm_node_ids/packed", DataLayout::OSM_NODE_ID_LIST},
-        {"/common/data_sources_names", DataLayout::DATASOURCES_NAMES},
-        {"/common/segment_data/index", DataLayout::GEOMETRIES_INDEX},
-        {"/common/segment_data/nodes", DataLayout::GEOMETRIES_NODE_LIST},
-        {"/common/segment_data/forward_weights/packed", DataLayout::GEOMETRIES_FWD_WEIGHT_LIST},
-        {"/common/segment_data/reverse_weights/packed", DataLayout::GEOMETRIES_REV_WEIGHT_LIST},
-        {"/common/segment_data/forward_durations/packed", DataLayout::GEOMETRIES_FWD_DURATION_LIST},
-        {"/common/segment_data/reverse_durations/packed", DataLayout::GEOMETRIES_REV_DURATION_LIST},
-        {"/common/segment_data/forward_data_sources", DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST},
-        {"/common/segment_data/reverse_data_sources", DataLayout::GEOMETRIES_REV_DATASOURCES_LIST},
-        {"/common/ebg_node_data/nodes", DataLayout::EDGE_BASED_NODE_DATA_LIST},
-        {"/common/ebg_node_data/annotations", DataLayout::ANNOTATION_DATA_LIST},
-        {"/common/turn_lanes/offsets", DataLayout::LANE_DESCRIPTION_OFFSETS},
-        {"/common/turn_lanes/masks", DataLayout::LANE_DESCRIPTION_MASKS},
-        {"/common/turn_lanes/data", DataLayout::TURN_LANE_DATA},
-        {"/common/maneuver_overrides/overrides", DataLayout::MANEUVER_OVERRIDES},
-        {"/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},
-        {"/common/turn_data/pre_turn_bearings", DataLayout::PRE_TURN_BEARING},
-        {"/common/turn_data/post_turn_bearings", DataLayout::POST_TURN_BEARING},
-        {"/common/turn_data/turn_instructions", DataLayout::TURN_INSTRUCTION},
-        {"/common/turn_data/lane_data_ids", DataLayout::LANE_DATA_ID},
-        {"/common/turn_data/entry_class_ids", DataLayout::ENTRY_CLASSID},
-        {"/common/turn_data/connectivity_checksum", DataLayout::IGNORE_BLOCK},
-        {"/common/names/blocks", DataLayout::NAME_BLOCKS},
-        {"/common/names/values", DataLayout::NAME_VALUES},
-        {"/common/rtree/search_tree", DataLayout::R_SEARCH_TREE},
-        {"/common/rtree/search_tree_level_starts", DataLayout::R_SEARCH_TREE_LEVEL_STARTS},
-    };
-    std::vector<NamedBlock> blocks;
-
     constexpr bool REQUIRED = true;
     constexpr bool OPTIONAL = false;
     std::vector<std::pair<bool, boost::filesystem::path>> tar_files = {
@@ -349,7 +238,7 @@ void Storage::PopulateLayout(DataLayout &layout)
     {
         if (boost::filesystem::exists(file.second))
         {
-            readBlocks(file.second, std::back_inserter(blocks));
+            readBlocks(file.second, layout);
         }
         else
         {
@@ -360,17 +249,6 @@ void Storage::PopulateLayout(DataLayout &layout)
             }
         }
     }
-
-    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())
-        {
-            throw util::exception("Could not map " + std::get<0>(block) +
-                                  " to a region in memory.");
-        }
-        layout.SetBlock(id_iter->second, std::get<1>(block));
-    }
 }
 
 void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
@@ -385,517 +263,186 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
     // store the filename of the on-disk portion of the RTree
     {
         const auto file_index_path_ptr =
-            layout.GetBlockPtr<char, true>(memory_ptr, DataLayout::FILE_INDEX_PATH);
+            layout.GetBlockPtr<char>(memory_ptr, "/common/rtree/file_index_path");
         // make sure we have 0 ending
         std::fill(file_index_path_ptr,
-                  file_index_path_ptr + layout.GetBlockSize(DataLayout::FILE_INDEX_PATH),
+                  file_index_path_ptr + layout.GetBlockSize("/common/rtree/file_index_path"),
                   0);
         const auto absolute_file_index_path =
             boost::filesystem::absolute(config.GetPath(".osrm.fileIndex")).string();
-        BOOST_ASSERT(static_cast<std::size_t>(layout.GetBlockSize(DataLayout::FILE_INDEX_PATH)) >=
-                     absolute_file_index_path.size());
+        BOOST_ASSERT(static_cast<std::size_t>(layout.GetBlockSize(
+                         "/common/rtree/file_index_path")) >= absolute_file_index_path.size());
         std::copy(
             absolute_file_index_path.begin(), absolute_file_index_path.end(), file_index_path_ptr);
     }
 
     // Name data
     {
-        const auto name_blocks_ptr =
-            layout.GetBlockPtr<extractor::NameTableView::IndexedData::BlockReference, true>(
-                memory_ptr, DataLayout::NAME_BLOCKS);
-        const auto name_values_ptr =
-            layout.GetBlockPtr<extractor::NameTableView::IndexedData::ValueType, true>(
-                memory_ptr, DataLayout::NAME_VALUES);
-
-        util::vector_view<extractor::NameTableView::IndexedData::BlockReference> blocks(
-            name_blocks_ptr, layout.GetBlockEntries(storage::DataLayout::NAME_BLOCKS));
-        util::vector_view<extractor::NameTableView::IndexedData::ValueType> values(
-            name_values_ptr, layout.GetBlockEntries(storage::DataLayout::NAME_VALUES));
-
-        extractor::NameTableView::IndexedData index_data_view{std::move(blocks), std::move(values)};
-        extractor::NameTableView name_table{index_data_view};
+        auto name_table = make_name_table_view(memory_ptr, layout, "/common/names");
         extractor::files::readNames(config.GetPath(".osrm.names"), name_table);
     }
 
     // Turn lane data
     {
-        const auto turn_lane_data_ptr = layout.GetBlockPtr<util::guidance::LaneTupleIdPair, true>(
-            memory_ptr, DataLayout::TURN_LANE_DATA);
-        util::vector_view<util::guidance::LaneTupleIdPair> turn_lane_data(
-            turn_lane_data_ptr, layout.GetBlockEntries(storage::DataLayout::TURN_LANE_DATA));
-
+        auto turn_lane_data = make_lane_data_view(memory_ptr, layout, "/common/turn_lanes");
         extractor::files::readTurnLaneData(config.GetPath(".osrm.tld"), turn_lane_data);
     }
 
     // Turn lane descriptions
     {
-        auto offsets_ptr = layout.GetBlockPtr<std::uint32_t, true>(
-            memory_ptr, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::vector_view<std::uint32_t> offsets(
-            offsets_ptr, layout.GetBlockEntries(storage::DataLayout::LANE_DESCRIPTION_OFFSETS));
-
-        auto masks_ptr = layout.GetBlockPtr<extractor::TurnLaneType::Mask, true>(
-            memory_ptr, storage::DataLayout::LANE_DESCRIPTION_MASKS);
-        util::vector_view<extractor::TurnLaneType::Mask> masks(
-            masks_ptr, layout.GetBlockEntries(storage::DataLayout::LANE_DESCRIPTION_MASKS));
-
-        extractor::files::readTurnLaneDescriptions(config.GetPath(".osrm.tls"), offsets, masks);
+        auto views = make_turn_lane_description_views(memory_ptr, layout, "/common/turn_lanes");
+        extractor::files::readTurnLaneDescriptions(
+            config.GetPath(".osrm.tls"), std::get<0>(views), std::get<1>(views));
     }
 
     // Load edge-based nodes data
     {
-        auto edge_based_node_data_list_ptr = layout.GetBlockPtr<extractor::EdgeBasedNode, true>(
-            memory_ptr, storage::DataLayout::EDGE_BASED_NODE_DATA_LIST);
-        util::vector_view<extractor::EdgeBasedNode> edge_based_node_data(
-            edge_based_node_data_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::EDGE_BASED_NODE_DATA_LIST));
-
-        auto annotation_data_list_ptr =
-            layout.GetBlockPtr<extractor::NodeBasedEdgeAnnotation, true>(
-                memory_ptr, storage::DataLayout::ANNOTATION_DATA_LIST);
-        util::vector_view<extractor::NodeBasedEdgeAnnotation> annotation_data(
-            annotation_data_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::ANNOTATION_DATA_LIST));
-
-        extractor::EdgeBasedNodeDataView node_data(std::move(edge_based_node_data),
-                                                   std::move(annotation_data));
-
+        auto node_data = make_ebn_data_view(memory_ptr, layout, "/common/ebg_node_data");
         extractor::files::readNodeData(config.GetPath(".osrm.ebg_nodes"), node_data);
     }
 
     // Load original edge data
     {
-        const auto lane_data_id_ptr =
-            layout.GetBlockPtr<LaneDataID, true>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
-        util::vector_view<LaneDataID> lane_data_ids(
-            lane_data_id_ptr, layout.GetBlockEntries(storage::DataLayout::LANE_DATA_ID));
-
-        const auto turn_instruction_list_ptr = layout.GetBlockPtr<guidance::TurnInstruction, true>(
-            memory_ptr, storage::DataLayout::TURN_INSTRUCTION);
-        util::vector_view<guidance::TurnInstruction> turn_instructions(
-            turn_instruction_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::TURN_INSTRUCTION));
-
-        const auto entry_class_id_list_ptr =
-            layout.GetBlockPtr<EntryClassID, true>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
-        util::vector_view<EntryClassID> entry_class_ids(
-            entry_class_id_list_ptr, layout.GetBlockEntries(storage::DataLayout::ENTRY_CLASSID));
-
-        const auto pre_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing, true>(
-            memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> pre_turn_bearings(
-            pre_turn_bearing_ptr, layout.GetBlockEntries(storage::DataLayout::PRE_TURN_BEARING));
-
-        const auto post_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing, true>(
-            memory_ptr, storage::DataLayout::POST_TURN_BEARING);
-        util::vector_view<guidance::TurnBearing> post_turn_bearings(
-            post_turn_bearing_ptr, layout.GetBlockEntries(storage::DataLayout::POST_TURN_BEARING));
-
-        guidance::TurnDataView turn_data(std::move(turn_instructions),
-                                         std::move(lane_data_ids),
-                                         std::move(entry_class_ids),
-                                         std::move(pre_turn_bearings),
-                                         std::move(post_turn_bearings));
+        auto turn_data = make_turn_data_view(memory_ptr, layout, "/common/turn_data");
+
+        auto connectivity_checksum_ptr =
+            layout.GetBlockPtr<std::uint32_t>(memory_ptr, "/common/connectivity_checksum");
 
         guidance::files::readTurnData(
-            config.GetPath(".osrm.edges"), turn_data, turns_connectivity_checksum);
+            config.GetPath(".osrm.edges"), turn_data, *connectivity_checksum_ptr);
+
+        turns_connectivity_checksum = *connectivity_checksum_ptr;
     }
 
     // load compressed geometry
     {
-        auto geometries_index_ptr =
-            layout.GetBlockPtr<unsigned, true>(memory_ptr, storage::DataLayout::GEOMETRIES_INDEX);
-        util::vector_view<unsigned> geometry_begin_indices(
-            geometries_index_ptr, layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_INDEX));
-
-        auto num_entries = layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_NODE_LIST);
-
-        auto geometries_node_list_ptr =
-            layout.GetBlockPtr<NodeID, true>(memory_ptr, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::vector_view<NodeID> geometry_node_list(geometries_node_list_ptr, num_entries);
-
-        auto geometries_fwd_weight_list_ptr =
-            layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type, true>(
-                memory_ptr, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_fwd_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_fwd_weight_list_ptr,
-                layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST)),
-            num_entries);
-
-        auto geometries_rev_weight_list_ptr =
-            layout.GetBlockPtr<extractor::SegmentDataView::SegmentWeightVector::block_type, true>(
-                memory_ptr, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        extractor::SegmentDataView::SegmentWeightVector geometry_rev_weight_list(
-            util::vector_view<extractor::SegmentDataView::SegmentWeightVector::block_type>(
-                geometries_rev_weight_list_ptr,
-                layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST)),
-            num_entries);
-
-        auto geometries_fwd_duration_list_ptr =
-            layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type, true>(
-                memory_ptr, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_fwd_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_fwd_duration_list_ptr,
-                layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST)),
-            num_entries);
-
-        auto geometries_rev_duration_list_ptr =
-            layout.GetBlockPtr<extractor::SegmentDataView::SegmentDurationVector::block_type, true>(
-                memory_ptr, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        extractor::SegmentDataView::SegmentDurationVector geometry_rev_duration_list(
-            util::vector_view<extractor::SegmentDataView::SegmentDurationVector::block_type>(
-                geometries_rev_duration_list_ptr,
-                layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_DURATION_LIST)),
-            num_entries);
-
-        auto geometries_fwd_datasources_list_ptr = layout.GetBlockPtr<DatasourceID, true>(
-            memory_ptr, storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_fwd_datasources_list(
-            geometries_fwd_datasources_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST));
-
-        auto geometries_rev_datasources_list_ptr = layout.GetBlockPtr<DatasourceID, true>(
-            memory_ptr, storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST);
-        util::vector_view<DatasourceID> geometry_rev_datasources_list(
-            geometries_rev_datasources_list_ptr,
-            layout.GetBlockEntries(storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST));
-
-        extractor::SegmentDataView segment_data{std::move(geometry_begin_indices),
-                                                std::move(geometry_node_list),
-                                                std::move(geometry_fwd_weight_list),
-                                                std::move(geometry_rev_weight_list),
-                                                std::move(geometry_fwd_duration_list),
-                                                std::move(geometry_rev_duration_list),
-                                                std::move(geometry_fwd_datasources_list),
-                                                std::move(geometry_rev_datasources_list)};
-
+        auto segment_data = make_segment_data_view(memory_ptr, layout, "/common/segment_data");
         extractor::files::readSegmentData(config.GetPath(".osrm.geometry"), segment_data);
     }
 
     {
-        const auto datasources_names_ptr = layout.GetBlockPtr<extractor::Datasources, true>(
-            memory_ptr, DataLayout::DATASOURCES_NAMES);
+        const auto datasources_names_ptr =
+            layout.GetBlockPtr<extractor::Datasources>(memory_ptr, "/common/data_sources_names");
         extractor::files::readDatasources(config.GetPath(".osrm.datasource_names"),
                                           *datasources_names_ptr);
     }
 
     // Loading list of coordinates
     {
-        const auto coordinates_ptr =
-            layout.GetBlockPtr<util::Coordinate, true>(memory_ptr, DataLayout::COORDINATE_LIST);
-        const auto osmnodeid_ptr =
-            layout.GetBlockPtr<extractor::PackedOSMIDsView::block_type, true>(
-                memory_ptr, DataLayout::OSM_NODE_ID_LIST);
-        util::vector_view<util::Coordinate> coordinates(
-            coordinates_ptr, layout.GetBlockEntries(DataLayout::COORDINATE_LIST));
-        extractor::PackedOSMIDsView osm_node_ids(
-            util::vector_view<extractor::PackedOSMIDsView::block_type>(
-                osmnodeid_ptr, layout.GetBlockEntries(DataLayout::OSM_NODE_ID_LIST)),
-            layout.GetBlockEntries(DataLayout::COORDINATE_LIST));
-
-        extractor::files::readNodes(config.GetPath(".osrm.nbg_nodes"), coordinates, osm_node_ids);
+        auto views = make_nbn_data_view(memory_ptr, layout, "/common/nbn_data");
+        extractor::files::readNodes(
+            config.GetPath(".osrm.nbg_nodes"), std::get<0>(views), std::get<1>(views));
     }
 
     // load turn weight penalties
     {
-        auto turn_duration_penalties_ptr = layout.GetBlockPtr<TurnPenalty, true>(
-            memory_ptr, storage::DataLayout::TURN_WEIGHT_PENALTIES);
-        util::vector_view<TurnPenalty> turn_duration_penalties(
-            turn_duration_penalties_ptr,
-            layout.GetBlockEntries(storage::DataLayout::TURN_WEIGHT_PENALTIES));
+        auto turn_duration_penalties =
+            make_turn_weight_view(memory_ptr, layout, "/common/turn_penalty");
         extractor::files::readTurnWeightPenalty(config.GetPath(".osrm.turn_weight_penalties"),
                                                 turn_duration_penalties);
     }
 
     // load turn duration penalties
     {
-        auto turn_duration_penalties_ptr = layout.GetBlockPtr<TurnPenalty, true>(
-            memory_ptr, storage::DataLayout::TURN_DURATION_PENALTIES);
-        util::vector_view<TurnPenalty> turn_duration_penalties(
-            turn_duration_penalties_ptr,
-            layout.GetBlockEntries(storage::DataLayout::TURN_DURATION_PENALTIES));
+        auto turn_duration_penalties =
+            make_turn_duration_view(memory_ptr, layout, "/common/turn_penalty");
         extractor::files::readTurnDurationPenalty(config.GetPath(".osrm.turn_duration_penalties"),
                                                   turn_duration_penalties);
     }
 
     // store search tree portion of rtree
     {
-
-        const auto rtree_ptr =
-            layout.GetBlockPtr<RTreeNode, true>(memory_ptr, DataLayout::R_SEARCH_TREE);
-        util::vector_view<RTreeNode> search_tree(
-            rtree_ptr, layout.GetBlockEntries(storage::DataLayout::R_SEARCH_TREE));
-
-        const auto rtree_levelstarts_ptr = layout.GetBlockPtr<std::uint64_t, true>(
-            memory_ptr, DataLayout::R_SEARCH_TREE_LEVEL_STARTS);
-        util::vector_view<std::uint64_t> rtree_level_starts(
-            rtree_levelstarts_ptr,
-            layout.GetBlockEntries(storage::DataLayout::R_SEARCH_TREE_LEVEL_STARTS));
-
-        // we need this purely for the interface
-        util::vector_view<util::Coordinate> empty_coords;
-
-        util::StaticRTree<RTreeLeaf, storage::Ownership::View> rtree{
-            std::move(search_tree),
-            std::move(rtree_level_starts),
-            config.GetPath(".osrm.fileIndex"),
-            empty_coords};
+        auto rtree = make_search_tree_view(memory_ptr, layout, "/common/rtree");
         extractor::files::readRamIndex(config.GetPath(".osrm.ramIndex"), rtree);
     }
 
+    // FIXME we only need to get the weight name
+    std::string metric_name;
     // load profile properties
     {
-        const auto profile_properties_ptr = layout.GetBlockPtr<extractor::ProfileProperties, true>(
-            memory_ptr, DataLayout::PROPERTIES);
+        const auto profile_properties_ptr =
+            layout.GetBlockPtr<extractor::ProfileProperties>(memory_ptr, "/common/properties");
         extractor::files::readProfileProperties(config.GetPath(".osrm.properties"),
                                                 *profile_properties_ptr);
+
+        metric_name = profile_properties_ptr->GetWeightName();
     }
 
     // Load intersection data
     {
-        auto bearing_class_id_ptr = layout.GetBlockPtr<BearingClassID, true>(
-            memory_ptr, storage::DataLayout::BEARING_CLASSID);
-        util::vector_view<BearingClassID> bearing_class_id(
-            bearing_class_id_ptr, layout.GetBlockEntries(storage::DataLayout::BEARING_CLASSID));
-
-        auto bearing_values_ptr = layout.GetBlockPtr<DiscreteBearing, true>(
-            memory_ptr, storage::DataLayout::BEARING_VALUES);
-        util::vector_view<DiscreteBearing> bearing_values(
-            bearing_values_ptr, layout.GetBlockEntries(storage::DataLayout::BEARING_VALUES));
-
-        auto offsets_ptr =
-            layout.GetBlockPtr<unsigned, true>(memory_ptr, storage::DataLayout::BEARING_OFFSETS);
-        auto blocks_ptr =
-            layout.GetBlockPtr<util::RangeTable<16, storage::Ownership::View>::BlockT, true>(
-                memory_ptr, storage::DataLayout::BEARING_BLOCKS);
-        util::vector_view<unsigned> bearing_offsets(
-            offsets_ptr, layout.GetBlockEntries(storage::DataLayout::BEARING_OFFSETS));
-        util::vector_view<util::RangeTable<16, storage::Ownership::View>::BlockT> bearing_blocks(
-            blocks_ptr, layout.GetBlockEntries(storage::DataLayout::BEARING_BLOCKS));
-
-        util::RangeTable<16, storage::Ownership::View> bearing_range_table(
-            bearing_offsets, bearing_blocks, static_cast<unsigned>(bearing_values.size()));
-
-        extractor::IntersectionBearingsView intersection_bearings_view{
-            std::move(bearing_values), std::move(bearing_class_id), std::move(bearing_range_table)};
-
-        auto entry_class_ptr = layout.GetBlockPtr<util::guidance::EntryClass, true>(
-            memory_ptr, storage::DataLayout::ENTRY_CLASS);
-        util::vector_view<util::guidance::EntryClass> entry_classes(
-            entry_class_ptr, layout.GetBlockEntries(storage::DataLayout::ENTRY_CLASS));
-
+        auto intersection_bearings_view =
+            make_intersection_bearings_view(memory_ptr, layout, "/common/intersection_bearings");
+        auto entry_classes = make_entry_classes_view(memory_ptr, layout, "/common/entry_classes");
         extractor::files::readIntersections(
             config.GetPath(".osrm.icd"), intersection_bearings_view, entry_classes);
     }
 
-    { // Load the HSGR file
-        if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
-        {
-            auto graph_nodes_ptr =
-                layout.GetBlockPtr<contractor::QueryGraphView::NodeArrayEntry, true>(
-                    memory_ptr, storage::DataLayout::CH_GRAPH_NODE_LIST);
-            auto graph_edges_ptr =
-                layout.GetBlockPtr<contractor::QueryGraphView::EdgeArrayEntry, true>(
-                    memory_ptr, storage::DataLayout::CH_GRAPH_EDGE_LIST);
-            auto checksum =
-                layout.GetBlockPtr<unsigned, true>(memory_ptr, DataLayout::HSGR_CHECKSUM);
-
-            util::vector_view<contractor::QueryGraphView::NodeArrayEntry> node_list(
-                graph_nodes_ptr, layout.GetBlockEntries(storage::DataLayout::CH_GRAPH_NODE_LIST));
-            util::vector_view<contractor::QueryGraphView::EdgeArrayEntry> edge_list(
-                graph_edges_ptr, layout.GetBlockEntries(storage::DataLayout::CH_GRAPH_EDGE_LIST));
-
-            std::vector<util::vector_view<bool>> edge_filter;
-            for (auto index : util::irange<std::size_t>(0, NUM_METRICS))
-            {
-                auto block_id =
-                    static_cast<DataLayout::BlockID>(storage::DataLayout::CH_EDGE_FILTER_0 + index);
-                auto data_ptr =
-                    layout.GetBlockPtr<util::vector_view<bool>::Word, true>(memory_ptr, block_id);
-                auto num_entries = layout.GetBlockEntries(block_id);
-                edge_filter.emplace_back(data_ptr, num_entries);
-            }
-
-            std::uint32_t graph_connectivity_checksum = 0;
-            contractor::QueryGraphView graph_view(std::move(node_list), std::move(edge_list));
-            contractor::files::readGraph(config.GetPath(".osrm.hsgr"),
-                                         *checksum,
-                                         graph_view,
-                                         edge_filter,
-                                         graph_connectivity_checksum);
-            if (turns_connectivity_checksum != graph_connectivity_checksum)
-            {
-                throw util::exception(
-                    "Connectivity checksum " + std::to_string(graph_connectivity_checksum) +
-                    " in " + config.GetPath(".osrm.hsgr").string() +
-                    " does not equal to checksum " + std::to_string(turns_connectivity_checksum) +
-                    " in " + config.GetPath(".osrm.edges").string());
-            }
-        }
-        else
-        {
-            layout.GetBlockPtr<unsigned, true>(memory_ptr, DataLayout::HSGR_CHECKSUM);
-            layout.GetBlockPtr<contractor::QueryGraphView::NodeArrayEntry, true>(
-                memory_ptr, DataLayout::CH_GRAPH_NODE_LIST);
-            layout.GetBlockPtr<contractor::QueryGraphView::EdgeArrayEntry, true>(
-                memory_ptr, DataLayout::CH_GRAPH_EDGE_LIST);
-        }
-    }
+    if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
+    {
+        const std::string metric_prefix = "/ch/metrics/" + metric_name;
+        auto contracted_metric = make_contracted_metric_view(memory_ptr, layout, metric_prefix);
+        std::unordered_map<std::string, contractor::ContractedMetricView> metrics = {
+            {metric_name, std::move(contracted_metric)}};
 
-    { // Loading MLD Data
-        if (boost::filesystem::exists(config.GetPath(".osrm.partition")))
-        {
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_LEVEL_DATA) > 0);
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_CELL_TO_CHILDREN) > 0);
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_PARTITION) > 0);
-
-            auto level_data =
-                layout.GetBlockPtr<partitioner::MultiLevelPartitionView::LevelData, true>(
-                    memory_ptr, storage::DataLayout::MLD_LEVEL_DATA);
-
-            auto mld_partition_ptr = layout.GetBlockPtr<PartitionID, true>(
-                memory_ptr, storage::DataLayout::MLD_PARTITION);
-            auto partition_entries_count =
-                layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
-
-            auto mld_chilren_ptr = layout.GetBlockPtr<CellID, true>(
-                memory_ptr, storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            auto children_entries_count =
-                layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
-
-            partitioner::MultiLevelPartitionView mlp{
-                std::move(level_data), std::move(partition), std::move(cell_to_children)};
-            partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
-        }
+        std::uint32_t graph_connectivity_checksum = 0;
+        contractor::files::readGraph(
+            config.GetPath(".osrm.hsgr"), metrics, graph_connectivity_checksum);
 
-        if (boost::filesystem::exists(config.GetPath(".osrm.cells")))
+        if (turns_connectivity_checksum != graph_connectivity_checksum)
         {
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_CELLS) > 0);
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS) > 0);
-
-            auto mld_source_boundary_ptr = layout.GetBlockPtr<NodeID, true>(
-                memory_ptr, storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto mld_destination_boundary_ptr = layout.GetBlockPtr<NodeID, true>(
-                memory_ptr, storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto mld_cells_ptr = layout.GetBlockPtr<partitioner::CellStorageView::CellData, true>(
-                memory_ptr, storage::DataLayout::MLD_CELLS);
-            auto mld_cell_level_offsets_ptr = layout.GetBlockPtr<std::uint64_t, true>(
-                memory_ptr, storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            auto source_boundary_entries_count =
-                layout.GetBlockEntries(storage::DataLayout::MLD_CELL_SOURCE_BOUNDARY);
-            auto destination_boundary_entries_count =
-                layout.GetBlockEntries(storage::DataLayout::MLD_CELL_DESTINATION_BOUNDARY);
-            auto cells_entries_counts = layout.GetBlockEntries(storage::DataLayout::MLD_CELLS);
-            auto cell_level_offsets_entries_count =
-                layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);
-
-            util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
-                                                      source_boundary_entries_count);
-            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
-                                                           destination_boundary_entries_count);
-            util::vector_view<partitioner::CellStorageView::CellData> cells(mld_cells_ptr,
-                                                                            cells_entries_counts);
-            util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
-                                                           cell_level_offsets_entries_count);
-
-            partitioner::CellStorageView storage{std::move(source_boundary),
-                                                 std::move(destination_boundary),
-                                                 std::move(cells),
-                                                 std::move(level_offsets)};
-            partitioner::files::readCells(config.GetPath(".osrm.cells"), storage);
+            throw util::exception(
+                "Connectivity checksum " + std::to_string(graph_connectivity_checksum) + " in " +
+                config.GetPath(".osrm.hsgr").string() + " does not equal to checksum " +
+                std::to_string(turns_connectivity_checksum) + " in " +
+                config.GetPath(".osrm.edges").string());
         }
+    }
 
-        if (boost::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
-        {
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_CELLS) > 0);
-            BOOST_ASSERT(layout.GetBlockSize(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS) > 0);
+    if (boost::filesystem::exists(config.GetPath(".osrm.partition")))
+    {
+        auto mlp = make_partition_view(memory_ptr, layout, "/mld/multilevelpartition");
+        partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
+    }
 
-            std::vector<customizer::CellMetricView> metrics;
+    if (boost::filesystem::exists(config.GetPath(".osrm.cells")))
+    {
+        auto storage = make_cell_storage_view(memory_ptr, layout, "/mld/cellstorage");
+        partitioner::files::readCells(config.GetPath(".osrm.cells"), storage);
+    }
 
-            for (auto index : util::irange<std::size_t>(0, NUM_METRICS))
-            {
-                auto weights_block_id = static_cast<DataLayout::BlockID>(
-                    storage::DataLayout::MLD_CELL_WEIGHTS_0 + index);
-                auto durations_block_id = static_cast<DataLayout::BlockID>(
-                    storage::DataLayout::MLD_CELL_DURATIONS_0 + index);
-
-                auto weight_entries_count = layout.GetBlockEntries(weights_block_id);
-                auto duration_entries_count = layout.GetBlockEntries(durations_block_id);
-                auto mld_cell_weights_ptr =
-                    layout.GetBlockPtr<EdgeWeight, true>(memory_ptr, weights_block_id);
-                auto mld_cell_duration_ptr =
-                    layout.GetBlockPtr<EdgeDuration, true>(memory_ptr, durations_block_id);
-                util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
-                util::vector_view<EdgeDuration> durations(mld_cell_duration_ptr,
-                                                          duration_entries_count);
-
-                metrics.push_back(
-                    customizer::CellMetricView{std::move(weights), std::move(durations)});
-            }
+    if (boost::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
+    {
+        auto exclude_metrics =
+            make_cell_metric_view(memory_ptr, layout, "/mld/metrics/" + metric_name);
+        std::unordered_map<std::string, std::vector<customizer::CellMetricView>> metrics = {
+            {metric_name, std::move(exclude_metrics)},
+        };
+        customizer::files::readCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
+    }
 
-            customizer::files::readCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
-        }
+    if (boost::filesystem::exists(config.GetPath(".osrm.mldgr")))
+    {
+        auto graph_view = make_multi_level_graph_view(memory_ptr, layout, "/mld/multilevelgraph");
+        std::uint32_t graph_connectivity_checksum = 0;
+        partitioner::files::readGraph(
+            config.GetPath(".osrm.mldgr"), graph_view, graph_connectivity_checksum);
 
-        if (boost::filesystem::exists(config.GetPath(".osrm.mldgr")))
+        if (turns_connectivity_checksum != graph_connectivity_checksum)
         {
-
-            auto graph_nodes_ptr =
-                layout.GetBlockPtr<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry, true>(
-                    memory_ptr, storage::DataLayout::MLD_GRAPH_NODE_LIST);
-            auto graph_edges_ptr =
-                layout.GetBlockPtr<customizer::MultiLevelEdgeBasedGraphView::EdgeArrayEntry, true>(
-                    memory_ptr, storage::DataLayout::MLD_GRAPH_EDGE_LIST);
-            auto graph_node_to_offset_ptr =
-                layout.GetBlockPtr<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset, true>(
-                    memory_ptr, storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET);
-
-            util::vector_view<customizer::MultiLevelEdgeBasedGraphView::NodeArrayEntry> node_list(
-                graph_nodes_ptr, layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_NODE_LIST));
-            util::vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeArrayEntry> edge_list(
-                graph_edges_ptr, layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_EDGE_LIST));
-            util::vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset> node_to_offset(
-                graph_node_to_offset_ptr,
-                layout.GetBlockEntries(storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET));
-
-            std::uint32_t graph_connectivity_checksum = 0;
-            customizer::MultiLevelEdgeBasedGraphView graph_view(
-                std::move(node_list), std::move(edge_list), std::move(node_to_offset));
-            partitioner::files::readGraph(
-                config.GetPath(".osrm.mldgr"), graph_view, graph_connectivity_checksum);
-
-            if (turns_connectivity_checksum != graph_connectivity_checksum)
-            {
-                throw util::exception(
-                    "Connectivity checksum " + std::to_string(graph_connectivity_checksum) +
-                    " in " + config.GetPath(".osrm.mldgr").string() +
-                    " does not equal to checksum " + std::to_string(turns_connectivity_checksum) +
-                    " in " + config.GetPath(".osrm.edges").string());
-            }
+            throw util::exception(
+                "Connectivity checksum " + std::to_string(graph_connectivity_checksum) + " in " +
+                config.GetPath(".osrm.mldgr").string() + " does not equal to checksum " +
+                std::to_string(turns_connectivity_checksum) + " in " +
+                config.GetPath(".osrm.edges").string());
         }
+    }
 
-        // load maneuver overrides
-        {
-            const auto maneuver_overrides_ptr =
-                layout.GetBlockPtr<extractor::StorageManeuverOverride, true>(
-                    memory_ptr, DataLayout::MANEUVER_OVERRIDES);
-            const auto maneuver_override_node_sequences_ptr = layout.GetBlockPtr<NodeID, true>(
-                memory_ptr, DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES);
-
-            util::vector_view<extractor::StorageManeuverOverride> maneuver_overrides(
-                maneuver_overrides_ptr, layout.GetBlockEntries(DataLayout::MANEUVER_OVERRIDES));
-            util::vector_view<NodeID> maneuver_override_node_sequences(
-                maneuver_override_node_sequences_ptr,
-                layout.GetBlockEntries(DataLayout::MANEUVER_OVERRIDE_NODE_SEQUENCES));
-
-            extractor::files::readManeuverOverrides(config.GetPath(".osrm.maneuver_overrides"),
-                                                    maneuver_overrides,
-                                                    maneuver_override_node_sequences);
-        }
+    // load maneuver overrides
+    {
+        auto views =
+            make_maneuver_overrides_views(memory_ptr, layout, "/common/maneuver_overrides");
+        extractor::files::readManeuverOverrides(
+            config.GetPath(".osrm.maneuver_overrides"), std::get<0>(views), std::get<1>(views));
     }
 }
 }
diff --git a/unit_tests/contractor/files.cpp b/unit_tests/contractor/files.cpp
index 7c357fca1f5..e4c037f8795 100644
--- a/unit_tests/contractor/files.cpp
+++ b/unit_tests/contractor/files.cpp
@@ -15,7 +15,6 @@ using namespace osrm::unit_test;
 
 BOOST_AUTO_TEST_CASE(read_write_hsgr)
 {
-    auto reference_checksum = 0xFF00FF00;
     auto reference_connectivity_checksum = 0xDEADBEEF;
     std::vector<TestEdge> edges = {TestEdge{0, 1, 3},
                                    TestEdge{0, 5, 1},
@@ -32,26 +31,28 @@ BOOST_AUTO_TEST_CASE(read_write_hsgr)
         {true, true, true, true, true, true, true},
     };
 
+    std::unordered_map<std::string, ContractedMetric> reference_metrics = {
+        {"duration", {std::move(reference_graph), std::move(reference_filters)}}};
+
     TemporaryFile tmp{TEST_DATA_DIR "/read_write_hsgr_test.osrm.hsgr"};
-    contractor::files::writeGraph(tmp.path,
-                                  reference_checksum,
-                                  reference_graph,
-                                  reference_filters,
-                                  reference_connectivity_checksum);
+    contractor::files::writeGraph(tmp.path, reference_metrics, reference_connectivity_checksum);
 
-    unsigned checksum;
     unsigned connectivity_checksum;
-    QueryGraph graph;
-    std::vector<std::vector<bool>> filters;
-    contractor::files::readGraph(tmp.path, checksum, graph, filters, connectivity_checksum);
 
-    BOOST_CHECK_EQUAL(checksum, reference_checksum);
+    std::unordered_map<std::string, ContractedMetric> metrics = {{"duration", {}}};
+    contractor::files::readGraph(tmp.path, metrics, connectivity_checksum);
+
     BOOST_CHECK_EQUAL(connectivity_checksum, reference_connectivity_checksum);
-    BOOST_CHECK_EQUAL(filters.size(), reference_filters.size());
-    CHECK_EQUAL_COLLECTIONS(filters[0], reference_filters[0]);
-    CHECK_EQUAL_COLLECTIONS(filters[1], reference_filters[1]);
-    CHECK_EQUAL_COLLECTIONS(filters[2], reference_filters[2]);
-    CHECK_EQUAL_COLLECTIONS(filters[3], reference_filters[3]);
+    BOOST_CHECK_EQUAL(metrics["duration"].edge_filter.size(),
+                      reference_metrics["duration"].edge_filter.size());
+    CHECK_EQUAL_COLLECTIONS(metrics["duration"].edge_filter[0],
+                            reference_metrics["duration"].edge_filter[0]);
+    CHECK_EQUAL_COLLECTIONS(metrics["duration"].edge_filter[1],
+                            reference_metrics["duration"].edge_filter[1]);
+    CHECK_EQUAL_COLLECTIONS(metrics["duration"].edge_filter[2],
+                            reference_metrics["duration"].edge_filter[2]);
+    CHECK_EQUAL_COLLECTIONS(metrics["duration"].edge_filter[3],
+                            reference_metrics["duration"].edge_filter[3]);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp
index 830dc41386a..f618730af0f 100644
--- a/unit_tests/mocks/mock_datafacade.hpp
+++ b/unit_tests/mocks/mock_datafacade.hpp
@@ -197,7 +197,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
         return {};
     }
 
-    unsigned GetCheckSum() const override { return 0; }
+    std::uint32_t GetCheckSum() const override { return 0; }
 
     extractor::TravelMode GetTravelMode(const NodeID /* id */) const override
     {
diff --git a/unit_tests/storage/data_layout.cpp b/unit_tests/storage/data_layout.cpp
new file mode 100644
index 00000000000..2aa0b40ee4b
--- /dev/null
+++ b/unit_tests/storage/data_layout.cpp
@@ -0,0 +1,114 @@
+#include "storage/shared_datatype.hpp"
+
+#include "../common/range_tools.hpp"
+#include "../common/temporary_file.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <cmath>
+
+BOOST_AUTO_TEST_SUITE(data_layout)
+
+using namespace osrm;
+using namespace osrm::storage;
+
+BOOST_AUTO_TEST_CASE(layout_write_test)
+{
+    DataLayout layout;
+
+    Block block_1{20, 8 * 20};
+    Block block_2{1, 4 * 1};
+    Block block_3{100, static_cast<std::uint64_t>(std::ceil(100 / 64.))};
+
+    layout.SetBlock("block1", block_1);
+    layout.SetBlock("block2", block_2);
+    layout.SetBlock("block3", block_3);
+
+    // Canary and alignment change layout size
+    BOOST_CHECK_GT(layout.GetSizeOfLayout(),
+                   block_1.byte_size + block_2.byte_size + block_3.byte_size);
+
+    BOOST_CHECK_EQUAL(layout.GetBlockSize("block1"), block_1.byte_size);
+    BOOST_CHECK_EQUAL(layout.GetBlockSize("block2"), block_2.byte_size);
+    BOOST_CHECK_EQUAL(layout.GetBlockSize("block3"), block_3.byte_size);
+
+    std::vector<char> buffer(layout.GetSizeOfLayout());
+    auto smallest_addr = buffer.data();
+    auto biggest_addr = buffer.data() + buffer.size();
+
+    {
+        auto block_1_ptr = layout.GetBlockPtr<std::uint64_t>(buffer.data(), "block1");
+        auto block_2_ptr = layout.GetBlockPtr<std::uint32_t>(buffer.data(), "block2");
+        auto block_3_ptr = layout.GetBlockPtr<std::uint64_t>(buffer.data(), "block3");
+
+        BOOST_CHECK_LT(reinterpret_cast<std::size_t>(smallest_addr),
+                       reinterpret_cast<std::size_t>(block_1_ptr));
+        BOOST_CHECK_GT(
+            reinterpret_cast<std::size_t>(biggest_addr),
+            reinterpret_cast<std::size_t>(block_1_ptr + layout.GetBlockEntries("block1")));
+
+        BOOST_CHECK_LT(reinterpret_cast<std::size_t>(smallest_addr),
+                       reinterpret_cast<std::size_t>(block_2_ptr));
+        BOOST_CHECK_GT(
+            reinterpret_cast<std::size_t>(biggest_addr),
+            reinterpret_cast<std::size_t>(block_2_ptr + layout.GetBlockEntries("block2")));
+
+        BOOST_CHECK_LT(reinterpret_cast<std::size_t>(smallest_addr),
+                       reinterpret_cast<std::size_t>(block_3_ptr));
+        BOOST_CHECK_GT(reinterpret_cast<std::size_t>(biggest_addr),
+                       reinterpret_cast<std::size_t>(
+                           block_3_ptr + static_cast<std::size_t>(
+                                             std::ceil(layout.GetBlockEntries("block3") / 64))));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(layout_list_test)
+{
+    DataLayout layout;
+
+    Block block_1{20, 8 * 20};
+    Block block_2{1, 4 * 1};
+    Block block_3{100, static_cast<std::uint64_t>(std::ceil(100 / 64.))};
+
+    layout.SetBlock("/ch/edge_filter/block1", block_1);
+    layout.SetBlock("/ch/edge_filter/block2", block_2);
+    layout.SetBlock("/ch/edge_filter/block3", block_3);
+    layout.SetBlock("/mld/metrics/0/durations", block_2);
+    layout.SetBlock("/mld/metrics/0/weights", block_3);
+    layout.SetBlock("/mld/metrics/1/durations", block_2);
+    layout.SetBlock("/mld/metrics/1/weights", block_3);
+
+    std::vector<std::string> results_1;
+    std::vector<std::string> results_2;
+    std::vector<std::string> results_3;
+    layout.List("/ch/edge_filter", std::back_inserter(results_1));
+    layout.List("/ch/edge_filter/", std::back_inserter(results_2));
+    layout.List("/ch/", std::back_inserter(results_3));
+
+    std::vector<std::string> results_4;
+    std::vector<std::string> results_5;
+    std::vector<std::string> results_6;
+    layout.List("/mld/metrics", std::back_inserter(results_4));
+    layout.List("/mld/metrics/", std::back_inserter(results_5));
+    layout.List("/mld/", std::back_inserter(results_6));
+
+    std::vector<std::string> results_7;
+    layout.List("", std::back_inserter(results_7));
+    BOOST_CHECK_EQUAL(results_7.size(), 7);
+
+    CHECK_EQUAL_RANGE(
+        results_1, "/ch/edge_filter/block1", "/ch/edge_filter/block2", "/ch/edge_filter/block3");
+    CHECK_EQUAL_RANGE(
+        results_2, "/ch/edge_filter/block1", "/ch/edge_filter/block2", "/ch/edge_filter/block3");
+    CHECK_EQUAL_RANGE(results_3, "/ch/edge_filter");
+    CHECK_EQUAL_RANGE(results_4,
+                      "/mld/metrics/0/durations",
+                      "/mld/metrics/0/weights",
+                      "/mld/metrics/1/durations",
+                      "/mld/metrics/1/weights");
+    CHECK_EQUAL_RANGE(results_5, "/mld/metrics/0", "/mld/metrics/1");
+    CHECK_EQUAL_RANGE(results_6, "/mld/metrics");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/storage/serialization.cpp b/unit_tests/storage/serialization.cpp
index 3496d1e9cdc..e42f8ea8e5c 100644
--- a/unit_tests/storage/serialization.cpp
+++ b/unit_tests/storage/serialization.cpp
@@ -115,4 +115,29 @@ BOOST_AUTO_TEST_CASE(tar_serialize_deallocting_vector)
     }
 }
 
+BOOST_AUTO_TEST_CASE(buffer_serialize_map)
+{
+    std::map<std::string, std::int32_t> map = {
+        {"foo", 1}, {"barrrr", 2}, {"bal", 3}, {"bazbar", 4}, {"foofofofo", 5},
+    };
+
+    std::string buffer;
+    {
+        io::BufferWriter writer;
+        storage::serialization::write(writer, map);
+        buffer = writer.GetBuffer();
+    }
+
+    std::map<std::string, std::int32_t> result;
+    {
+        io::BufferReader reader(buffer);
+        storage::serialization::read(reader, result);
+    }
+
+    for (auto &pair : map)
+    {
+        BOOST_CHECK_EQUAL(pair.second, result[pair.first]);
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()