[Fuchsia] Give VMOs names

runtime/vm/pages.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/pages.h"
 
 #include "platform/address_sanitizer.h"
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
@@ skipping 38 matching lines @@
 DEFINE_FLAG(bool,
             log_code_drop,
             false,
             "Emit a log message when pointers to unused code are dropped.");
 DEFINE_FLAG(bool,
             always_drop_code,
             false,
             "Always try to drop code if the function's usage counter is >= 0");
 DEFINE_FLAG(bool, log_growth, false, "Log PageSpace growth policy decisions.");
 
-HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
+HeapPage* HeapPage::Initialize(VirtualMemory* memory,
+                               PageType type,
+                               const char* name) {
   ASSERT(memory != NULL);
   ASSERT(memory->size() > VirtualMemory::PageSize());
   bool is_executable = (type == kExecutable);

[siva, 2017/06/09 21:25:46]

Why not make Heap::RegionName a static method and call it here

const intptr_t kVmNameSize = 128;
char vm_name[kVmNameSize];
Heap::RegionName(is_executable ? Heap::kCode : Heap::kOld, vm_name,
kVmNameSize);

instead of the two blobs in PageSpace::AllocatePage and
PageSpace::AllocateLargePage and the additional parameter 'name' being passed in

[zra, 2017/06/09 21:47:35]

Same situation here. Have to pass either the name or the Heap to get at the
isolate name (or add a back pointer to HeapPage).

   // Create the new page executable (RWX) only if we're not in W^X mode
   bool create_executable = !FLAG_write_protect_code && is_executable;
-  if (!memory->Commit(create_executable)) {
+  if (!memory->Commit(create_executable, name)) {
     return NULL;
   }
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   ASSERT(result != NULL);
   result->memory_ = memory;
   result->next_ = NULL;
   result->type_ = type;
 
   LSAN_REGISTER_ROOT_REGION(result, sizeof(*result));
 
   return result;
 }
 
 
-HeapPage* HeapPage::Allocate(intptr_t size_in_words, PageType type) {
+HeapPage* HeapPage::Allocate(intptr_t size_in_words,
+                             PageType type,
+                             const char* name) {
   VirtualMemory* memory =
       VirtualMemory::Reserve(size_in_words << kWordSizeLog2);
   if (memory == NULL) {
     return NULL;
   }
-  HeapPage* result = Initialize(memory, type);
+  HeapPage* result = Initialize(memory, type, name);
   if (result == NULL) {
     delete memory;  // Release reservation to OS.
     return NULL;
   }
   return result;
 }
 
 
 void HeapPage::Deallocate() {
   bool image_page = is_image_page();
@@ skipping 124 matching lines @@
 
 
 intptr_t PageSpace::LargePageSizeInWordsFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + HeapPage::ObjectStartOffset(),
                                       VirtualMemory::PageSize());
   return page_size >> kWordSizeLog2;
 }
 
 
 HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
-  HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type);
+  const bool is_exec = (type == HeapPage::kExecutable);
+  const intptr_t kVmNameSize = 128;
+  char vm_name[kVmNameSize];
+  heap_->RegionName(is_exec ? Heap::kCode : Heap::kOld, vm_name, kVmNameSize);
+  HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type, vm_name);
   if (page == NULL) {
     return NULL;
   }
 
-  bool is_exec = (type == HeapPage::kExecutable);
-
   MutexLocker ml(pages_lock_);
   if (!is_exec) {
     if (pages_ == NULL) {
       pages_ = page;
     } else {
       pages_tail_->set_next(page);
     }
     pages_tail_ = page;
   } else {
     // Should not allocate executable pages when running from a precompiled
@@ skipping 13 matching lines @@
     }
     exec_pages_tail_ = page;
   }
   IncreaseCapacityInWordsLocked(kPageSizeInWords);
   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
-  intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
-  HeapPage* page = HeapPage::Allocate(page_size_in_words, type);
+  const bool is_exec = (type == HeapPage::kExecutable);
+  const intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
+  const intptr_t kVmNameSize = 128;
+  char vm_name[kVmNameSize];
+  heap_->RegionName(is_exec ? Heap::kCode : Heap::kOld, vm_name, kVmNameSize);
+  HeapPage* page = HeapPage::Allocate(page_size_in_words, type, vm_name);
   if (page == NULL) {
     return NULL;
   }
   page->set_next(large_pages_);
   large_pages_ = page;
   IncreaseCapacityInWords(page_size_in_words);
   // Only one object in this page (at least until String::MakeExternal or
   // Array::MakeArray is called).
   page->set_object_end(page->object_start() + size);
   return page;
@@ skipping 1024 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>(
         (static_cast<double>(gc_time) / static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart