fcmp++: set max arenas glibc will use

Author: j-berman

src/cryptonote_core/cryptonote_core.cpp

@@ -453,6 +453,9 @@ namespace cryptonote
   {
     start_time = std::time(nullptr);
 
+    // Necessary for FCMP++ sync on Linux platforms, especially with limited memory
+    rct::limitMaxMemArenas();
+
     const bool regtest = command_line::get_arg(vm, arg_regtest_on);
     if (test_options != NULL || regtest)
     {

src/ringct/rctSigs.cpp

@@ -44,6 +44,10 @@
 #include "device/device.hpp"
 #include "serialization/crypto.h"
 
+#if defined(__GLIBC__)
+#include <malloc.h>
+#endif
+
 using namespace crypto;
 using namespace std;
 
@@ -1747,4 +1751,26 @@ namespace rct {
       }
       return true;
     }
+
+    void limitMaxMemArenas()
+    {
+#ifdef M_ARENA_MAX
+      tools::threadpool &tpool = tools::threadpool::getInstanceForCompute();
+      const std::size_t n_threads = std::max<std::size_t>(1, tpool.get_max_concurrency());
+
+      // See mallopt and M_ARENA_MAX at: https://man7.org/linux/man-pages/man3/mallopt.3.html
+      int r = mallopt(M_ARENA_MAX, n_threads);
+      if (r == 1)
+      {
+        MDEBUG("Set max arenas to " << n_threads);
+        return;
+      }
+
+      MWARNING("Failed to set max arenas, the system may use more memory than expected during sync.");
+#else
+      MDEBUG("System does not have mallopt and M_ARENA_MAX setting. This setting is crucial for some Linux platforms to"
+        << " avoid OOM's when batch verifying FCMP++ txs. If we see OOM's in the future when batch verifying on a non-"
+        << "Linux platform, then check the system allocator behavior and see if it has a setting similar to mallopt");
+#endif
+    }
 }

src/ringct/rctSigs.h

@@ -147,6 +147,17 @@ namespace rct {
 
     // Split into batches and verify each batch in parallel
     bool batchVerifyFcmpPpProofs(std::vector<fcmp_pp::FcmpPpVerifyInput> &&fcmp_pp_verify_inputs);
+
+    // The default libc allocator on most Linux systems may cache allocated memory for reuse.
+    // As a result, verifying many large batches of FCMP++ proofs in multithreaded contexts
+    // can end up using a lot of memory that does not get released back to the OS, even
+    // though memory is already freed.
+    // This function uses the mallopt syscall to limit the max number of "arenas" the system
+    // may use, setting it to the number of threads the system has. This way there won't
+    // be more memory allocated and kept around than expected in a potentially unbounded
+    // number of arenas.
+    // More on this here: https://gotplt.org/posts/malloc-per-thread-arenas-in-glibc.html
+    void limitMaxMemArenas();
 }
 #endif  /* RCTSIGS_H */