Log getMemoryLoad()

Author: Sjors

src/interfaces/mining.h

@@ -23,6 +23,12 @@ class CScript;
 
 namespace interfaces {
 
+//! Tracks memory usage for template-bound transactions.
+struct MemoryLoad
+{
+    uint64_t usage{0};
+};
+
 //! Block template interface
 class BlockTemplate
 {
@@ -129,6 +135,12 @@ class Mining
      * For signets the challenge verification is skipped when check_pow is false.
      */
     virtual bool checkBlock(const CBlock& block, const node::BlockCheckOptions& options, std::string& reason, std::string& debug) = 0;
+
+    /**
+     * Returns the current memory load for template transactions outside the
+     * mempool.
+     */
+    virtual MemoryLoad getMemoryLoad() = 0;
 };
 
 } // namespace interfaces

src/ipc/capnp/mining.capnp

@@ -19,6 +19,7 @@ interface Mining $Proxy.wrap("interfaces::Mining") {
     waitTipChanged @3 (context :Proxy.Context, currentTip: Data, timeout: Float64) -> (result: Common.BlockRef);
     createNewBlock @4 (options: BlockCreateOptions) -> (result: BlockTemplate);
     checkBlock @5 (block: Data, options: BlockCheckOptions) -> (reason: Text, debug: Text, result: Bool);
+    getMemoryLoad @6 (context :Proxy.Context) -> (result: MemoryLoad);
 }
 
 interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
@@ -36,6 +37,10 @@ interface BlockTemplate $Proxy.wrap("interfaces::BlockTemplate") {
     interruptWait @11() -> ();
 }
 
+struct MemoryLoad $Proxy.wrap("interfaces::MemoryLoad") {
+    usage @0 :UInt64;
+}
+
 struct BlockCreateOptions $Proxy.wrap("node::BlockCreateOptions") {
     useMempool @0 :Bool $Proxy.name("use_mempool");
     blockReservedWeight @1 :UInt64 $Proxy.name("block_reserved_weight");

src/sv2/template_provider.cpp

@@ -17,6 +17,8 @@
 #include <algorithm>
 #include <limits>
 
+using interfaces::MemoryLoad;
+
 // Allow a few seconds for clients to submit a block or to request transactions
 constexpr size_t STALE_TEMPLATE_GRACE_PERIOD{10};
 
@@ -110,6 +112,8 @@ bool Sv2TemplateProvider::Start(const Sv2TemplateProviderOptions& options)
     }
 
     m_thread_sv2_handler = std::thread(&util::TraceThread, "sv2", [this] { ThreadSv2Handler(); });
+    m_thread_memory_handler = std::thread(&util::TraceThread, "memory", [this] { ThreadMemoryHandler(); });
+
     return true;
 }
 
@@ -154,6 +158,9 @@ void Sv2TemplateProvider::StopThreads()
     if (m_thread_sv2_handler.joinable()) {
         m_thread_sv2_handler.join();
     }
+    if (m_thread_memory_handler.joinable()) {
+        m_thread_memory_handler.join();
+    }
 }
 
 class Timer {
@@ -249,6 +256,26 @@ void Sv2TemplateProvider::ThreadSv2Handler()
 
 }
 
+void Sv2TemplateProvider::ThreadMemoryHandler()
+{
+    size_t seconds{0};
+    while (!m_flag_interrupt_sv2) {
+        std::this_thread::sleep_for(1000ms);
+        if (++seconds % 60 != 0) continue;
+        if (m_mining.isInitialBlockDownload()) continue;
+        try {
+            MemoryLoad memory_load{m_mining.getMemoryLoad()};
+            const double usage_mib{static_cast<double>(memory_load.usage) / (1024.0 * 1024.0)};
+            const std::string usage_mib_str{strprintf("%.3f", usage_mib)};
+            LogTrace(BCLog::SV2, "Template memory footprint %s MiB", usage_mib_str);
+        } catch (const ipc::Exception& e) {
+            LogTrace(BCLog::SV2, "getMemoryLoad() not implemented on the node");
+            // Nothing to do for this thread
+            break;
+        }
+    }
+}
+
 void Sv2TemplateProvider::ThreadSv2ClientHandler(size_t client_id)
 {
     try {

src/sv2/template_provider.h

@@ -81,6 +81,11 @@ class Sv2TemplateProvider : public Sv2EventsInterface
      */
     std::thread m_thread_sv2_handler;
 
+    /**
+     * Memory management thread
+     */
+    std::thread m_thread_memory_handler;
+
     /**
      * Signal for handling interrupts and stopping the template provider event loop.
      */
@@ -129,6 +134,11 @@ class Sv2TemplateProvider : public Sv2EventsInterface
      */
     void ThreadSv2Handler() EXCLUSIVE_LOCKS_REQUIRED(!m_tp_mutex);
 
+    /**
+     * Template memory management thread.
+     */
+    void ThreadMemoryHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_tp_mutex);
+
     /**
      * Give each client its own thread so they're treated equally
      * and so that newly connected clients don't have to wait.

src/test/sv2_mock_mining.cpp

@@ -123,6 +123,13 @@ std::unique_ptr<interfaces::BlockTemplate> MockMining::createNewBlock(const node
 }
 bool MockMining::checkBlock(const CBlock&, const node::BlockCheckOptions&, std::string&, std::string&) { return true; }
 
+MemoryLoad MockMining::getMemoryLoad()
+{
+    return {
+        .usage = 0
+    };
+}
+
 uint64_t MockMining::GetTemplateSeq()
 {
     LOCK(state->m);

src/test/sv2_mock_mining.h

@@ -17,6 +17,8 @@
 #include <sync.h>
 #include <uint256.h>
 
+using interfaces::MemoryLoad;
+
 // Minimal mocks for the Mining IPC interface used by sv2 tests.
 
 struct MockEvent {
@@ -82,6 +84,7 @@ class MockMining : public interfaces::Mining {
     std::optional<interfaces::BlockRef> waitTipChanged(uint256, MillisecondsDouble) override;
     std::unique_ptr<interfaces::BlockTemplate> createNewBlock(const node::BlockCreateOptions&) override;
     bool checkBlock(const CBlock&, const node::BlockCheckOptions&, std::string&, std::string&) override;
+    MemoryLoad getMemoryLoad() override;
 
     // Accessors for tests (thread-safe)
     uint64_t GetTemplateSeq();