[Isolates] Merge crankshaft (r5922 from bleeding_edge).

src/isolate.cc

 // Copyright 2006-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 16 matching lines @@
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "ast.h"
 #include "bootstrapper.h"
 #include "codegen.h"
 #include "compilation-cache.h"
 #include "debug.h"
+#include "deoptimizer.h"
 #include "heap-profiler.h"
+#include "hydrogen.h"
 #include "isolate.h"
+#include "lithium-allocator.h"
 #include "log.h"
+#include "oprofile-agent.h"
 #include "regexp-stack.h"
-#include "serialize.h"
+#include "runtime-profiler.h"
 #include "scanner.h"
 #include "scopeinfo.h"
+#include "serialize.h"
 #include "simulator.h"
+#include "spaces.h"
 #include "stub-cache.h"
-#include "spaces.h"
-#include "oprofile-agent.h"
 #include "version.h"
 
+
 namespace v8 {
 namespace internal {
 
 
 // Create a dummy thread that will wait forever on a semaphore. The only
 // purpose for this thread is to have some stack area to save essential data
 // into for use by a stacks only core dump (aka minidump).
 class PreallocatedMemoryThread: public Thread {
  public:
   char* data() {
@@ skipping 101 matching lines @@
   // Done with the thread entirely.
   delete preallocated_memory_thread_;
   preallocated_memory_thread_ = NULL;
 }
 
 
 Isolate* Isolate::default_isolate_ = NULL;
 Thread::LocalStorageKey Isolate::isolate_key_;
 Thread::LocalStorageKey Isolate::thread_id_key_;
 Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_;
-Mutex* Isolate::process_wide_mutex_ = NULL;
+Mutex* Isolate::process_wide_mutex_ = OS::CreateMutex();
 Isolate::ThreadDataTable* Isolate::thread_data_table_ = NULL;
 Isolate::ThreadId Isolate::highest_thread_id_ = 0;
 
 class IsolateInitializer {
  public:
   IsolateInitializer() {
     Isolate::EnsureDefaultIsolate();
   }
 };
 
@@ skipping 45 matching lines @@
     per_thread = thread_data_table_->Lookup(this, thread_id);
     if (per_thread == NULL) {
       per_thread = AllocatePerIsolateThreadData(thread_id);
     }
   }
   return per_thread;
 }
 
 
 void Isolate::EnsureDefaultIsolate() {
-  // Assume there is only one static-initializing thread.
-  if (process_wide_mutex_ == NULL) {
-    process_wide_mutex_ = OS::CreateMutex();
-  }
-
   ScopedLock lock(process_wide_mutex_);
   if (default_isolate_ == NULL) {
     isolate_key_ = Thread::CreateThreadLocalKey();
     thread_id_key_ = Thread::CreateThreadLocalKey();
     per_isolate_thread_data_key_ = Thread::CreateThreadLocalKey();
     thread_data_table_ = new Isolate::ThreadDataTable();
     default_isolate_ = new Isolate();
   }
   // Can't use SetIsolateThreadLocals(default_isolate_, NULL) here
   // becase a non-null thread data may be already set.
@@ skipping 69 matching lines @@
 
 
 Isolate::Isolate()
     : state_(UNINITIALIZED),
       entry_stack_(NULL),
       stack_trace_nesting_level_(0),
       incomplete_message_(NULL),
       preallocated_memory_thread_(NULL),
       preallocated_message_space_(NULL),
       bootstrapper_(NULL),
+      runtime_profiler_(NULL),
       compilation_cache_(NULL),
       counters_(new Counters()),
       cpu_features_(NULL),
       code_range_(NULL),
       break_access_(OS::CreateMutex()),
       logger_(new Logger()),
       stats_table_(new StatsTable()),
       stub_cache_(NULL),
+      deoptimizer_data_(NULL),
       capture_stack_trace_for_uncaught_exceptions_(false),
       stack_trace_for_uncaught_exceptions_frame_limit_(0),
       stack_trace_for_uncaught_exceptions_options_(StackTrace::kOverview),
       transcendental_cache_(NULL),
       memory_allocator_(NULL),
       keyed_lookup_cache_(NULL),
       context_slot_cache_(NULL),
       descriptor_lookup_cache_(NULL),
       handle_scope_implementer_(NULL),
       scanner_constants_(NULL),
@@ skipping 73 matching lines @@
 
   // Restore the previous current isolate.
   SetIsolateThreadLocals(saved_isolate, saved_data);
 }
 
 
 void Isolate::Deinit() {
   if (state_ == INITIALIZED) {
     TRACE_ISOLATE(deinit);
 
+    if (FLAG_time_hydrogen) HStatistics::Instance()->Print();
+
+    // We must stop the logger before we tear down other components.
+    logger_->EnsureTickerStopped();
+
+    delete deoptimizer_data_;
+    deoptimizer_data_ = NULL;
     OProfileAgent::TearDown();
     if (FLAG_preemption) {
       v8::Locker locker;
       v8::Locker::StopPreemption();
     }
     builtins_.TearDown();
     bootstrapper_->TearDown();
 
     // Remove the external reference to the preallocated stack memory.
     delete preallocated_message_space_;
     preallocated_message_space_ = NULL;
     PreallocatedMemoryThreadStop();
 
     HeapProfiler::TearDown();
     CpuProfiler::TearDown();
+    if (runtime_profiler_ != NULL) {
+      runtime_profiler_->TearDown();
+      delete runtime_profiler_;
+      runtime_profiler_ = NULL;
+    }
     heap_.TearDown();
     logger_->TearDown();
 
     // The default isolate is re-initializable due to legacy API.
     state_ = PREINITIALIZED;
   }
 }
 
 
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
@@ skipping 180 matching lines @@
   ::assembler::arm::Simulator::Initialize();
 #elif defined(V8_TARGET_ARCH_MIPS)
   ::assembler::mips::Simulator::Initialize();
 #endif
 #endif
 
   { // NOLINT
     // Ensure that the thread has a valid stack guard.  The v8::Locker object
     // will ensure this too, but we don't have to use lockers if we are only
     // using one thread.
-    ExecutionAccess lock;
+    ExecutionAccess lock(this);
     stack_guard_.InitThread(lock);
   }
 
   // Setup the object heap
   ASSERT(!heap_.HasBeenSetup());
   if (!heap_.Setup(create_heap_objects)) {
     V8::SetFatalError();
     return false;
   }
 
@@ skipping 32 matching lines @@
   // Deserializing may put strange things in the root array's copy of the
   // stack guard.
   heap_.SetStackLimits();
 
   // Setup the CPU support. Must be done after heap setup and after
   // any deserialization because we have to have the initial heap
   // objects in place for creating the code object used for probing.
   CPU::Setup();
 
   OProfileAgent::Initialize();
+  deoptimizer_data_ = new DeoptimizerData;
+  LAllocator::Setup();
+  runtime_profiler_ = new RuntimeProfiler(this);
+  runtime_profiler_->Setup();
 
   // If we are deserializing, log non-function code objects and compiled
   // functions found in the snapshot.
   if (des != NULL && FLAG_log_code) {
     HandleScope scope;
     LOG(LogCodeObjects());
     LOG(LogCompiledFunctions());
   }
 
   state_ = INITIALIZED;
@@ skipping 64 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();
+}
+
 } }  // namespace v8::internal