Make CodeAllocatorCinder stats fields atomic

Summary: Convert `lost_bytes_`, `huge_allocs_`, and `fragmented_allocs_` to `std::atomic` so their getters can be called without holding the allocator mutex. Also switch `used_bytes_` accesses in subclasses to explicit `fetch_add` with relaxed ordering.

Reviewed By: alexmalyshev

Differential Revision: D97004723

fbshipit-source-id: 7c52abfd9a8c806963acfcea5dcc845fe624829b

Author: yoney

cinderx/Jit/code_allocator.cpp

@@ -147,13 +147,13 @@ AllocateResult CodeAllocatorCinder::addCode(asmjit::CodeHolder* code) {
   size_t max_code_size = code->codeSize();
   size_t alloc_size = ((max_code_size / kAllocSize) + 1) * kAllocSize;
   if (current_alloc_free_ < max_code_size) {
-    lost_bytes_ += current_alloc_free_;
+    lost_bytes_.fetch_add(current_alloc_free_, std::memory_order_relaxed);
 
     uint8_t* res = allocPages(alloc_size);
     if (!setHugePages(res, alloc_size)) {
-      fragmented_allocs_++;
+      fragmented_allocs_.fetch_add(1, std::memory_order_relaxed);
     } else {
-      huge_allocs_++;
+      huge_allocs_.fetch_add(1, std::memory_order_relaxed);
     }
     current_alloc_ = static_cast<uint8_t*>(res);
     allocations_.emplace_back(res, alloc_size);
@@ -186,7 +186,7 @@ AllocateResult CodeAllocatorCinder::addCode(asmjit::CodeHolder* code) {
 
   current_alloc_ += actual_code_size;
   current_alloc_free_ -= actual_code_size;
-  used_bytes_ += actual_code_size;
+  used_bytes_.fetch_add(actual_code_size, std::memory_order_relaxed);
 
   return AllocateResult{addr, asmjit::kErrorOk};
 }
@@ -264,7 +264,7 @@ AllocateResult MultipleSectionCodeAllocator::addCode(asmjit::CodeHolder* code) {
   }
 
   size_t potential_code_size = code->codeSize();
-  used_bytes_ += potential_code_size;
+  used_bytes_.fetch_add(potential_code_size, std::memory_order_relaxed);
   // We fall back to the default size of code allocation if the
   // code doesn't fit into either section, and we can make this check more
   // granular by comparing sizes section-by-section.

cinderx/Jit/code_allocator.h

@@ -53,15 +53,15 @@ class CodeAllocatorCinder : public CodeAllocator {
   ~CodeAllocatorCinder() override;
 
   size_t lostBytes() const {
-    return lost_bytes_;
+    return lost_bytes_.load(std::memory_order_relaxed);
   }
 
   size_t fragmentedAllocs() const {
-    return fragmented_allocs_;
+    return fragmented_allocs_.load(std::memory_order_relaxed);
   }
 
   size_t hugeAllocs() const {
-    return huge_allocs_;
+    return huge_allocs_.load(std::memory_order_relaxed);
   }
 
   AllocateResult addCode(asmjit::CodeHolder* code) override;
@@ -84,11 +84,11 @@ class CodeAllocatorCinder : public CodeAllocator {
 
   // Number of bytes in total lost when allocations didn't fit neatly into
   // the bytes remaining in a chunk so a new one was allocated.
-  size_t lost_bytes_{0};
+  std::atomic<size_t> lost_bytes_{0};
   // Number of chunks allocated (= to number of huge pages used)
-  size_t huge_allocs_{0};
+  std::atomic<size_t> huge_allocs_{0};
   // Number of chunks allocated which did not use huge pages.
-  size_t fragmented_allocs_{0};
+  std::atomic<size_t> fragmented_allocs_{0};
 };
 
 class MultipleSectionCodeAllocator : public CodeAllocator {