Add thread memory tracker util class to compute object size

Summary:
Add a util class `ThreadMemoryTracker` to help compute object size when enabling size-awareness.
The basic idea is
- Use Jemalloc util function(`thread.allocatedp` and `thread.deallocatedp`) to calculate allocated memory and deallocated memory in the current thread:
```
  memory usage = allocate memory - deallocated memory
```
- Get the currently used memory before and after the object construction, the difference is the object memory:
```
   get before memory usage
   ...construct object
   get after memory usage
   object size = after memory usage - before memory usage

```

Example:
```
// initialize memory tracker only at the beginning
ThreadMemoryTracke tMemTracker;
...

auto beforeMemUsage = tMemTracker.getMemUsageBytes();
...construct the object
auto afterMemUsage = tMemTracker.getMemUsageBytes();
auto objectSize = LIKELY(afterMemUsage > beforeMemUsage)
                        ? (afterMemUsage - beforeMemUsage)
                        : 0;
```

Reviewed By: therealgymmy

Differential Revision: D40958506

fbshipit-source-id: 967c214ab7b96b9787f20ba55c6eb6c0771a90b1

Author: Jiayue Bao

cachelib/experimental/objcache2/util/ThreadMemoryTracker.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/logging/xlog.h>
+#include <folly/memory/Malloc.h>
+
+namespace facebook {
+namespace cachelib {
+namespace objcache2 {
+
+// Tracks the memory usage in a local thread.
+// Use this class to calculate the object size when enabling size-awareness.
+// Example:
+//      ThreadMemoryTracker tMemTracker;
+//      auto beforeMemUsage = tMemTracker.getMemUsageBytes();
+//      ... create the object
+//      auto afterMemUsage = tMemTracker.getMemUsageBytes();
+//      ...
+//      auto objectSize = LIKELY(afterMemUsage > beforeMemUsage) ?
+//                        (afterMemUsage - beforeMemUsage) : 0;
+class ThreadMemoryTracker {
+ public:
+  ThreadMemoryTracker() {
+    if (folly::usingJEMalloc()) {
+      size_t size = sizeof(uint64_t*);
+      mallctl("thread.allocatedp", &allocPtr_, &size, nullptr, 0);
+      mallctl("thread.deallocatedp", &deallocPtr_, &size, nullptr, 0);
+    }
+  }
+
+  size_t getMemUsageBytes() {
+    if (!allocPtr_ || !deallocPtr_) {
+      return 0;
+    }
+    if (*allocPtr_ < *deallocPtr_) {
+      return 0;
+    }
+    return *allocPtr_ - *deallocPtr_;
+  }
+
+ private:
+  // pointer of the total number of bytes ever allocated by the calling thread
+  uint64_t* allocPtr_{nullptr};
+  // pointer of the total number of bytes ever deallocated by the calling thread
+  uint64_t* deallocPtr_{nullptr};
+};
+} // namespace objcache2
+} // namespace cachelib
+} // namespace facebook

cachelib/experimental/objcache2/util/tests/ThreadMemoryTrackerTest.cpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Benchmark.h>
+#include <gtest/gtest.h>
+
+#include "cachelib/experimental/objcache2/util/ThreadMemoryTracker.h"
+
+namespace facebook {
+namespace cachelib {
+namespace objcache2 {
+namespace test {
+using Object = std::array<char, 16>;
+
+static const size_t expected =
+    folly::usingJEMalloc() ? folly::goodMallocSize(sizeof(Object)) : 0;
+
+TEST(ThreadMemoryTrackerTest, Basic) {
+  ThreadMemoryTracker tMemTracker;
+  auto beforeMemUsage = tMemTracker.getMemUsageBytes();
+  auto ptr = std::make_unique<Object>();
+  folly::doNotOptimizeAway(ptr);
+  auto afterMemUsage = tMemTracker.getMemUsageBytes();
+  auto objectSize = LIKELY(afterMemUsage > beforeMemUsage)
+                        ? (afterMemUsage - beforeMemUsage)
+                        : 0;
+  EXPECT_EQ(objectSize, expected);
+}
+
+TEST(ThreadMemoryTrackerTest, Iteration) {
+  ThreadMemoryTracker tMemTracker;
+  for (auto i = 0; i < 100; i++) {
+    auto beforeMemUsage = tMemTracker.getMemUsageBytes();
+    auto ptr = std::make_unique<Object>();
+    folly::doNotOptimizeAway(ptr);
+    auto afterMemUsage = tMemTracker.getMemUsageBytes();
+    auto objectSize = LIKELY(afterMemUsage > beforeMemUsage)
+                          ? (afterMemUsage - beforeMemUsage)
+                          : 0;
+    EXPECT_EQ(objectSize, expected);
+  }
+}
+
+} // namespace test
+} // namespace objcache2
+} // namespace cachelib
+} // namespace facebook