Merge up to 8597 to experimental/gc from the bleeding edge.

src/isolate.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 172 matching lines @@
     }
 
     // Make sure we access the buffer after the wait to remove all possibility
     // of it being optimized away.
     OS::StrNCpy(local_buffer, "PreallocatedMemoryThread shutting down.\n",
                 local_buffer.length());
   }
 
 
  private:
-  explicit PreallocatedMemoryThread(Isolate* isolate)
-      : Thread(isolate, "v8:PreallocMem"),
+  PreallocatedMemoryThread()
+      : Thread("v8:PreallocMem"),
         keep_running_(true),
         wait_for_ever_semaphore_(OS::CreateSemaphore(0)),
         data_ready_semaphore_(OS::CreateSemaphore(0)),
         data_(NULL),
         length_(0) {
   }
 
   // Used to make sure that the thread keeps looping even for spurious wakeups.
   bool keep_running_;
 
   // This semaphore is used by the PreallocatedMemoryThread to wait for ever.
   Semaphore* wait_for_ever_semaphore_;
   // Semaphore to signal that the data has been initialized.
   Semaphore* data_ready_semaphore_;
 
   // Location and size of the preallocated memory block.
   char* data_;
   unsigned length_;
 
   friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(PreallocatedMemoryThread);
 };
 
 
 void Isolate::PreallocatedMemoryThreadStart() {
   if (preallocated_memory_thread_ != NULL) return;
-  preallocated_memory_thread_ = new PreallocatedMemoryThread(this);
+  preallocated_memory_thread_ = new PreallocatedMemoryThread();
   preallocated_memory_thread_->Start();
 }
 
 
 void Isolate::PreallocatedMemoryThreadStop() {
   if (preallocated_memory_thread_ == NULL) return;
   preallocated_memory_thread_->StopThread();
   // Done with the thread entirely.
   delete preallocated_memory_thread_;
   preallocated_memory_thread_ = NULL;
@@ skipping 1039 matching lines @@
   }
 #endif  // ENABLE_DEBUGGER_SUPPORT
   if (it.done()) return Handle<Context>::null();
   JavaScriptFrame* frame = it.frame();
   Context* context = Context::cast(frame->context());
   return Handle<Context>(context->global_context());
 }
 
 
 char* Isolate::ArchiveThread(char* to) {
+#ifdef ENABLE_LOGGING_AND_PROFILING
   if (RuntimeProfiler::IsEnabled() && current_vm_state() == JS) {
     RuntimeProfiler::IsolateExitedJS(this);
   }
+#endif
   memcpy(to, reinterpret_cast<char*>(thread_local_top()),
          sizeof(ThreadLocalTop));
   InitializeThreadLocal();
   return to + sizeof(ThreadLocalTop);
 }
 
 
 char* Isolate::RestoreThread(char* from) {
   memcpy(reinterpret_cast<char*>(thread_local_top()), from,
          sizeof(ThreadLocalTop));
   // This might be just paranoia, but it seems to be needed in case a
   // thread_local_top_ is restored on a separate OS thread.
 #ifdef USE_SIMULATOR
 #ifdef V8_TARGET_ARCH_ARM
   thread_local_top()->simulator_ = Simulator::current(this);
 #elif V8_TARGET_ARCH_MIPS
   thread_local_top()->simulator_ = Simulator::current(this);
 #endif
 #endif
+#ifdef ENABLE_LOGGING_AND_PROFILING
   if (RuntimeProfiler::IsEnabled() && current_vm_state() == JS) {
     RuntimeProfiler::IsolateEnteredJS(this);
   }
+  ASSERT(context() == NULL || context()->IsContext());
+#endif
   return from + sizeof(ThreadLocalTop);
 }
 
 
 Isolate::ThreadDataTable::ThreadDataTable()
     : list_(NULL) {
 }
 
 
 Isolate::PerIsolateThreadData*
@@ skipping 22 matching lines @@
 
 void Isolate::ThreadDataTable::Remove(Isolate* isolate,
                                       ThreadId thread_id) {
   PerIsolateThreadData* data = Lookup(isolate, thread_id);
   if (data != NULL) {
     Remove(data);
   }
 }
 
 
+void Isolate::ThreadDataTable::RemoveAllThreads(Isolate* isolate) {
+  PerIsolateThreadData* data = list_;
+  while (data != NULL) {
+    PerIsolateThreadData* next = data->next_;
+    if (data->isolate() == isolate) Remove(data);
+    data = next;
+  }
+}
+
+
 #ifdef DEBUG
 #define TRACE_ISOLATE(tag)                                              \
   do {                                                                  \
     if (FLAG_trace_isolates) {                                          \
       PrintF("Isolate %p " #tag "\n", reinterpret_cast<void*>(this));   \
     }                                                                   \
   } while (false)
 #else
 #define TRACE_ISOLATE(tag)
 #endif
@@ skipping 30 matching lines @@
       free_list_(0),
       preallocated_storage_preallocated_(false),
       pc_to_code_cache_(NULL),
       write_input_buffer_(NULL),
       global_handles_(NULL),
       context_switcher_(NULL),
       thread_manager_(NULL),
       ast_sentinels_(NULL),
       string_tracker_(NULL),
       regexp_stack_(NULL),
-      frame_element_constant_list_(0),
-      result_constant_list_(0),
       embedder_data_(NULL) {
   TRACE_ISOLATE(constructor);
 
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (k_isolate_address_count + 1));
 
   heap_.isolate_ = this;
   zone_.isolate_ = this;
   stack_guard_.isolate_ = this;
 
@@ skipping 14 matching lines @@
   memset(&js_spill_information_, 0, sizeof(js_spill_information_));
   memset(code_kind_statistics_, 0,
          sizeof(code_kind_statistics_[0]) * Code::NUMBER_OF_KINDS);
 #endif
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   debug_ = NULL;
   debugger_ = NULL;
 #endif
 
-#ifdef ENABLE_LOGGING_AND_PROFILING
-  producer_heap_profile_ = NULL;
-#endif
-
   handle_scope_data_.Initialize();
 
 #define ISOLATE_INIT_EXECUTE(type, name, initial_value)                        \
   name##_ = (initial_value);
   ISOLATE_INIT_LIST(ISOLATE_INIT_EXECUTE)
 #undef ISOLATE_INIT_EXECUTE
 
 #define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length)                         \
   memset(name##_, 0, sizeof(type) * length);
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
 #undef ISOLATE_INIT_ARRAY_EXECUTE
 }
 
 void Isolate::TearDown() {
   TRACE_ISOLATE(tear_down);
 
   // Temporarily set this isolate as current so that various parts of
   // the isolate can access it in their destructors without having a
   // direct pointer. We don't use Enter/Exit here to avoid
   // initializing the thread data.
   PerIsolateThreadData* saved_data = CurrentPerIsolateThreadData();
   Isolate* saved_isolate = UncheckedCurrent();
   SetIsolateThreadLocals(this, NULL);
 
   Deinit();
 
+  { ScopedLock lock(process_wide_mutex_);
+    thread_data_table_->RemoveAllThreads(this);
+  }
+
   if (!IsDefaultIsolate()) {
     delete this;
   }
 
   // Restore the previous current isolate.
   SetIsolateThreadLocals(saved_isolate, saved_data);
 }
 
 
 void Isolate::Deinit() {
@@ skipping 38 matching lines @@
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data) {
   Thread::SetThreadLocal(isolate_key_, isolate);
   Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }
 
 
 Isolate::~Isolate() {
   TRACE_ISOLATE(destructor);
 
-#ifdef ENABLE_LOGGING_AND_PROFILING
-  delete producer_heap_profile_;
-  producer_heap_profile_ = NULL;
-#endif
-
   delete unicode_cache_;
   unicode_cache_ = NULL;
 
   delete regexp_stack_;
   regexp_stack_ = NULL;
 
   delete ast_sentinels_;
   ast_sentinels_ = NULL;
 
   delete descriptor_lookup_cache_;
@@ skipping 55 matching lines @@
 
 
 bool Isolate::PreInit() {
   if (state_ != UNINITIALIZED) return true;
 
   TRACE_ISOLATE(preinit);
 
   ASSERT(Isolate::Current() == this);
 #ifdef ENABLE_DEBUGGER_SUPPORT
   debug_ = new Debug(this);
-  debugger_ = new Debugger();
-  debugger_->isolate_ = this;
+  debugger_ = new Debugger(this);
 #endif
 
   memory_allocator_ = new MemoryAllocator();
   memory_allocator_->isolate_ = this;
   code_range_ = new CodeRange();
   code_range_->isolate_ = this;
 
   // Safe after setting Heap::isolate_, initializing StackGuard and
   // ensuring that Isolate::Current() == this.
   heap_.SetStackLimits();
@@ skipping 19 matching lines @@
   pc_to_code_cache_ = new PcToCodeCache(this);
   write_input_buffer_ = new StringInputBuffer();
   global_handles_ = new GlobalHandles(this);
   bootstrapper_ = new Bootstrapper();
   handle_scope_implementer_ = new HandleScopeImplementer(this);
   stub_cache_ = new StubCache(this);
   ast_sentinels_ = new AstSentinels();
   regexp_stack_ = new RegExpStack();
   regexp_stack_->isolate_ = this;
 
-#ifdef ENABLE_LOGGING_AND_PROFILING
-  producer_heap_profile_ = new ProducerHeapProfile();
-  producer_heap_profile_->isolate_ = this;
-#endif
-
   state_ = PREINITIALIZED;
   return true;
 }
 
 
 void Isolate::InitializeThreadLocal() {
   thread_local_top_.isolate_ = this;
   thread_local_top_.Initialize();
   clear_pending_exception();
   clear_pending_message();
@@ skipping 69 matching lines @@
     stack_guard_.InitThread(lock);
   }
 
   // Setup the object heap
   ASSERT(!heap_.HasBeenSetup());
   if (!heap_.Setup(create_heap_objects)) {
     V8::SetFatalError();
     return false;
   }
 
+  InitializeThreadLocal();
+
   bootstrapper_->Initialize(create_heap_objects);
   builtins_.Setup(create_heap_objects);
 
-  InitializeThreadLocal();
-
   // Only preallocate on the first initialization.
   if (FLAG_preallocate_message_memory && preallocated_message_space_ == NULL) {
     // Start the thread which will set aside some memory.
     PreallocatedMemoryThreadStart();
     preallocated_message_space_ =
         new NoAllocationStringAllocator(
             preallocated_memory_thread_->data(),
             preallocated_memory_thread_->length());
     PreallocatedStorageInit(preallocated_memory_thread_->length() / 4);
   }
@@ skipping 99 matching lines @@
   PerIsolateThreadData* previous_thread_data = item->previous_thread_data;
   Isolate* previous_isolate = item->previous_isolate;
 
   delete item;
 
   // Reinit the current thread for the isolate it was running before this one.
   SetIsolateThreadLocals(previous_isolate, previous_thread_data);
 }
 
 
-void Isolate::ResetEagerOptimizingData() {
-  compilation_cache_->ResetEagerOptimizingData();
-}
-
-
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal