maint: Remove use of folly/ThreadCachedInt

cpp/arcticdb/CMakeLists.txt

@@ -360,6 +360,7 @@ set(arcticdb_srcs
         util/sparse_utils.hpp
         util/storage_lock.hpp
         util/string_utils.hpp
+        util/thread_cached_int.hpp
         util/timeouts.hpp
         util/timer.hpp
         util/trace.hpp

cpp/arcticdb/util/allocator.cpp

@@ -12,8 +12,8 @@
 #include <arcticdb/util/memory_tracing.hpp>
 #include <arcticdb/util/clock.hpp>
 #include <arcticdb/util/configs_map.hpp>
+#include <arcticdb/util/thread_cached_int.hpp>
 #include <folly/concurrency/ConcurrentHashMap.h>
-#include <folly/ThreadCachedInt.h>
 
 #include <fmt/std.h>
 
@@ -152,7 +152,7 @@ namespace arcticdb {
     namespace {
         template<typename TracingPolicy, typename ClockType>
         auto& free_count_of(){
-            static folly::ThreadCachedInt<uint32_t> free_count;
+            static ThreadCachedInt<uint32_t> free_count;
             return free_count;
         };
     }

cpp/arcticdb/util/thread_cached_int.hpp

@@ -0,0 +1,76 @@
+/* Copyright 2023 Man Group Operations Limited
+ *
+ * Use of this software is governed by the Business Source License 1.1 included in the file licenses/BSL.txt.
+ *
+ * As of the Change Date specified in that file, in accordance with the Business Source License, use of this software will be governed by the Apache License, version 2.0.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <boost/thread/tss.hpp>
+
+namespace arcticdb {
+
+    template <class IntT>
+    class ThreadCachedInt {
+    public:
+        explicit ThreadCachedInt(IntT initialVal = 0, uint32_t cacheSize = 1000)
+            : target_(initialVal), cacheSize_(cacheSize) {}
+
+        ThreadCachedInt(const ThreadCachedInt&) = delete;
+        ThreadCachedInt& operator=(const ThreadCachedInt&) = delete;
+
+        void increment(IntT inc) {
+            auto cache = cache_.get();
+            if (cache == nullptr) {
+                cache = new IntCache(*this);
+                cache_.reset(cache);
+            }
+            cache->increment(inc);
+        }
+
+        // Quickly grabs the current value which may not include some cached increments.
+        IntT readFast() const {
+            return target_.load(std::memory_order_relaxed);
+        }
+
+        // Quickly reads and resets current value (doesn't reset cached increments).
+        IntT readFastAndReset() {
+            return target_.exchange(0, std::memory_order_release);
+        }
+
+    private:
+        struct IntCache;
+
+        std::atomic<IntT> target_;
+        std::atomic<uint32_t> cacheSize_;
+        boost::thread_specific_ptr<IntCache> cache_; // Must be last for dtor ordering
+
+        struct IntCache {
+            ThreadCachedInt* parent_;
+            mutable IntT val_;
+            mutable uint32_t numUpdates_;
+
+            explicit IntCache(ThreadCachedInt& parent)
+                : parent_(&parent), val_(0), numUpdates_(0) {}
+
+            void increment(IntT inc) {
+                val_ += inc;
+                ++numUpdates_;
+                if (numUpdates_ > parent_->cacheSize_.load(std::memory_order_acquire)) {
+                    flush();
+                }
+            }
+
+            void flush() const {
+                parent_->target_.fetch_add(val_, std::memory_order_release);
+                val_ = 0;
+                numUpdates_ = 0;
+            }
+
+            ~IntCache() { flush(); }
+        };
+    };
+
+} //namespace arcticdb