unite process/shared_memory datafacades into a single type using an allocator scheme

src/engine/datafacade/process_memory_allocator.cpp

@@ -0,0 +1,33 @@
+#include "engine/datafacade/process_memory_allocator.hpp"
+#include "storage/storage.hpp"
+
+#include "boost/assert.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+namespace datafacade
+{
+
+ProcessMemoryAllocator::ProcessMemoryAllocator(const storage::StorageConfig &config)
+{
+    storage::Storage storage(config);
+
+    // Calculate the layout/size of the memory block
+    internal_layout = std::make_unique<storage::DataLayout>();
+    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());
+}
+
+ProcessMemoryAllocator::~ProcessMemoryAllocator() {}
+
+storage::DataLayout &ProcessMemoryAllocator::GetLayout() { return *internal_layout.get(); }
+char *ProcessMemoryAllocator::GetMemory() { return internal_memory.get(); }
+
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm

src/engine/datafacade/shared_memory_allocator.cpp

@@ -0,0 +1,34 @@
+#include "engine/datafacade/shared_memory_allocator.hpp"
+#include "util/log.hpp"
+
+#include "boost/assert.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+namespace datafacade
+{
+
+SharedMemoryAllocator::SharedMemoryAllocator(storage::SharedDataType data_region)
+{
+    util::Log(logDEBUG) << "Loading new data for region " << regionToString(data_region);
+
+    BOOST_ASSERT(storage::SharedMemory::RegionExists(data_region));
+    m_large_memory = storage::makeSharedMemory(data_region);
+}
+
+SharedMemoryAllocator::~SharedMemoryAllocator() {}
+
+storage::DataLayout &SharedMemoryAllocator::GetLayout()
+{
+    return *reinterpret_cast<storage::DataLayout *>(m_large_memory->Ptr());
+}
+char *SharedMemoryAllocator::GetMemory()
+{
+    return reinterpret_cast<char *>(m_large_memory->Ptr()) + sizeof(storage::DataLayout);
+}
+
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm

src/engine/engine.cpp

@@ -3,8 +3,8 @@
 #include "engine/engine_config.hpp"
 #include "engine/status.hpp"
 
-#include "engine/datafacade/process_memory_datafacade.hpp"
-#include "engine/datafacade/shared_memory_datafacade.hpp"
+#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade/process_memory_allocator.hpp"
 
 #include "storage/shared_barriers.hpp"
 #include "util/log.hpp"
@@ -80,8 +80,11 @@ Engine::Engine(const EngineConfig &config)
         {
             throw util::exception("Invalid file paths given!" + SOURCE_REF);
         }
+        auto allocator =
+            std::make_unique<datafacade::ProcessMemoryAllocator>(config.storage_config);
         immutable_data_facade =
-            std::make_shared<const datafacade::ProcessMemoryDataFacade>(config.storage_config);
+            std::make_shared<const datafacade::ContiguousInternalMemoryDataFacade>(
+                std::move(allocator));
     }
 }