Implement committed physical memory stats for Linux.

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 469 matching lines @@
     heap_->decrement_scan_on_scavenge_pages();
     ClearFlag(SCAN_ON_SCAVENGE);
   }
   next_chunk_->prev_chunk_ = prev_chunk_;
   prev_chunk_->next_chunk_ = next_chunk_;
   prev_chunk_ = NULL;
   next_chunk_ = NULL;
 }
 
 
+size_t MemoryChunk::CommittedPhysicalMemory() {
+  size_t physical;
+  size_t size = area_end_ - area_start_;

[Michael Starzinger, 2012/09/27 09:46:16]

Can we use area_size() for this calculation?

[alph, 2012/09/27 12:51:13]

Let's try. Hopefully it won't go beyond 2GB limit.

+  if (VirtualMemory::CommittedPhysicalSizeInRegion(
+          area_start_, size, &physical)) {
+    return physical;
+  } else {
+    return size;
+  }
+}
+
+
 MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
                                             Executability executable,
                                             Space* owner) {
   size_t chunk_size;
   Heap* heap = isolate_->heap();
   Address base = NULL;
   VirtualMemory reservation;
   Address area_start = NULL;
   Address area_end = NULL;
   if (executable == EXECUTABLE) {
@@ skipping 312 matching lines @@
   PageIterator iterator(this);
   while (iterator.has_next()) {
     heap()->isolate()->memory_allocator()->Free(iterator.next());
   }
   anchor_.set_next_page(&anchor_);
   anchor_.set_prev_page(&anchor_);
   accounting_stats_.Clear();
 }
 
 
+size_t PagedSpace::CommittedPhysicalMemory() {
+  size_t size = 0;
+  PageIterator it(this);
+  while (it.has_next()) {
+    size += it.next()->CommittedPhysicalMemory();
+  }
+  return size;
+}
+
+
 MaybeObject* PagedSpace::FindObject(Address addr) {
   // Note: this function can only be called on precisely swept spaces.
   ASSERT(!heap()->mark_compact_collector()->in_use());
 
   if (!Contains(addr)) return Failure::Exception();
 
   Page* p = Page::FromAddress(addr);
   HeapObjectIterator it(p, NULL);
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
     Address cur = obj->address();
@@ skipping 545 matching lines @@
     return false;
   }
   anchor()->set_next_page(anchor());
   anchor()->set_prev_page(anchor());
 
   committed_ = false;
   return true;
 }
 
 
+size_t SemiSpace::CommittedPhysicalMemory() {
+  if (!is_committed()) return 0;
+  size_t size = 0;
+  NewSpacePage* page = anchor_.next_page();

[Michael Starzinger, 2012/09/27 09:46:16]

Can we use NewSpacePageIterator for this iteration? It should work on just one
of the two SemiSpaces as well.

[alph, 2012/09/27 12:51:13]

Done.

+  CHECK(anchor_.semi_space() == this);
+  while (page != &anchor_) {
+    size += page->CommittedPhysicalMemory();
+    page = page->next_page();
+  }
+  return size;
+}
+
+
 bool SemiSpace::GrowTo(int new_capacity) {
   if (!is_committed()) {
     if (!Commit()) return false;
   }
   ASSERT((new_capacity & Page::kPageAlignmentMask) == 0);
   ASSERT(new_capacity <= maximum_capacity_);
   ASSERT(new_capacity > capacity_);
   int pages_before = capacity_ / Page::kPageSize;
   int pages_after = new_capacity / Page::kPageSize;
 
@@ skipping 1286 matching lines @@
   reinterpret_cast<Object**>(object->address())[0] =
       heap()->fixed_array_map();
   reinterpret_cast<Object**>(object->address())[1] = Smi::FromInt(0);
 #endif
 
   heap()->incremental_marking()->OldSpaceStep(object_size);
   return object;
 }
 
 
+size_t LargeObjectSpace::CommittedPhysicalMemory() {
+  size_t size = 0;
+  LargePage* current = first_page_;
+  while (current != NULL) {

[Michael Starzinger, 2012/09/27 09:46:16]

Can we use LargeObjectIterator for this iteration?

[alph, 2012/09/27 12:51:13]

I'm not sure. It returns not a page, but a HeapObject from each page.

[Michael Starzinger, 2012/09/27 13:13:28]

You are right, my bad.

+    size += current->CommittedPhysicalMemory();
+    current = current->next_page();
+  }
+  return size;
+}
+
+
 // GC support
 MaybeObject* LargeObjectSpace::FindObject(Address a) {
   LargePage* page = FindPage(a);
   if (page != NULL) {
     return page->GetObject();
   }
   return Failure::Exception();
 }
 
 
@@ skipping 184 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal