Tracks the usage of executable memory allocated by V8 and exposes the value t...

src/spaces.cc

 // Copyright 2006-2008 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 23 matching lines @@
 namespace v8 {
 namespace internal {
 
 // For contiguous spaces, top should be in the space (or at the end) and limit
 // should be the end of the space.
 #define ASSERT_SEMISPACE_ALLOCATION_INFO(info, space) \
   ASSERT((space).low() <= (info).top                  \
          && (info).top <= (space).high()              \
          && (info).limit == (space).high())
 
-intptr_t Page::watermark_invalidated_mark_ = Page::WATERMARK_INVALIDATED;
+intptr_t Page::watermark_invalidated_mark_ = 1 << Page::WATERMARK_INVALIDATED;
 
 // ----------------------------------------------------------------------------
 // HeapObjectIterator
 
 HeapObjectIterator::HeapObjectIterator(PagedSpace* space) {
   Initialize(space->bottom(), space->top(), NULL);
 }
 
 
 HeapObjectIterator::HeapObjectIterator(PagedSpace* space,
@@ skipping 204 matching lines @@
     free_list_.Free();
     allocation_list_.Free();
 }
 
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 //
 int MemoryAllocator::capacity_   = 0;
 int MemoryAllocator::size_       = 0;
+int MemoryAllocator::size_executable_ = 0;
 
 VirtualMemory* MemoryAllocator::initial_chunk_ = NULL;
 
 // 270 is an estimate based on the static default heap size of a pair of 256K
 // semispaces and a 64M old generation.
 const int kEstimatedNumberOfChunks = 270;
 List<MemoryAllocator::ChunkInfo> MemoryAllocator::chunks_(
     kEstimatedNumberOfChunks);
 List<int> MemoryAllocator::free_chunk_ids_(kEstimatedNumberOfChunks);
 int MemoryAllocator::max_nof_chunks_ = 0;
 int MemoryAllocator::top_ = 0;
 
 
 void MemoryAllocator::Push(int free_chunk_id) {
   ASSERT(max_nof_chunks_ > 0);
   ASSERT(top_ < max_nof_chunks_);
   free_chunk_ids_[top_++] = free_chunk_id;
 }
 
 
 int MemoryAllocator::Pop() {
   ASSERT(top_ > 0);
   return free_chunk_ids_[--top_];
 }
 
 
+#if defined(V8_REPORT_EXECUTABLE_MEMORY_USAGE)

[Søren Thygesen Gjesse, 2010/08/18 08:20:01]

I don't think we need this conditional compile unless this will have performance
impact being on by default.

+void *executable_memory_histogram = NULL;
+#endif
 bool MemoryAllocator::Setup(int capacity) {
   capacity_ = RoundUp(capacity, Page::kPageSize);
 
   // Over-estimate the size of chunks_ array.  It assumes the expansion of old
   // space is always in the unit of a chunk (kChunkSize) except the last
   // expansion.
   //
   // Due to alignment, allocated space might be one page less than required
   // number (kPagesPerChunk) of pages for old spaces.
   //
   // Reserve two chunk ids for semispaces, one for map space, one for old
   // space, and one for code space.
   max_nof_chunks_ = (capacity_ / (kChunkSize - Page::kPageSize)) + 5;
   if (max_nof_chunks_ > kMaxNofChunks) return false;
 
   size_ = 0;
+  size_executable_ = 0;
+#if defined(V8_REPORT_EXECUTABLE_MEMORY_USAGE)
+  executable_memory_histogram =
+      StatsTable::CreateHistogram("V8.ExecutableMemoryMax", 0, MB * 512, 50);
+#endif
   ChunkInfo info;  // uninitialized element.
   for (int i = max_nof_chunks_ - 1; i >= 0; i--) {
     chunks_.Add(info);
     free_chunk_ids_.Add(i);
   }
   top_ = max_nof_chunks_;
   return true;
 }
 
 
@@ skipping 25 matching lines @@
     return NULL;
   }
   void* mem;
   if (executable == EXECUTABLE  && CodeRange::exists()) {
     mem = CodeRange::AllocateRawMemory(requested, allocated);
   } else {
     mem = OS::Allocate(requested, allocated, (executable == EXECUTABLE));
   }
   int alloced = static_cast<int>(*allocated);
   size_ += alloced;
+
+  if (executable == EXECUTABLE) {
+    size_executable_ += alloced;
+#if defined(V8_REPORT_EXECUTABLE_MEMORY_USAGE)
+    static int size_executable_max_observed_ = 0;
+    if (size_executable_max_observed_ < size_executable_) {
+      size_executable_max_observed_ = size_executable_;
+      StatsTable::AddHistogramSample(executable_memory_histogram,
+          size_executable_);
+    }
+#endif
+  }
 #ifdef DEBUG
   ZapBlock(reinterpret_cast<Address>(mem), alloced);
 #endif
   Counters::memory_allocated.Increment(alloced);
   return mem;
 }
 
 
-void MemoryAllocator::FreeRawMemory(void* mem, size_t length) {
+void MemoryAllocator::FreeRawMemory(void* mem,
+                                    size_t length,
+                                    Executability executable) {
 #ifdef DEBUG
   ZapBlock(reinterpret_cast<Address>(mem), length);
 #endif
   if (CodeRange::contains(static_cast<Address>(mem))) {
     CodeRange::FreeRawMemory(mem, length);
   } else {
     OS::Free(mem, length);
   }
   Counters::memory_allocated.Decrement(static_cast<int>(length));
   size_ -= static_cast<int>(length);
+  if (executable == EXECUTABLE) size_executable_ -= length;
   ASSERT(size_ >= 0);
 }
 
 
 void* MemoryAllocator::ReserveInitialChunk(const size_t requested) {
   ASSERT(initial_chunk_ == NULL);
 
   initial_chunk_ = new VirtualMemory(requested);
   CHECK(initial_chunk_ != NULL);
   if (!initial_chunk_->IsReserved()) {
@@ skipping 33 matching lines @@
     requested_pages = static_cast<int>(chunk_size >> kPageSizeBits);
 
     if (requested_pages <= 0) return Page::FromAddress(NULL);
   }
   void* chunk = AllocateRawMemory(chunk_size, &chunk_size, owner->executable());
   if (chunk == NULL) return Page::FromAddress(NULL);
   LOG(NewEvent("PagedChunk", chunk, chunk_size));
 
   *allocated_pages = PagesInChunk(static_cast<Address>(chunk), chunk_size);
   if (*allocated_pages == 0) {
-    FreeRawMemory(chunk, chunk_size);
+    FreeRawMemory(chunk, chunk_size, owner->executable());
     LOG(DeleteEvent("PagedChunk", chunk));
     return Page::FromAddress(NULL);
   }
 
   int chunk_id = Pop();
   chunks_[chunk_id].init(static_cast<Address>(chunk), chunk_size, owner);
 
   return InitializePagesInChunk(chunk_id, *allocated_pages, owner);
 }
 
@@ skipping 145 matching lines @@
   // We cannot free a chunk contained in the initial chunk because it was not
   // allocated with AllocateRawMemory.  Instead we uncommit the virtual
   // memory.
   if (InInitialChunk(c.address())) {
     // TODO(1240712): VirtualMemory::Uncommit has a return value which
     // is ignored here.
     initial_chunk_->Uncommit(c.address(), c.size());
     Counters::memory_allocated.Decrement(static_cast<int>(c.size()));
   } else {
     LOG(DeleteEvent("PagedChunk", c.address()));
-    FreeRawMemory(c.address(), c.size());
+    FreeRawMemory(c.address(), c.size(), c.owner()->executable());
   }
   c.init(NULL, 0, NULL);
   Push(chunk_id);
 }
 
 
 Page* MemoryAllocator::FindFirstPageInSameChunk(Page* p) {
   int chunk_id = GetChunkId(p);
   ASSERT(IsValidChunk(chunk_id));
 
@@ skipping 1940 matching lines @@
 LargeObjectChunk* LargeObjectChunk::New(int size_in_bytes,
                                         size_t* chunk_size,
                                         Executability executable) {
   size_t requested = ChunkSizeFor(size_in_bytes);
   void* mem = MemoryAllocator::AllocateRawMemory(requested,
                                                  chunk_size,
                                                  executable);
   if (mem == NULL) return NULL;
   LOG(NewEvent("LargeObjectChunk", mem, *chunk_size));
   if (*chunk_size < requested) {
-    MemoryAllocator::FreeRawMemory(mem, *chunk_size);
+    MemoryAllocator::FreeRawMemory(mem, *chunk_size, executable);
     LOG(DeleteEvent("LargeObjectChunk", mem));
     return NULL;
   }
   return reinterpret_cast<LargeObjectChunk*>(mem);
 }
 
 
 int LargeObjectChunk::ChunkSizeFor(int size_in_bytes) {
   int os_alignment = static_cast<int>(OS::AllocateAlignment());
   if (os_alignment < Page::kPageSize)
@@ skipping 17 matching lines @@
   page_count_ = 0;
   return true;
 }
 
 
 void LargeObjectSpace::TearDown() {
   while (first_chunk_ != NULL) {
     LargeObjectChunk* chunk = first_chunk_;
     first_chunk_ = first_chunk_->next();
     LOG(DeleteEvent("LargeObjectChunk", chunk->address()));
-    MemoryAllocator::FreeRawMemory(chunk->address(), chunk->size());
+    Page* page = Page::FromAddress(chunk->address());

[Søren Thygesen Gjesse, 2010/08/18 09:36:27]

This line should be:

Page* page = Page::FromAddress(RoundUp(current->address(), Page::kPageSize));

+    Executability executable =
+        page->IsPageExecutable() ? EXECUTABLE : NOT_EXECUTABLE;
+    MemoryAllocator::FreeRawMemory(chunk->address(),
+                                   chunk->size(),
+                                   executable);
   }
 
   size_ = 0;
   page_count_ = 0;
 }
 
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void LargeObjectSpace::Protect() {
@@ skipping 43 matching lines @@
   first_chunk_ = chunk;
 
   // Initialize page header.
   Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize));
   Address object_address = page->ObjectAreaStart();
   // Clear the low order bit of the second word in the page to flag it as a
   // large object page.  If the chunk_size happened to be written there, its
   // low order bit should already be clear.
   ASSERT((chunk_size & 0x1) == 0);
   page->SetIsLargeObjectPage(true);
+  page->SetIsPageExecutable(executable);
   page->SetRegionMarks(Page::kAllRegionsCleanMarks);
   return HeapObject::FromAddress(object_address);
 }
 
 
 Object* LargeObjectSpace::AllocateRawCode(int size_in_bytes) {
   ASSERT(0 < size_in_bytes);
   return AllocateRawInternal(size_in_bytes,
                              size_in_bytes,
                              EXECUTABLE);
@@ skipping 94 matching lines @@
   LargeObjectChunk* previous = NULL;
   LargeObjectChunk* current = first_chunk_;
   while (current != NULL) {
     HeapObject* object = current->GetObject();
     if (object->IsMarked()) {
       object->ClearMark();
       MarkCompactCollector::tracer()->decrement_marked_count();
       previous = current;
       current = current->next();
     } else {
+      Page* page = Page::FromAddress(RoundUp(current->address(),
+                                     Page::kPageSize));
+      Executability executable =
+          page->IsPageExecutable() ? EXECUTABLE : NOT_EXECUTABLE;
       Address chunk_address = current->address();
       size_t chunk_size = current->size();
 
       // Cut the chunk out from the chunk list.
       current = current->next();
       if (previous == NULL) {
         first_chunk_ = current;
       } else {
         previous->set_next(current);
       }
 
       // Free the chunk.
       MarkCompactCollector::ReportDeleteIfNeeded(object);
       size_ -= static_cast<int>(chunk_size);
       page_count_--;
-      MemoryAllocator::FreeRawMemory(chunk_address, chunk_size);
+      MemoryAllocator::FreeRawMemory(chunk_address, chunk_size, executable);
       LOG(DeleteEvent("LargeObjectChunk", chunk_address));
     }
   }
 }
 
 
 bool LargeObjectSpace::Contains(HeapObject* object) {
   Address address = object->address();
   if (Heap::new_space()->Contains(address)) {
     return false;
@@ skipping 95 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal