[heap] Extend mutex guards for CodeRange.

src/heap/spaces.cc

 // Copyright 2011 the V8 project 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 "src/heap/spaces.h"
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/heap/mark-compact.h"
@@ skipping 145 matching lines @@
 
 bool CodeRange::GetNextAllocationBlock(size_t requested) {
   for (current_allocation_block_index_++;
        current_allocation_block_index_ < allocation_list_.length();
        current_allocation_block_index_++) {
     if (requested <= allocation_list_[current_allocation_block_index_].size) {
       return true;  // Found a large enough allocation block.
     }
   }
 
-  {
-    base::LockGuard<base::Mutex> free_list_lock_guard(&free_list_mutex_);
-
-    // Sort and merge the free blocks on the free list and the allocation list.
-    free_list_.AddAll(allocation_list_);
-    allocation_list_.Clear();
-    free_list_.Sort(&CompareFreeBlockAddress);
-    for (int i = 0; i < free_list_.length();) {
-      FreeBlock merged = free_list_[i];
+  // Sort and merge the free blocks on the free list and the allocation list.
+  free_list_.AddAll(allocation_list_);
+  allocation_list_.Clear();
+  free_list_.Sort(&CompareFreeBlockAddress);
+  for (int i = 0; i < free_list_.length();) {
+    FreeBlock merged = free_list_[i];
+    i++;
+    // Add adjacent free blocks to the current merged block.
+    while (i < free_list_.length() &&
+           free_list_[i].start == merged.start + merged.size) {
+      merged.size += free_list_[i].size;
       i++;
-      // Add adjacent free blocks to the current merged block.
-      while (i < free_list_.length() &&
-             free_list_[i].start == merged.start + merged.size) {
-        merged.size += free_list_[i].size;
-        i++;
-      }
-      if (merged.size > 0) {
-        allocation_list_.Add(merged);
-      }
     }
-    free_list_.Clear();
+    if (merged.size > 0) {
+      allocation_list_.Add(merged);
+    }
   }
+  free_list_.Clear();
 
   for (current_allocation_block_index_ = 0;
        current_allocation_block_index_ < allocation_list_.length();
        current_allocation_block_index_++) {
     if (requested <= allocation_list_[current_allocation_block_index_].size) {
       return true;  // Found a large enough allocation block.
     }
   }
   current_allocation_block_index_ = 0;
   // Code range is full or too fragmented.
@@ skipping 31 matching lines @@
 }
 
 
 bool CodeRange::UncommitRawMemory(Address start, size_t length) {
   return code_range_->Uncommit(start, length);
 }
 
 
 void CodeRange::FreeRawMemory(Address address, size_t length) {
   DCHECK(IsAddressAligned(address, MemoryChunk::kAlignment));
-  base::LockGuard<base::Mutex> free_list_lock_guard(&free_list_mutex_);
+  base::LockGuard<base::Mutex> guard(&code_range_mutex_);
   free_list_.Add(FreeBlock(address, length));
   code_range_->Uncommit(address, length);
 }
 
 
 void CodeRange::TearDown() {
   delete code_range_;  // Frees all memory in the virtual memory range.
   code_range_ = NULL;
-  base::LockGuard<base::Mutex> free_list_lock_guard(&free_list_mutex_);
+  base::LockGuard<base::Mutex> guard(&code_range_mutex_);
   free_list_.Free();
   allocation_list_.Free();
 }
 
 
 bool CodeRange::ReserveBlock(const size_t requested_size, FreeBlock* block) {
+  base::LockGuard<base::Mutex> guard(&code_range_mutex_);
   DCHECK(allocation_list_.length() == 0 ||
          current_allocation_block_index_ < allocation_list_.length());
   if (allocation_list_.length() == 0 ||
       requested_size > allocation_list_[current_allocation_block_index_].size) {
     // Find an allocation block large enough.
     if (!GetNextAllocationBlock(requested_size)) return false;
   }
   // Commit the requested memory at the start of the current allocation block.
   size_t aligned_requested = RoundUp(requested_size, MemoryChunk::kAlignment);
   *block = allocation_list_[current_allocation_block_index_];
   // Don't leave a small free block, useless for a large object or chunk.
   if (aligned_requested < (block->size - Page::kPageSize)) {
     block->size = aligned_requested;
   }
   DCHECK(IsAddressAligned(block->start, MemoryChunk::kAlignment));
   allocation_list_[current_allocation_block_index_].start += block->size;
   allocation_list_[current_allocation_block_index_].size -= block->size;
   return true;
 }
 
 
 void CodeRange::ReleaseBlock(const FreeBlock* block) {
-  base::LockGuard<base::Mutex> free_list_lock_guard(&free_list_mutex_);
+  base::LockGuard<base::Mutex> guard(&code_range_mutex_);
   free_list_.Add(*block);
 }
 
 
 void CodeRange::ReserveEmergencyBlock() {
   const size_t requested_size = MemoryAllocator::CodePageAreaSize();
   if (emergency_block_.size == 0) {
     ReserveBlock(requested_size, &emergency_block_);
   } else {
     DCHECK(emergency_block_.size >= requested_size);
@@ skipping 2897 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8