Expose more detailed memory statistics

src/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 309 matching lines @@
   // TODO(gc) make code_range part of memory allocator?
   ASSERT(size_ >= size);
   size_ -= size;
 
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
   if (executable == EXECUTABLE) {
     ASSERT(size_executable_ >= size);
     size_executable_ -= size;
   }
-  if (isolate_->code_range()->contains(static_cast<Address>(base))) {
+  if (isolate_->code_range()->contains(base)) {
     ASSERT(executable == EXECUTABLE);
     isolate_->code_range()->FreeRawMemory(base, size);
   } else {
     ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
     bool result = VirtualMemory::ReleaseRegion(base, size);
     USE(result);
     ASSERT(result);
   }
 }
 
@@ skipping 207 matching lines @@
 #endif
 
     area_start = base + Page::kObjectStartOffset;
     area_end = base + chunk_size;
   }
 
   isolate_->counters()->memory_allocated()->
       Increment(static_cast<int>(chunk_size));
 
   LOG(isolate_, NewEvent("MemoryChunk", base, chunk_size));
-  if (owner != NULL) {
-    ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());
-    PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
+
+  ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());

[Michael Starzinger, 2012/06/25 15:49:19]

The deoptimizer (i.e. Deoptimizer::CreateCode) uses this allocation method
without providing a valid owner.

+  PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
+
+  switch (owner->identity()) {
+    case OLD_POINTER_SPACE:
+      isolate_->counters()->old_pointer_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->old_pointer_space_bytes_used()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case OLD_DATA_SPACE:
+      isolate_->counters()->old_data_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->old_data_space_bytes_allocated()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case CODE_SPACE:
+      isolate_->counters()->code_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->code_space_bytes_allocated()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case MAP_SPACE:
+      isolate_->counters()->map_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->map_space_bytes_allocated()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case CELL_SPACE:
+      isolate_->counters()->cell_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->cell_space_bytes_allocated()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case LO_SPACE:
+      isolate_->counters()->lo_space_bytes_allocated()->
+          Increment(static_cast<int>(chunk_size));
+      isolate_->counters()->lo_space_bytes_allocated()->
+          Set(static_cast<int>(owner->SizeOfObjects()));
+      break;
+
+    case NEW_SPACE:
+      // NEW_SPACE is released using ReserveAlignedMemory and CommitBlock.
+
+    default:
+      UNREACHABLE();
   }
 
   MemoryChunk* result = MemoryChunk::Initialize(heap,
                                                 base,
                                                 chunk_size,
                                                 area_start,
                                                 area_end,
                                                 executable,
                                                 owner);
   result->set_reserved_memory(&reservation);
@@ skipping 16 matching lines @@
                                               Space* owner,
                                               Executability executable) {
   MemoryChunk* chunk = AllocateChunk(object_size, executable, owner);
   if (chunk == NULL) return NULL;
   return LargePage::Initialize(isolate_->heap(), chunk);
 }
 
 
 void MemoryAllocator::Free(MemoryChunk* chunk) {
   LOG(isolate_, DeleteEvent("MemoryChunk", chunk));
-  if (chunk->owner() != NULL) {
-    ObjectSpace space =
-        static_cast<ObjectSpace>(1 << chunk->owner()->identity());
-    PerformAllocationCallback(space, kAllocationActionFree, chunk->size());
-  }
+  size_t chunk_size;
+  ObjectSpace space =
+      static_cast<ObjectSpace>(1 << chunk->owner()->identity());
+  PerformAllocationCallback(space, kAllocationActionFree, chunk->size());
 
   isolate_->heap()->RememberUnmappedPage(
       reinterpret_cast<Address>(chunk), chunk->IsEvacuationCandidate());
 
   delete chunk->slots_buffer();
   delete chunk->skip_list();
 
   VirtualMemory* reservation = chunk->reserved_memory();
   if (reservation->IsReserved()) {
+    chunk_size = reservation->size();
     FreeMemory(reservation, chunk->executable());
   } else {
+    chunk_size = chunk->size();
     FreeMemory(chunk->address(),
                chunk->size(),
                chunk->executable());
   }
+
+  switch (chunk->owner()->identity()) {
+    case OLD_POINTER_SPACE:
+      isolate_->counters()->old_pointer_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case OLD_DATA_SPACE:
+      isolate_->counters()->old_data_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case CODE_SPACE:
+      isolate_->counters()->code_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case MAP_SPACE:
+      isolate_->counters()->map_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case CELL_SPACE:
+      isolate_->counters()->cell_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case LO_SPACE:
+      isolate_->counters()->lo_space_bytes_allocated()->
+          Decrement(static_cast<int>(chunk_size));
+      break;
+
+    case NEW_SPACE:
+      // NEW_SPACE is released using UncommitBlock.
+
+    default:
+      UNREACHABLE();
+  }
 }
 
 
 bool MemoryAllocator::CommitBlock(Address start,
                                   size_t size,
                                   Executability executable) {
   if (!VirtualMemory::CommitRegion(start, size, executable)) return false;
 #ifdef DEBUG
   ZapBlock(start, size);
 #endif
   isolate_->counters()->memory_allocated()->Increment(static_cast<int>(size));
+  isolate_->counters()->new_space_bytes_allocated()->Increment(
+      static_cast<int>(size));
   return true;
 }
 
 
 bool MemoryAllocator::UncommitBlock(Address start, size_t size) {
   if (!VirtualMemory::UncommitRegion(start, size)) return false;
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
+  isolate_->counters()->new_space_bytes_allocated()->Decrement(
+      static_cast<int>(size));
   return true;
 }
 
 
 void MemoryAllocator::ZapBlock(Address start, size_t size) {
   for (size_t s = 0; s + kPointerSize <= size; s += kPointerSize) {
     Memory::Address_at(start + s) = kZapValue;
   }
 }
 
@@ skipping 2212 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal