Update storage interface, impl, test to support dynamic head.

include/bitcoin/database/memory/interfaces/storage.hpp

@@ -67,6 +67,10 @@ class storage
     /// Allocate bytes and return offset to first allocated (or eof).
     virtual size_t allocate(size_t chunk) NOEXCEPT = 0;
 
+    /// Get remap-protected r/w access to offset (or null) allocated to size.
+    virtual memory_ptr set(size_t offset, size_t size,
+        uint8_t backfill) NOEXCEPT = 0;
+
     /// Get remap-protected r/w access to start/offset of memory map (or null).
     virtual memory_ptr get(size_t offset=zero) const NOEXCEPT = 0;
 

include/bitcoin/database/memory/map.hpp

@@ -90,6 +90,10 @@ class BCD_API map
     /// Allocate bytes and return offset to first allocated (or eof).
     size_t allocate(size_t chunk) NOEXCEPT override;
 
+    /// Get remap-protected r/w access to offset (or null) allocated to size.
+    memory_ptr set(size_t offset, size_t size,
+        uint8_t backfill) NOEXCEPT override;
+
     /// Get remap-protected r/w access to start/offset of memory map (or null).
     memory_ptr get(size_t offset=zero) const NOEXCEPT override;
 

src/memory/map.cpp

@@ -242,20 +242,54 @@ size_t map::allocate(size_t chunk) NOEXCEPT
     auto end = logical_ + chunk;
     if (end > capacity_)
     {
-        const auto size = to_capacity(end);
+        const auto new_capacity = to_capacity(end);
 
         // TODO: Could loop over a try lock here and log deadlock warning.
         std::unique_lock remap_lock(remap_mutex_);
 
         // Disk full condition leaves store in valid state despite eof return.
-        if (!remap_(size))
+        if (!remap_(new_capacity))
             return storage::eof;
     }
 
     std::swap(logical_, end);
     return end;
 }
 
+memory_ptr map::set(size_t offset, size_t size, uint8_t backfill) NOEXCEPT
+{
+    {
+        std::unique_lock field_lock(field_mutex_);
+
+        if (fault_ || !loaded_ || is_add_overflow(offset, size))
+            return {};
+
+        const auto end = std::max(logical_, offset + size);
+        if (end > capacity_)
+        {
+            const auto old_capacity = capacity_;
+            const auto new_capacity = to_capacity(end);
+
+            // TODO: Could loop over a try lock here and log deadlock warning.
+            std::unique_lock remap_lock(remap_mutex_);
+
+            // Disk full condition leaves store in valid state despite null.
+            if (!remap_(new_capacity))
+                return {};
+
+            // Fill new capacity as offset may not be at end due to expansion.
+            BC_PUSH_WARNING(NO_POINTER_ARITHMETIC)
+            std::fill_n(memory_map_ + old_capacity, new_capacity - old_capacity,
+                backfill);
+            BC_POP_WARNING()
+        }
+
+        logical_ = end;
+    }
+
+    return get(offset);
+}
+
 memory_ptr map::get(size_t offset) const NOEXCEPT
 {
     // Obtaining logical before access prevents mutual mutex wait (deadlock).