Merge isolates to bleeding_edge.

src/heap-profiler.cc

 // Copyright 2009-2010 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 54 matching lines @@
                              const JSObjectsCluster& cluster, int size);
 };
 
 
 JSObjectsCluster Clusterizer::Clusterize(HeapObject* obj, bool fine_grain) {
   if (obj->IsJSObject()) {
     JSObject* js_obj = JSObject::cast(obj);
     String* constructor = GetConstructorNameForHeapProfile(
         JSObject::cast(js_obj));
     // Differentiate Object and Array instances.
-    if (fine_grain && (constructor == Heap::Object_symbol() ||
-                       constructor == Heap::Array_symbol())) {
+    if (fine_grain && (constructor == HEAP->Object_symbol() ||
+                       constructor == HEAP->Array_symbol())) {
       return JSObjectsCluster(constructor, obj);
     } else {
       return JSObjectsCluster(constructor);
     }
   } else if (obj->IsString()) {
-    return JSObjectsCluster(Heap::String_symbol());
+    return JSObjectsCluster(HEAP->String_symbol());
   } else if (obj->IsJSGlobalPropertyCell()) {
     return JSObjectsCluster(JSObjectsCluster::GLOBAL_PROPERTY);
   } else if (obj->IsCode() || obj->IsSharedFunctionInfo() || obj->IsScript()) {
     return JSObjectsCluster(JSObjectsCluster::CODE);
   }
   return JSObjectsCluster();
 }
 
 
 void Clusterizer::InsertIntoTree(JSObjectsClusterTree* tree,
@@ skipping 12 matching lines @@
   number_and_size.increment_number(1);
   number_and_size.increment_bytes(size);
   loc.set_value(number_and_size);
 }
 
 
 int Clusterizer::CalculateNetworkSize(JSObject* obj) {
   int size = obj->Size();
   // If 'properties' and 'elements' are non-empty (thus, non-shared),
   // take their size into account.
-  if (obj->properties() != Heap::empty_fixed_array()) {
+  if (obj->properties() != HEAP->empty_fixed_array()) {
     size += obj->properties()->Size();
   }
-  if (obj->elements() != Heap::empty_fixed_array()) {
+  if (obj->elements() != HEAP->empty_fixed_array()) {
     size += obj->elements()->Size();
   }
   // For functions, also account non-empty context and literals sizes.
   if (obj->IsJSFunction()) {
     JSFunction* f = JSFunction::cast(obj);
     if (f->unchecked_context()->IsContext()) {
       size += f->context()->Size();
     }
     if (f->literals()->length() != 0) {
       size += f->literals()->Size();
@@ skipping 38 matching lines @@
 
 
 // A printer interface implementation for the Retainers profile.
 class RetainersPrinter : public RetainerHeapProfile::Printer {
  public:
   void PrintRetainers(const JSObjectsCluster& cluster,
                       const StringStream& retainers) {
     HeapStringAllocator allocator;
     StringStream stream(&allocator);
     cluster.Print(&stream);
-    LOG(HeapSampleJSRetainersEvent(
+    LOG(ISOLATE,
+        HeapSampleJSRetainersEvent(
         *(stream.ToCString()), *(retainers.ToCString())));
   }
 };
 
 
 // Visitor for printing a cluster tree.
 class ClusterTreePrinter BASE_EMBEDDED {
  public:
   explicit ClusterTreePrinter(StringStream* stream) : stream_(stream) {}
   void Call(const JSObjectsCluster& cluster,
@@ skipping 120 matching lines @@
   if (eq.is_null()) return;
   JSObjectsRetainerTree::Locator loc;
   if (output_tree_.Insert(eq, &loc)) {
     loc.set_value(new JSObjectsClusterTree());
   }
   RetainersAggregator retainers_aggregator(coarser_, loc.value());
   tree->ForEach(&retainers_aggregator);
 }
 
 
-HeapProfiler* HeapProfiler::singleton_ = NULL;
-
 HeapProfiler::HeapProfiler()
     : snapshots_(new HeapSnapshotsCollection()),
       next_snapshot_uid_(1) {
 }
 
 
 HeapProfiler::~HeapProfiler() {
   delete snapshots_;
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 void HeapProfiler::Setup() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  if (singleton_ == NULL) {
-    singleton_ = new HeapProfiler();
+  Isolate* isolate = Isolate::Current();
+  if (isolate->heap_profiler() == NULL) {
+    isolate->set_heap_profiler(new HeapProfiler());
   }
 #endif
 }
 
 
 void HeapProfiler::TearDown() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  delete singleton_;
-  singleton_ = NULL;
+  Isolate* isolate = Isolate::Current();
+  delete isolate->heap_profiler();
+  isolate->set_heap_profiler(NULL);
 #endif
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 HeapSnapshot* HeapProfiler::TakeSnapshot(const char* name,
                                          int type,
                                          v8::ActivityControl* control) {
-  ASSERT(singleton_ != NULL);
-  return singleton_->TakeSnapshotImpl(name, type, control);
+  ASSERT(Isolate::Current()->heap_profiler() != NULL);
+  return Isolate::Current()->heap_profiler()->TakeSnapshotImpl(name,
+                                                               type,
+                                                               control);
 }
 
 
 HeapSnapshot* HeapProfiler::TakeSnapshot(String* name,
                                          int type,
                                          v8::ActivityControl* control) {
-  ASSERT(singleton_ != NULL);
-  return singleton_->TakeSnapshotImpl(name, type, control);
+  ASSERT(Isolate::Current()->heap_profiler() != NULL);
+  return Isolate::Current()->heap_profiler()->TakeSnapshotImpl(name,
+                                                               type,
+                                                               control);
 }
 
 
 void HeapProfiler::DefineWrapperClass(
     uint16_t class_id, v8::HeapProfiler::WrapperInfoCallback callback) {
-  ASSERT(singleton_ != NULL);
   ASSERT(class_id != v8::HeapProfiler::kPersistentHandleNoClassId);
-  if (singleton_->wrapper_callbacks_.length() <= class_id) {
-    singleton_->wrapper_callbacks_.AddBlock(
-        NULL, class_id - singleton_->wrapper_callbacks_.length() + 1);
+  if (wrapper_callbacks_.length() <= class_id) {
+    wrapper_callbacks_.AddBlock(
+        NULL, class_id - wrapper_callbacks_.length() + 1);
   }
-  singleton_->wrapper_callbacks_[class_id] = callback;
+  wrapper_callbacks_[class_id] = callback;
 }
 
 
 v8::RetainedObjectInfo* HeapProfiler::ExecuteWrapperClassCallback(
     uint16_t class_id, Object** wrapper) {
-  ASSERT(singleton_ != NULL);
-  if (singleton_->wrapper_callbacks_.length() <= class_id) return NULL;
-  return singleton_->wrapper_callbacks_[class_id](
+  if (wrapper_callbacks_.length() <= class_id) return NULL;
+  return wrapper_callbacks_[class_id](
       class_id, Utils::ToLocal(Handle<Object>(wrapper)));
 }
 
 
 HeapSnapshot* HeapProfiler::TakeSnapshotImpl(const char* name,
                                              int type,
                                              v8::ActivityControl* control) {
   HeapSnapshot::Type s_type = static_cast<HeapSnapshot::Type>(type);
   HeapSnapshot* result =
       snapshots_->NewSnapshot(s_type, name, next_snapshot_uid_++);
   bool generation_completed = true;
   switch (s_type) {
     case HeapSnapshot::kFull: {
-      Heap::CollectAllGarbage(true);
+      HEAP->CollectAllGarbage(true);
       HeapSnapshotGenerator generator(result, control);
       generation_completed = generator.GenerateSnapshot();
       break;
     }
     case HeapSnapshot::kAggregated: {
-      Heap::CollectAllGarbage(true);
+      HEAP->CollectAllGarbage(true);
       AggregatedHeapSnapshot agg_snapshot;
       AggregatedHeapSnapshotGenerator generator(&agg_snapshot);
       generator.GenerateSnapshot();
       generator.FillHeapSnapshot(result);
       break;
     }
     default:
       UNREACHABLE();
   }
   if (!generation_completed) {
     delete result;
     result = NULL;
   }
   snapshots_->SnapshotGenerationFinished(result);
   return result;
 }
 
 
 HeapSnapshot* HeapProfiler::TakeSnapshotImpl(String* name,
                                              int type,
                                              v8::ActivityControl* control) {
   return TakeSnapshotImpl(snapshots_->names()->GetName(name), type, control);
 }
 
 
 int HeapProfiler::GetSnapshotsCount() {
-  ASSERT(singleton_ != NULL);
-  return singleton_->snapshots_->snapshots()->length();
+  HeapProfiler* profiler = Isolate::Current()->heap_profiler();
+  ASSERT(profiler != NULL);
+  return profiler->snapshots_->snapshots()->length();
 }
 
 
 HeapSnapshot* HeapProfiler::GetSnapshot(int index) {
-  ASSERT(singleton_ != NULL);
-  return singleton_->snapshots_->snapshots()->at(index);
+  HeapProfiler* profiler = Isolate::Current()->heap_profiler();
+  ASSERT(profiler != NULL);
+  return profiler->snapshots_->snapshots()->at(index);
 }
 
 
 HeapSnapshot* HeapProfiler::FindSnapshot(unsigned uid) {
-  ASSERT(singleton_ != NULL);
-  return singleton_->snapshots_->GetSnapshot(uid);
+  HeapProfiler* profiler = Isolate::Current()->heap_profiler();
+  ASSERT(profiler != NULL);
+  return profiler->snapshots_->GetSnapshot(uid);
 }
 
 
 void HeapProfiler::ObjectMoveEvent(Address from, Address to) {
-  ASSERT(singleton_ != NULL);
-  singleton_->snapshots_->ObjectMoveEvent(from, to);
+  snapshots_->ObjectMoveEvent(from, to);
 }
 
 
 const JSObjectsClusterTreeConfig::Key JSObjectsClusterTreeConfig::kNoKey;
 const JSObjectsClusterTreeConfig::Value JSObjectsClusterTreeConfig::kNoValue;
 
 
 ConstructorHeapProfile::ConstructorHeapProfile()
     : zscope_(DELETE_ON_EXIT) {
 }
 
 
 void ConstructorHeapProfile::Call(const JSObjectsCluster& cluster,
                                   const NumberAndSizeInfo& number_and_size) {
   HeapStringAllocator allocator;
   StringStream stream(&allocator);
   cluster.Print(&stream);
-  LOG(HeapSampleJSConstructorEvent(*(stream.ToCString()),
+  LOG(ISOLATE,
+      HeapSampleJSConstructorEvent(*(stream.ToCString()),
                                    number_and_size.number(),
                                    number_and_size.bytes()));
 }
 
 
 void ConstructorHeapProfile::CollectStats(HeapObject* obj) {
   Clusterizer::InsertIntoTree(&js_objects_info_tree_, obj, false);
 }
 
 
@@ skipping 198 matching lines @@
 const JSObjectsRetainerTreeConfig::Key JSObjectsRetainerTreeConfig::kNoKey;
 const JSObjectsRetainerTreeConfig::Value JSObjectsRetainerTreeConfig::kNoValue =
     NULL;
 
 
 RetainerHeapProfile::RetainerHeapProfile()
     : zscope_(DELETE_ON_EXIT),
       aggregator_(NULL) {
   JSObjectsCluster roots(JSObjectsCluster::ROOTS);
   ReferencesExtractor extractor(roots, this);
-  Heap::IterateRoots(&extractor, VISIT_ONLY_STRONG);
+  HEAP->IterateRoots(&extractor, VISIT_ONLY_STRONG);
 }
 
 
 RetainerHeapProfile::~RetainerHeapProfile() {
   delete aggregator_;
 }
 
 
 void RetainerHeapProfile::StoreReference(const JSObjectsCluster& cluster,
                                          HeapObject* ref) {
@@ skipping 49 matching lines @@
   DeleteArray(static_cast<Address*>(trace));
   object.Dispose();
 }
 
 
 static void PrintProducerStackTrace(Object* obj, void* trace) {
   if (!obj->IsJSObject()) return;
   String* constructor = GetConstructorNameForHeapProfile(JSObject::cast(obj));
   SmartPointer<char> s_name(
       constructor->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL));
-  LOG(HeapSampleJSProducerEvent(GetConstructorName(*s_name),
+  LOG(ISOLATE,
+      HeapSampleJSProducerEvent(GetConstructorName(*s_name),
                                 reinterpret_cast<Address*>(trace)));
 }
 
 
 void HeapProfiler::WriteSample() {
-  LOG(HeapSampleBeginEvent("Heap", "allocated"));
-  LOG(HeapSampleStats(
-      "Heap", "allocated", Heap::CommittedMemory(), Heap::SizeOfObjects()));
+  Isolate* isolate = Isolate::Current();
+  LOG(isolate, HeapSampleBeginEvent("Heap", "allocated"));
+  LOG(isolate,
+      HeapSampleStats(
+          "Heap", "allocated", HEAP->CommittedMemory(), HEAP->SizeOfObjects()));
 
   AggregatedHeapSnapshot snapshot;
   AggregatedHeapSnapshotGenerator generator(&snapshot);
   generator.GenerateSnapshot();
 
   HistogramInfo* info = snapshot.info();
   for (int i = FIRST_NONSTRING_TYPE;
        i <= AggregatedHeapSnapshotGenerator::kAllStringsType;
        ++i) {
     if (info[i].bytes() > 0) {
-      LOG(HeapSampleItemEvent(info[i].name(), info[i].number(),
+      LOG(isolate,
+          HeapSampleItemEvent(info[i].name(), info[i].number(),
                               info[i].bytes()));
     }
   }
 
   snapshot.js_cons_profile()->PrintStats();
   snapshot.js_retainer_profile()->PrintStats();
 
-  GlobalHandles::IterateWeakRoots(PrintProducerStackTrace,
-                                  StackWeakReferenceCallback);
+  isolate->global_handles()->IterateWeakRoots(PrintProducerStackTrace,
+                                              StackWeakReferenceCallback);
 
-  LOG(HeapSampleEndEvent("Heap", "allocated"));
+  LOG(isolate, HeapSampleEndEvent("Heap", "allocated"));
 }
 
 
 AggregatedHeapSnapshot::AggregatedHeapSnapshot()
     : info_(NewArray<HistogramInfo>(
         AggregatedHeapSnapshotGenerator::kAllStringsType + 1)) {
 #define DEF_TYPE_NAME(name) info_[name].set_name(#name);
   INSTANCE_TYPE_LIST(DEF_TYPE_NAME);
 #undef DEF_TYPE_NAME
   info_[AggregatedHeapSnapshotGenerator::kAllStringsType].set_name(
@@ skipping 313 matching lines @@
   agg_snapshot_->js_cons_profile()->ForEach(&alloc_cons_iter);
   entries_map.AllocateEntries();
 
   // Fill up references.
   IterateRetainers<AllocatingRetainersIterator>(&allocator, &entries_map);
 
   snapshot->SetDominatorsToSelf();
 }
 
 
-bool ProducerHeapProfile::can_log_ = false;
-
 void ProducerHeapProfile::Setup() {
   can_log_ = true;
 }
 
 void ProducerHeapProfile::DoRecordJSObjectAllocation(Object* obj) {
   ASSERT(FLAG_log_producers);
   if (!can_log_) return;
   int framesCount = 0;
   for (JavaScriptFrameIterator it; !it.done(); it.Advance()) {
     ++framesCount;
   }
   if (framesCount == 0) return;
   ++framesCount;  // Reserve place for the terminator item.
   Vector<Address> stack(NewArray<Address>(framesCount), framesCount);
   int i = 0;
   for (JavaScriptFrameIterator it; !it.done(); it.Advance()) {
     stack[i++] = it.frame()->pc();
   }
   stack[i] = NULL;
-  Handle<Object> handle = GlobalHandles::Create(obj);
-  GlobalHandles::MakeWeak(handle.location(),
-                          static_cast<void*>(stack.start()),
-                          StackWeakReferenceCallback);
+  Handle<Object> handle = isolate_->global_handles()->Create(obj);
+  isolate_->global_handles()->MakeWeak(handle.location(),
+                                       static_cast<void*>(stack.start()),
+                                       StackWeakReferenceCallback);
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 } }  // namespace v8::internal