Nest per-table storage settings.

builds/gnu/Makefile.am

@@ -227,6 +227,7 @@ include_bitcoin_database_memory_HEADERS = \
     ${srcdir}/../../include/bitcoin/database/memory/mmaps.hpp \
     ${srcdir}/../../include/bitcoin/database/memory/mstage.hpp \
     ${srcdir}/../../include/bitcoin/database/memory/reader.hpp \
+    ${srcdir}/../../include/bitcoin/database/memory/settings.hpp \
     ${srcdir}/../../include/bitcoin/database/memory/streamers.hpp \
     ${srcdir}/../../include/bitcoin/database/memory/utilities.hpp
 

builds/msvc/vs2026/libbitcoin-database/libbitcoin-database.vcxproj

@@ -161,6 +161,7 @@
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\mmaps.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\mstage.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\reader.hpp" />
+    <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\settings.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\streamers.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\utilities.hpp" />
     <ClInclude Include="..\..\..\..\include\bitcoin\database\primitives\arrayhead.hpp" />

builds/msvc/vs2026/libbitcoin-database/libbitcoin-database.vcxproj.filters

@@ -197,6 +197,9 @@
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\mstage.hpp">
       <Filter>include\bitcoin\database\memory</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\settings.hpp">
+      <Filter>include\bitcoin\database\memory</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\..\include\bitcoin\database\memory\reader.hpp">
       <Filter>include\bitcoin\database\memory</Filter>
     </ClInclude>

include/bitcoin/database/impl/memory/mmap.ipp

@@ -32,25 +32,25 @@ namespace database {
 // ----------------------------------------------------------------------------
 
 TEMPLATE
-CLASS::mmap(const path& filename, size_t minimum, size_t expansion,
+CLASS::mmap(const path& filename, const storage_settings& settings,
     bool random, bool staged) NOEXCEPT
     requires (is_one(columns))
   : filenames_{ filename },
-    minimum_(to_rows(minimum)),
-    expansion_(expansion),
+    minimum_(to_rows(settings.size)),
+    expansion_(settings.rate),
     random_(random),
     staged_(staged),
     opened_{ file::invalid }
 {
 }
 
 TEMPLATE
-CLASS::mmap(const paths& filenames, size_t minimum, size_t expansion,
+CLASS::mmap(const paths& filenames, const storage_settings& settings,
     bool random, bool staged) NOEXCEPT
     requires (columns > one)
   : filenames_(filenames),
-    minimum_(to_rows(minimum)),
-    expansion_(expansion),
+    minimum_(to_rows(settings.size)),
+    expansion_(settings.rate),
     random_(random),
     staged_(staged),
     opened_{}

include/bitcoin/database/impl/store/store.ipp

@@ -31,79 +31,79 @@ CLASS::store(const settings& config) NOEXCEPT
     // Archive.
     // ------------------------------------------------------------------------
 
-    header_head_(head(config.path / schema::dir::heads, schema::archive::header), 1, 0, random),
-    header_body_(body(config.path, schema::archive::header), config.header_size, config.header_rate, sequential, staged),
+    header_head_(head(config.path / schema::dir::heads, schema::archive::header), head_settings, random),
+    header_body_(body(config.path, schema::archive::header), config.header, sequential, staged),
 
-    input_head_(head(config.path / schema::dir::heads, schema::archive::input), 1, 0, sequential),
-    input_body_(body(config.path, schema::archive::input), config.input_size, config.input_rate, sequential, staged),
+    input_head_(head(config.path / schema::dir::heads, schema::archive::input), head_settings, sequential),
+    input_body_(body(config.path, schema::archive::input), config.input, sequential, staged),
 
-    output_head_(head(config.path / schema::dir::heads, schema::archive::output), 1, 0, sequential),
-    output_body_(body(config.path, schema::archive::output), config.output_size, config.output_rate, sequential, staged),
+    output_head_(head(config.path / schema::dir::heads, schema::archive::output), head_settings, sequential),
+    output_body_(body(config.path, schema::archive::output), config.output, sequential, staged),
 
-    ins_head_(head(config.path / schema::dir::heads, schema::archive::ins), 1, 0, random),
-    ins_body_(body(config.path, schema::archive::ins), config.ins_size, config.ins_rate, sequential, staged),
+    ins_head_(head(config.path / schema::dir::heads, schema::archive::ins), head_settings, random),
+    ins_body_(body(config.path, schema::archive::ins), config.ins, sequential, staged),
 
-    outs_head_(head(config.path / schema::dir::heads, schema::archive::outs), 1, 0, sequential),
-    outs_body_(body(config.path, schema::archive::outs), config.outs_size, config.outs_rate, sequential, staged),
+    outs_head_(head(config.path / schema::dir::heads, schema::archive::outs), head_settings, sequential),
+    outs_body_(body(config.path, schema::archive::outs), config.outs, sequential, staged),
 
-    tx_head_(head(config.path / schema::dir::heads, schema::archive::tx), 1, 0, random),
-    tx_body_(body(config.path, schema::archive::tx), config.tx_size, config.tx_rate, sequential, staged),
+    tx_head_(head(config.path / schema::dir::heads, schema::archive::tx), head_settings, random),
+    tx_body_(body(config.path, schema::archive::tx), config.tx, sequential, staged),
 
-    txs_head_(head(config.path / schema::dir::heads, schema::archive::txs), 1, 0, random),
-    txs_body_(body(config.path, schema::archive::txs), config.txs_size, config.txs_rate, sequential, staged),
+    txs_head_(head(config.path / schema::dir::heads, schema::archive::txs), head_settings, random),
+    txs_body_(body(config.path, schema::archive::txs), config.txs, sequential, staged),
 
     // Indexes.
     // ------------------------------------------------------------------------
 
-    candidate_head_(head(config.path / schema::dir::heads, schema::indexes::candidate), 1, 0, sequential),
-    candidate_body_(body(config.path, schema::indexes::candidate), config.candidate_size, config.candidate_rate, sequential, staged),
+    candidate_head_(head(config.path / schema::dir::heads, schema::indexes::candidate), head_settings, sequential),
+    candidate_body_(body(config.path, schema::indexes::candidate), config.candidate, sequential, staged),
 
-    confirmed_head_(head(config.path / schema::dir::heads, schema::indexes::confirmed), 1, 0, sequential),
-    confirmed_body_(body(config.path, schema::indexes::confirmed), config.confirmed_size, config.confirmed_rate, sequential, staged),
+    confirmed_head_(head(config.path / schema::dir::heads, schema::indexes::confirmed), head_settings, sequential),
+    confirmed_body_(body(config.path, schema::indexes::confirmed), config.confirmed, sequential, staged),
 
-    strong_tx_head_(head(config.path / schema::dir::heads, schema::indexes::strong_tx), 1, 0, random),
-    strong_tx_body_(body(config.path, schema::indexes::strong_tx), config.strong_tx_size, config.strong_tx_rate, sequential, staged),
+    strong_tx_head_(head(config.path / schema::dir::heads, schema::indexes::strong_tx), head_settings, random),
+    strong_tx_body_(body(config.path, schema::indexes::strong_tx), config.strong_tx, sequential, staged),
 
     // Caches.
     // ------------------------------------------------------------------------
 
     // TODO: body not random, but keep in memory.
-    ecdsa_head_(head(config.path / schema::dir::heads, schema::caches::ecdsa), 1, 0, sequential),
-    ecdsa_body_(body(config.path, schema::caches::ecdsa), config.ecdsa_size, config.ecdsa_rate, sequential, staged),
+    ecdsa_head_(head(config.path / schema::dir::heads, schema::caches::ecdsa), head_settings, sequential),
+    ecdsa_body_(body(config.path, schema::caches::ecdsa), config.ecdsa, sequential, staged),
 
     // TODO: body not random, but keep in memory.
-    schnorr_head_(head(config.path / schema::dir::heads, schema::caches::schnorr), 1, 0, sequential),
-    schnorr_body_(body(config.path, schema::caches::schnorr), config.schnorr_size, config.schnorr_rate, sequential, staged),
+    schnorr_head_(head(config.path / schema::dir::heads, schema::caches::schnorr), head_settings, sequential),
+    schnorr_body_(body(config.path, schema::caches::schnorr), config.schnorr, sequential, staged),
 
-    silent_head_(head(config.path / schema::dir::heads, schema::caches::silent), 1, 0, sequential),
-    silent_body_(body(config.path, schema::caches::silent), config.silent_size, config.silent_rate, sequential, staged),
+    silent_head_(head(config.path / schema::dir::heads, schema::caches::silent), head_settings, sequential),
+    silent_body_(body(config.path, schema::caches::silent), config.silent, sequential, staged),
 
-    duplicate_head_(head(config.path / schema::dir::heads, schema::caches::duplicate), 1, 0, random),
-    duplicate_body_(body(config.path, schema::caches::duplicate), config.duplicate_size, config.duplicate_rate, sequential, staged),
+    duplicate_head_(head(config.path / schema::dir::heads, schema::caches::duplicate), head_settings, random),
+    duplicate_body_(body(config.path, schema::caches::duplicate), config.duplicate, sequential, staged),
 
-    prevalid_head_(head(config.path / schema::dir::heads, schema::caches::prevalid), 1, 0, sequential),
-    prevalid_body_(body(config.path, schema::caches::prevalid), config.prevalid_size, config.prevalid_rate, sequential, staged),
+    prevalid_head_(head(config.path / schema::dir::heads, schema::caches::prevalid), head_settings, sequential),
+    prevalid_body_(body(config.path, schema::caches::prevalid), config.prevalid, sequential, staged),
 
-    prevout_head_(head(config.path / schema::dir::heads, schema::caches::prevout), 1, 0, random),
-    prevout_body_(body(config.path, schema::caches::prevout), config.prevout_size, config.prevout_rate, sequential, staged),
+    prevout_head_(head(config.path / schema::dir::heads, schema::caches::prevout), head_settings, random),
+    prevout_body_(body(config.path, schema::caches::prevout), config.prevout, sequential, staged),
 
-    validated_bk_head_(head(config.path / schema::dir::heads, schema::caches::validated_bk), 1, 0, random),
-    validated_bk_body_(body(config.path, schema::caches::validated_bk), config.validated_bk_size, config.validated_bk_rate, sequential, staged),
+    validated_bk_head_(head(config.path / schema::dir::heads, schema::caches::validated_bk), head_settings, random),
+    validated_bk_body_(body(config.path, schema::caches::validated_bk), config.validated_bk, sequential, staged),
 
-    validated_tx_head_(head(config.path / schema::dir::heads, schema::caches::validated_tx), 1, 0, random),
-    validated_tx_body_(body(config.path, schema::caches::validated_tx), config.validated_tx_size, config.validated_tx_rate, sequential, staged),
+    validated_tx_head_(head(config.path / schema::dir::heads, schema::caches::validated_tx), head_settings, random),
+    validated_tx_body_(body(config.path, schema::caches::validated_tx), config.validated_tx, sequential, staged),
 
     // Optionals.
     // ------------------------------------------------------------------------
 
-    address_head_(head(config.path / schema::dir::heads, schema::optionals::address), 1, 0, random),
-    address_body_(body(config.path, schema::optionals::address), config.address_size, config.address_rate, sequential, staged),
+    address_head_(head(config.path / schema::dir::heads, schema::optionals::address), head_settings, random),
+    address_body_(body(config.path, schema::optionals::address), config.address, sequential, staged),
 
-    filter_bk_head_(head(config.path / schema::dir::heads, schema::optionals::filter_bk), 1, 0, random),
-    filter_bk_body_(body(config.path, schema::optionals::filter_bk), config.filter_bk_size, config.filter_bk_rate, sequential, staged),
+    filter_bk_head_(head(config.path / schema::dir::heads, schema::optionals::filter_bk), head_settings, random),
+    filter_bk_body_(body(config.path, schema::optionals::filter_bk), config.filter_bk, sequential, staged),
 
-    filter_tx_head_(head(config.path / schema::dir::heads, schema::optionals::filter_tx), 1, 0, random),
-    filter_tx_body_(body(config.path, schema::optionals::filter_tx), config.filter_tx_size, config.filter_tx_rate, sequential, staged),
+    filter_tx_head_(head(config.path / schema::dir::heads, schema::optionals::filter_tx), head_settings, random),
+    filter_tx_body_(body(config.path, schema::optionals::filter_tx), config.filter_tx, sequential, staged),
 
     // Locks.
     // ------------------------------------------------------------------------
@@ -114,30 +114,30 @@ CLASS::store(const settings& config) NOEXCEPT
     // Tables.
     // ------------------------------------------------------------------------
 
-    header(header_head_, header_body_, config.header_buckets),
+    header(header_head_, header_body_, config.header.buckets),
     input(input_head_, input_body_),
     output(output_head_, output_body_),
-    ins(ins_head_, ins_body_, config.ins_buckets),
+    ins(ins_head_, ins_body_, config.ins.buckets),
     outs(outs_head_, outs_body_),
-    tx(tx_head_, tx_body_, config.tx_buckets),
-    txs(txs_head_, txs_body_, config.txs_buckets),
+    tx(tx_head_, tx_body_, config.tx.buckets),
+    txs(txs_head_, txs_body_, config.txs.buckets),
 
     candidate(candidate_head_, candidate_body_),
     confirmed(confirmed_head_, confirmed_body_),
-    strong_tx(strong_tx_head_, strong_tx_body_, config.strong_tx_buckets),
+    strong_tx(strong_tx_head_, strong_tx_body_, config.strong_tx.buckets),
 
     ecdsa(ecdsa_head_, ecdsa_body_),
     schnorr(schnorr_head_, schnorr_body_),
     silent(silent_head_, silent_body_),
-    duplicate(duplicate_head_, duplicate_body_, config.duplicate_buckets),
+    duplicate(duplicate_head_, duplicate_body_, config.duplicate.buckets),
     prevalid(prevalid_head_, prevalid_body_),
-    prevout(prevout_head_, prevout_body_, config.prevout_buckets),
-    validated_bk(validated_bk_head_, validated_bk_body_, config.validated_bk_buckets),
-    validated_tx(validated_tx_head_, validated_tx_body_, config.validated_tx_buckets),
+    prevout(prevout_head_, prevout_body_, config.prevout.buckets),
+    validated_bk(validated_bk_head_, validated_bk_body_, config.validated_bk.buckets),
+    validated_tx(validated_tx_head_, validated_tx_body_, config.validated_tx.buckets),
 
-    address(address_head_, address_body_, config.address_buckets),
-    filter_bk(filter_bk_head_, filter_bk_body_, config.filter_bk_buckets),
-    filter_tx(filter_tx_head_, filter_tx_body_, config.filter_tx_buckets)
+    address(address_head_, address_body_, config.address.buckets),
+    filter_bk(filter_bk_head_, filter_bk_body_, config.filter_bk.buckets),
+    filter_tx(filter_tx_head_, filter_tx_body_, config.filter_tx.buckets)
 {
 }
 

include/bitcoin/database/memory/mmap.hpp

@@ -32,6 +32,7 @@
 #include <bitcoin/database/memory/accessor.hpp>
 #include <bitcoin/database/memory/interfaces/storage.hpp>
 #include <bitcoin/database/memory/mstage.hpp>
+#include <bitcoin/database/memory/settings.hpp>
 
 namespace libbitcoin {
 namespace database {
@@ -68,13 +69,16 @@ class mmap
     /// file only by explicit transfer, so no dirty file-backed page ever
     /// exists (no effect where the staging backend is not built).
 
-    /// Scalar construction (columns == 1): unchanged signature and codegen.
-    mmap(const path& filename, size_t minimum=1, size_t expansion=0,
+    /// Storage tuning is passed by settings (future tunables land there
+    /// without signature change); random and staged are structural.
+
+    /// Scalar construction (columns == 1).
+    mmap(const path& filename, const storage_settings& settings={},
         bool random=true, bool staged=false) NOEXCEPT
         requires (is_one(columns));
 
     /// Aggregate construction (columns > 1): one file per column, shared guards.
-    mmap(const paths& filenames, size_t minimum=1, size_t expansion=0,
+    mmap(const paths& filenames, const storage_settings& settings={},
         bool random=true, bool staged=false) NOEXCEPT
         requires (columns > one);
 

include/bitcoin/database/memory/mmaps.hpp

@@ -51,17 +51,18 @@ class mmaps
         }...
     };
 
-    mmaps(const path& base_path, size_t size, size_t rate,
+    mmaps(const path& base_path, const storage_settings& settings,
         bool random_access, bool staged=false) NOEXCEPT
-      : mmaps(base_path, size, rate, random_access, staged, sequence)
+      : mmaps(base_path, settings, random_access, staged, sequence)
     {
     }
 
 protected:
     template <size_t... Index>
-    mmaps(const path& base_path, size_t size, size_t rate, bool random_access,
-        bool staged, std::index_sequence<Index...>) NOEXCEPT
-      : base(paths{ to_subpath(base_path, suffixes[Index])... }, size, rate,
+    mmaps(const path& base_path, const storage_settings& settings,
+        bool random_access, bool staged,
+        std::index_sequence<Index...>) NOEXCEPT
+      : base(paths{ to_subpath(base_path, suffixes[Index])... }, settings,
           random_access, staged),
         base_path_{ base_path }
     {

include/bitcoin/database/memory/settings.hpp

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2011-2026 libbitcoin developers
+ *
+ * This file is part of libbitcoin.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef LIBBITCOIN_DATABASE_MEMORY_SETTINGS_HPP
+#define LIBBITCOIN_DATABASE_MEMORY_SETTINGS_HPP
+
+#include <bitcoin/database/define.hpp>
+
+namespace libbitcoin {
+namespace database {
+
+/// Storage tuning consumed by memory map construction: the base of table
+/// configuration, as network settings bases are derived by server services.
+/// Future staging tunables land here without constructor signature changes.
+struct storage_settings
+{
+    /// Minimum body allocation (bytes).
+    uint64_t size{ 1 };
+
+    /// Body expansion rate (percentage).
+    uint16_t rate{ 5 };
+};
+
+} // namespace database
+} // namespace libbitcoin
+
+#endif