Move memory management code into separate class for future reuse.

base/debug/activity_tracker.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/activity_tracker.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 48 matching lines @@
   ThreadRef thread_ref;
   thread_ref.as_id = 0;  // Zero the union in case other is smaller.
 #if defined(OS_WIN)
   thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
 #elif defined(OS_POSIX)
   thread_ref.as_handle = handle.platform_handle();
 #endif
   return ForThread(thread_ref.as_id);
 }
 
+ActivityTrackerMemoryAllocator::ActivityTrackerMemoryAllocator(
+    PersistentMemoryAllocator* allocator,
+    uint32_t object_type,
+    uint32_t object_free_type,
+    size_t object_size,
+    size_t cache_size)
+    : allocator_(allocator),
+      object_type_(object_type),
+      object_free_type_(object_free_type),
+      object_size_(object_size),
+      cache_size_(cache_size),
+      iterator_(allocator),
+      cache_values_(new Reference[cache_size]),
+      cache_used_(0) {
+  DCHECK(allocator);
+}
+
+ActivityTrackerMemoryAllocator::~ActivityTrackerMemoryAllocator() {}
+
+ActivityTrackerMemoryAllocator::Reference
+ActivityTrackerMemoryAllocator::GetObjectReference() {
+  // First see if there is a cached value that can be returned. This is much
+  // faster than searching the memory system for free blocks.
+  while (cache_used_ > 0) {
+    Reference cached = cache_values_[--cache_used_];
+    // Change the type of the cached object to the proper type and return it.
+    // If the type-change fails that means another thread has taken this from
+    // under us (via the search below) so ignore it and keep trying.
+    if (allocator_->ChangeType(cached, object_type_, object_free_type_))
+      return cached;
+  }
+
+  // Fetch the next "free" object from persistent memory. Rather than restart
+  // the iterator at the head each time and likely waste time going again
+  // through objects that aren't relevant, the iterator continues from where
+  // it last left off and is only reset when the end is reached. If the
+  // returned reference matches |last|, then it has wrapped without finding
+  // anything.
+  const Reference last = iterator_.GetLast();
+  while (true) {
+    uint32_t type;
+    Reference found = iterator_.GetNext(&type);
+    if (found && type == object_free_type_) {
+      // Found a free object. Change it to the proper type and return it. If
+      // the type-change fails that means another thread has taken this from
+      // under us so ignore it and keep trying.
+      if (allocator_->ChangeType(found, object_type_, object_free_type_))
+        return found;
+    }
+    if (found == last) {
+      // Wrapped. No desired object was found.
+      break;
+    }
+    if (!found) {
+      // Reached end; start over at the beginning.
+      iterator_.Reset();
+    }
+  }
+
+  // No free block was found so instead allocate a new one.
+  Reference allocated = allocator_->Allocate(object_size_, object_type_);
+  if (allocated)
+    allocator_->MakeIterable(allocated);
+  return allocated;
+}
+
+void ActivityTrackerMemoryAllocator::ReleaseObjectReference(Reference ref) {
+  // Zero the memory so that it is ready for immediate use if needed later.
+  char* mem_base = allocator_->GetAsObject<char>(ref, object_type_);
+  DCHECK(mem_base);
+  memset(mem_base, 0, object_size_);
+
+  // Mark object as free.
+  bool success = allocator_->ChangeType(ref, object_free_type_, object_type_);
+  DCHECK(success);
+
+  // Add this reference to our "free" cache if there is space. If not, the type
+  // has still been changed to indicate that it is free so this (or another)
+  // thread can find it, albeit more slowly, using the iteration method above.
+  if (cache_used_ < cache_size_)
+    cache_values_[cache_used_++] = ref;
+}
+
 // static
 void Activity::FillFrom(Activity* activity,
                         const void* origin,
                         Type type,
                         const ActivityData& data) {
   activity->time_internal = base::TimeTicks::Now().ToInternalValue();
   activity->origin_address = reinterpret_cast<uintptr_t>(origin);
   activity->activity_type = type;
   activity->data = data;
 
@@ skipping 413 matching lines @@
                                                   uint64_t id,
                                                   StringPiece name,
                                                   int stack_depth) {
   CreateWithAllocator(
       MakeUnique<LocalPersistentMemoryAllocator>(size, id, name), stack_depth);
 }
 
 ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
   DCHECK(!this_thread_tracker_.Get());
 
-  PersistentMemoryAllocator::Reference mem_reference =
-      PersistentMemoryAllocator::kReferenceNull;
-  DCHECK(!mem_reference);  // invalid_value should be checkable with !
+  PersistentMemoryAllocator::Reference mem_reference;
 
-  while (true) {
-    // Get the first available memory from the top of the FIFO.
-    if (!available_memories_.pop(&mem_reference))
-      break;
-
-    // Turn the reference back into one of the activity-tracker type. This can
-    // fail if something else has already taken the block and changed its type.
-    if (allocator_->ChangeType(mem_reference, kTypeIdActivityTracker,
-                               kTypeIdActivityTrackerFree)) {
-      break;
-    }
+  {
+    base::AutoLock autolock(thread_tracker_allocator_lock_);
+    mem_reference = thread_tracker_allocator_.GetObjectReference();
   }
 
-  // Handle the case where no known available memories were found.
   if (!mem_reference) {
-    // Allocate a block of memory from the persistent segment.
-    mem_reference =
-        allocator_->Allocate(stack_memory_size_, kTypeIdActivityTracker);
-    if (mem_reference) {
-      // Success. Make the allocation iterable so it can be found later.
-      allocator_->MakeIterable(mem_reference);
-    } else {
-      // Failure. Look for any free blocks that weren't held in the cache
-      // of available memories and try to claim it. This can happen if the
-      // |available_memories_| stack isn't sufficiently large to hold all
-      // released memories or if multiple independent processes are sharing
-      // the memory segment.
-      PersistentMemoryAllocator::Iterator iter(allocator_.get());
-      while ((mem_reference = iter.GetNextOfType(kTypeIdActivityTrackerFree)) !=
-             0) {
-        if (allocator_->ChangeType(mem_reference, kTypeIdActivityTracker,
-                                   kTypeIdActivityTrackerFree)) {
-          break;
-        }
-        mem_reference = 0;
-      }
-      if (!mem_reference) {
-        // Dobule Failure. This shouldn't happen. But be graceful if it does,
-        // probably because the underlying allocator wasn't given enough memory
-        // to satisfy all possible requests.
-        NOTREACHED();
-        // Report the thread-count at which the allocator was full so that the
-        // failure can be seen and underlying memory resized appropriately.
-        UMA_HISTOGRAM_COUNTS_1000(
-            "ActivityTracker.ThreadTrackers.MemLimitTrackerCount",
-            thread_tracker_count_.load(std::memory_order_relaxed));
-        // Return null, just as if tracking wasn't enabled.
-        return nullptr;
-      }
-    }
+    // Failure. This shouldn't happen. But be graceful if it does, probably
+    // because the underlying allocator wasn't given enough memory to satisfy
+    // to all possible requests.
+    NOTREACHED();
+    // Report the thread-count at which the allocator was full so that the
+    // failure can be seen and underlying memory resized appropriately.
+    UMA_HISTOGRAM_COUNTS_1000(
+        "ActivityTracker.ThreadTrackers.MemLimitTrackerCount",
+        thread_tracker_count_.load(std::memory_order_relaxed));
+    // Return null, just as if tracking wasn't enabled.
+    return nullptr;
   }
 
   // Convert the memory block found above into an actual memory address.
   DCHECK(mem_reference);
   void* mem_base =
       allocator_->GetAsObject<char>(mem_reference, kTypeIdActivityTracker);
   DCHECK(mem_base);
   DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
 
   // Create a tracker with the acquired memory and set it as the tracker
@@ skipping 16 matching lines @@
     delete tracker;
 }
 
 GlobalActivityTracker::GlobalActivityTracker(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
     int stack_depth)
     : allocator_(std::move(allocator)),
       stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
       this_thread_tracker_(&OnTLSDestroy),
       thread_tracker_count_(0),
-      available_memories_(kMaxThreadCount) {
+      thread_tracker_allocator_(allocator_.get(),
+                                kTypeIdActivityTracker,
+                                kTypeIdActivityTrackerFree,
+                                stack_memory_size_,
+                                kCachedThreadMemories) {
   // Ensure the passed memory is valid and empty (iterator finds nothing).
   uint32_t type;
   DCHECK(!PersistentMemoryAllocator::Iterator(allocator_.get()).GetNext(&type));
 
   // Ensure that there is no other global object and then make this one such.
   DCHECK(!g_tracker_);
   g_tracker_ = this;
 }
 
 GlobalActivityTracker::~GlobalActivityTracker() {
   DCHECK_EQ(g_tracker_, this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
   g_tracker_ = nullptr;
 }
 
 void GlobalActivityTracker::ReturnTrackerMemory(
     ManagedActivityTracker* tracker) {
   PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
   void* mem_base = tracker->mem_base_;
   DCHECK(mem_reference);
   DCHECK(mem_base);
 
-  // Zero the memory so that it is ready for use if needed again later. It's
-  // better to clear the memory now, when a thread is exiting, than to do it
-  // when it is first needed by a thread doing actual work.
-  memset(mem_base, 0, stack_memory_size_);
-
   // Remove the destructed tracker from the set of known ones.
   DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
   thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
 
-  // The memory was within the persistent memory allocator. Change its type
-  // so it is effectively marked as "free".
-  allocator_->ChangeType(mem_reference, kTypeIdActivityTrackerFree,
-                         kTypeIdActivityTracker);
-
-  // Push this on the internal cache of available memory blocks so it can
-  // be found and reused quickly. If the push somehow exceeds the maximum
-  // size of the cache, it will fail but a fallback check in CreateTracker
-  // will find it by (slow) iteration.
-  available_memories_.push(mem_reference);
+  // Release this memory for re-use at a later time.
+  base::AutoLock autolock(thread_tracker_allocator_lock_);
+  thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
 }
 
 // static
 void GlobalActivityTracker::OnTLSDestroy(void* value) {
   delete reinterpret_cast<ManagedActivityTracker*>(value);
 }
 
 ScopedActivity::ScopedActivity(const tracked_objects::Location& location,
                                uint8_t action,
                                uint32_t id,
@@ skipping 60 matching lines @@
     const base::Process* process)
     : GlobalActivityTracker::ScopedThreadActivity(
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base