use MemoryUsage

3 files changed, 27 insertions, 13 deletions

diff --git a/vespalib/src/tests/util/reusable_set/reusable_set_test.cpp b/vespalib/src/tests/util/reusable_set/reusable_set_test.cpp
index bc3db27a2fd..8450366ffa5 100644
--- a/vespalib/src/tests/util/reusable_set/reusable_set_test.cpp
+++ b/vespalib/src/tests/util/reusable_set/reusable_set_test.cpp
@@ -94,8 +94,8 @@ TEST_F(Pool, reuse_works)
         verify_handle(handle, 248, i+1, 0);
         exercise(handle);
     }
-    EXPECT_TRUE(500 < pool.memory_usage());
-    EXPECT_TRUE(1000 > pool.memory_usage());
+    EXPECT_TRUE(500 < pool.memory_usage().allocatedBytes());
+    EXPECT_TRUE(1000 > pool.memory_usage().allocatedBytes());
     for (int i = 0; i < 5; ++i) {
         auto handle = pool.get(7);
         EXPECT_EQ(65535+i, pool.reuse_count());
@@ -112,17 +112,21 @@ TEST_F(Pool, reuse_works)
         EXPECT_EQ(3, pool.create_count());
         verify_handle(handle4, 400, 1, 0);
         exercise(handle4);
+        EXPECT_TRUE(1000 < pool.memory_usage().usedBytes());
+        EXPECT_TRUE(2000 > pool.memory_usage().usedBytes());
     }
+    EXPECT_TRUE(500 < pool.memory_usage().usedBytes());
+    EXPECT_TRUE(1000 > pool.memory_usage().usedBytes());
     auto handle7 = pool.get(401);
     EXPECT_EQ(4, pool.create_count());
     verify_handle(handle7, 480, 1, 0);
     exercise(handle7);
-    EXPECT_TRUE(1000 < pool.memory_usage());
-    EXPECT_TRUE(3000 > pool.memory_usage());
+    EXPECT_TRUE(1000 < pool.memory_usage().allocatedBytes());
+    EXPECT_TRUE(3000 > pool.memory_usage().allocatedBytes());
     auto handle8 = pool.get(2500);
     auto handle9 = pool.get(2500);
-    EXPECT_TRUE(11000 < pool.memory_usage());
-    EXPECT_TRUE(13000 > pool.memory_usage());
+    EXPECT_TRUE(11000 < pool.memory_usage().allocatedBytes());
+    EXPECT_TRUE(13000 > pool.memory_usage().allocatedBytes());
 }
 
 GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/vespa/vespalib/util/memoryusage.h b/vespalib/src/vespa/vespalib/util/memoryusage.h
index 84bf39fde10..0ab339d1262 100644
--- a/vespalib/src/vespa/vespalib/util/memoryusage.h
+++ b/vespalib/src/vespa/vespalib/util/memoryusage.h
@@ -35,6 +35,7 @@ public:
     void incAllocatedBytes(size_t inc) { _allocatedBytes += inc; }
     void decAllocatedBytes(size_t dec) { _allocatedBytes -= dec; }
     void incUsedBytes(size_t inc) { _usedBytes += inc; }
+    void decUsedBytes(size_t dec) { _usedBytes -= dec; }
     void incDeadBytes(size_t inc) { _deadBytes += inc; }
     void incAllocatedBytesOnHold(size_t inc) { _allocatedBytesOnHold += inc; }
     void decAllocatedBytesOnHold(size_t inc) { _allocatedBytesOnHold -= inc; }
diff --git a/vespalib/src/vespa/vespalib/util/reusable_set_pool.h b/vespalib/src/vespa/vespalib/util/reusable_set_pool.h
index 7e3562a3d72..1af2b76dedc 100644
--- a/vespalib/src/vespa/vespalib/util/reusable_set_pool.h
+++ b/vespalib/src/vespa/vespalib/util/reusable_set_pool.h
@@ -4,6 +4,7 @@
 
 #include "reusable_set.h"
 #include "reusable_set_handle.h"
+#include "memoryusage.h"
 
 #include <vector>
 #include <mutex>
@@ -20,10 +21,10 @@ class ReusableSetPool
     using RSUP = std::unique_ptr<ReusableSet>;
     using Guard = std::lock_guard<std::mutex>;
     std::vector<RSUP> _lru_stack;
-    std::mutex _lock;
+    mutable std::mutex _lock;
     size_t _reuse_count;
     size_t _create_count;
-    size_t _total_memory_used;
+    MemoryUsage _total_memory;
     const size_t _min_size;
     const size_t _grow_percent;
 
@@ -34,9 +35,11 @@ public:
     ReusableSetPool()
       : _lru_stack(), _lock(),
         _reuse_count(0), _create_count(0),
-        _total_memory_used(sizeof(ReusableSetPool)),
+        _total_memory(),
         _min_size(248), _grow_percent(20)
-    {}
+    {
+        _total_memory.incAllocatedBytes(sizeof(ReusableSetPool));
+    }
 
     /** Create or re-use a set with (at least) the given size. */
     ReusableSetHandle get(size_t size) {
@@ -48,30 +51,36 @@ public:
             if (r->capacity() >= size) {
                 r->clear();
                 ++_reuse_count;
+                _total_memory.incUsedBytes(r->memory_usage());
                 return ReusableSetHandle(std::move(r), *this);
             }
-            _total_memory_used -= r->memory_usage();
+            _total_memory.decAllocatedBytes(r->memory_usage());
             last_used_size = std::max(last_used_size, r->capacity());
         }
         double grow_factor = (1.0 + _grow_percent / 100.0);
         last_used_size *= grow_factor;
         size_t at_least_size = std::max(_min_size, last_used_size);
         RSUP r = std::make_unique<ReusableSet>(std::max(at_least_size, size));
+        _total_memory.incAllocatedBytes(r->memory_usage());
         ++_create_count;
-        _total_memory_used += r->memory_usage();
+        _total_memory.incUsedBytes(r->memory_usage());
         return ReusableSetHandle(std::move(r), *this);
     }
 
     /** Return a ReusableSet to the pool. */
     void reuse(RSUP used) {
         Guard guard(_lock);
+        _total_memory.decUsedBytes(used->memory_usage());
         _lru_stack.push_back(std::move(used));
     }
 
     // for unit testing and statistics
     size_t reuse_count() const { return _reuse_count; }
     size_t create_count() const { return _create_count; }
-    size_t memory_usage() const { return _total_memory_used; }
+    MemoryUsage memory_usage() const {
+        Guard guard(_lock);
+        return _total_memory;
+    }
 };
 
 } // namespace