Removed default Isolate.

There is probably room for more cleanup after this...

BUG=359977
LOG=y
R=dcarney@chromium.org

Review URL: https://codereview.chromium.org/262163006

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@21167 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/api.cc b/src/api.cc
index 1fc270c..1ea45ff 100644 (file)
--- a/src/api.cc
+++ b/src/api.cc
@@ -4958,12 +4958,6 @@ void v8::V8::SetArrayBufferAllocator(
 
 
 bool v8::V8::Dispose() {
-  i::Isolate* isolate = i::Isolate::Current();
-  if (!Utils::ApiCheck(isolate != NULL && isolate->IsDefaultIsolate(),
-                       "v8::V8::Dispose()",
-                       "Use v8::Isolate::Dispose() for non-default isolate.")) {
-    return false;
-  }
   i::V8::TearDown();
   return true;
 }

diff --git a/src/d8.cc b/src/d8.cc
index 396d68b..2661fa0 100644 (file)
--- a/src/d8.cc
+++ b/src/d8.cc
@@ -1659,7 +1659,7 @@ int Shell::Main(int argc, char* argv[]) {
     v8::V8::SetArrayBufferAllocator(&array_buffer_allocator);
   }
   int result = 0;
-  Isolate* isolate = Isolate::GetCurrent();
+  Isolate* isolate = Isolate::New();
 #ifndef V8_SHARED
   v8::ResourceConstraints constraints;
   constraints.ConfigureDefaults(i::OS::TotalPhysicalMemory(),
@@ -1669,6 +1669,7 @@ int Shell::Main(int argc, char* argv[]) {
 #endif
   DumbLineEditor dumb_line_editor(isolate);
   {
+    Isolate::Scope scope(isolate);
     Initialize(isolate);
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
     vTune::InitializeVtuneForV8();

diff --git a/src/isolate.cc b/src/isolate.cc
index d93639b..dd7235b 100644 (file)
--- a/src/isolate.cc
+++ b/src/isolate.cc
@@ -103,7 +103,6 @@ v8::TryCatch* ThreadLocalTop::TryCatchHandler() {
 }
 
 
-Isolate* Isolate::default_isolate_ = NULL;
 Thread::LocalStorageKey Isolate::isolate_key_;
 Thread::LocalStorageKey Isolate::thread_id_key_;
 Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_;
@@ -166,7 +165,7 @@ void Isolate::SetCrashIfDefaultIsolateInitialized() {
 void Isolate::EnsureDefaultIsolate() {
   LockGuard<Mutex> lock_guard(&process_wide_mutex_);
   CHECK(default_isolate_status_ != kDefaultIsolateCrashIfInitialized);
-  if (default_isolate_ == NULL) {
+  if (thread_data_table_ == NULL) {
     isolate_key_ = Thread::CreateThreadLocalKey();
     thread_id_key_ = Thread::CreateThreadLocalKey();
     per_isolate_thread_data_key_ = Thread::CreateThreadLocalKey();
@@ -174,12 +173,6 @@ void Isolate::EnsureDefaultIsolate() {
     PerThreadAssertScopeBase::thread_local_key = Thread::CreateThreadLocalKey();
 #endif  // DEBUG
     thread_data_table_ = new Isolate::ThreadDataTable();
-    default_isolate_ = new Isolate();
-  }
-  // Can't use SetIsolateThreadLocals(default_isolate_, NULL) here
-  // because a non-null thread data may be already set.
-  if (Thread::GetThreadLocal(isolate_key_) == NULL) {
-    Thread::SetThreadLocal(isolate_key_, default_isolate_);
   }
 }
 
@@ -1523,9 +1516,7 @@ void Isolate::TearDown() {
     serialize_partial_snapshot_cache_ = NULL;
   }
 
-  if (!IsDefaultIsolate()) {
-    delete this;
-  }
+  delete this;
 
   // Restore the previous current isolate.
   SetIsolateThreadLocals(saved_isolate, saved_data);

diff --git a/src/isolate.h b/src/isolate.h
index 5b1e77f..97854f2 100644 (file)
--- a/src/isolate.h
+++ b/src/isolate.h
@@ -478,8 +478,6 @@ class Isolate {
 
   static void GlobalTearDown();
 
-  bool IsDefaultIsolate() const { return this == default_isolate_; }
-
   static void SetCrashIfDefaultIsolateInitialized();
   // Ensures that process-wide resources and the default isolate have been
   // allocated. It is only necessary to call this method in rare cases, for
@@ -1134,14 +1132,12 @@ class Isolate {
     DISALLOW_COPY_AND_ASSIGN(EntryStackItem);
   };
 
-  // This mutex protects highest_thread_id_, thread_data_table_ and
-  // default_isolate_.
+  // This mutex protects highest_thread_id_ and thread_data_table_.
   static Mutex process_wide_mutex_;
 
   static Thread::LocalStorageKey per_isolate_thread_data_key_;
   static Thread::LocalStorageKey isolate_key_;
   static Thread::LocalStorageKey thread_id_key_;
-  static Isolate* default_isolate_;
   static ThreadDataTable* thread_data_table_;
 
   // A global counter for all generated Isolates, might overflow.

diff --git a/src/log.cc b/src/log.cc
index 88dae56..623e08d 100644 (file)
--- a/src/log.cc
+++ b/src/log.cc
@@ -1936,58 +1936,48 @@ void Logger::LogAccessorCallbacks() {
 
 
 static void AddIsolateIdIfNeeded(Isolate* isolate, StringStream* stream) {
-  if (isolate->IsDefaultIsolate() || !FLAG_logfile_per_isolate) return;
-  stream->Add("isolate-%p-", isolate);
+  if (FLAG_logfile_per_isolate) stream->Add("isolate-%p-", isolate);
 }
 
 
 static SmartArrayPointer<const char> PrepareLogFileName(
     Isolate* isolate, const char* file_name) {
-  if (strchr(file_name, '%') != NULL || !isolate->IsDefaultIsolate()) {
-    // If there's a '%' in the log file name we have to expand
-    // placeholders.
-    HeapStringAllocator allocator;
-    StringStream stream(&allocator);
-    AddIsolateIdIfNeeded(isolate, &stream);
-    for (const char* p = file_name; *p; p++) {
-      if (*p == '%') {
-        p++;
-        switch (*p) {
-          case '\0':
-            // If there's a % at the end of the string we back up
-            // one character so we can escape the loop properly.
-            p--;
-            break;
-          case 'p':
-            stream.Add("%d", OS::GetCurrentProcessId());
-            break;
-          case 't': {
-            // %t expands to the current time in milliseconds.
-            double time = OS::TimeCurrentMillis();
-            stream.Add("%.0f", FmtElm(time));
-            break;
-          }
-          case '%':
-            // %% expands (contracts really) to %.
-            stream.Put('%');
-            break;
-          default:
-            // All other %'s expand to themselves.
-            stream.Put('%');
-            stream.Put(*p);
-            break;
+  HeapStringAllocator allocator;
+  StringStream stream(&allocator);
+  AddIsolateIdIfNeeded(isolate, &stream);
+  for (const char* p = file_name; *p; p++) {
+    if (*p == '%') {
+      p++;
+      switch (*p) {
+        case '\0':
+          // If there's a % at the end of the string we back up
+          // one character so we can escape the loop properly.
+          p--;
+          break;
+        case 'p':
+          stream.Add("%d", OS::GetCurrentProcessId());
+          break;
+        case 't': {
+          // %t expands to the current time in milliseconds.
+          double time = OS::TimeCurrentMillis();
+          stream.Add("%.0f", FmtElm(time));
+          break;
         }
-      } else {
-        stream.Put(*p);
+        case '%':
+          // %% expands (contracts really) to %.
+          stream.Put('%');
+          break;
+        default:
+          // All other %'s expand to themselves.
+          stream.Put('%');
+          stream.Put(*p);
+          break;
       }
+    } else {
+      stream.Put(*p);
     }
-    return SmartArrayPointer<const char>(stream.ToCString());
   }
-  int length = StrLength(file_name);
-  char* str = NewArray<char>(length + 1);
-  OS::MemCopy(str, file_name, length);
-  str[length] = '\0';
-  return SmartArrayPointer<const char>(str);
+  return SmartArrayPointer<const char>(stream.ToCString());
 }
 
 

diff --git a/src/mksnapshot.cc b/src/mksnapshot.cc
index a8bf871..ef0a282 100644 (file)
--- a/src/mksnapshot.cc
+++ b/src/mksnapshot.cc
@@ -393,6 +393,10 @@ int main(int argc, char** argv) {
 
   isolate->Exit();
   isolate->Dispose();
-  V8::Dispose();
+  // TODO(svenpanne) Alas, we can't cleanly dispose V8 here, because
+  // Serializer::code_address_map_ is static (a.k.a. a global variable), and
+  // disposing that would involve accessing the Isolate just disposed.
+  // code_address_map_ really has to be an instance variable...
+  // V8::Dispose();
   return 0;
 }

diff --git a/src/v8.cc b/src/v8.cc
index f8156ec..9cca201 100644 (file)
--- a/src/v8.cc
+++ b/src/v8.cc
@@ -53,16 +53,6 @@ bool V8::Initialize(Deserializer* des) {
 
 
 void V8::TearDown() {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate->IsDefaultIsolate());
-  if (!isolate->IsInitialized()) return;
-
-  // The isolate has to be torn down before clearing the LOperand
-  // caches so that the optimizing compiler thread (if running)
-  // doesn't see an inconsistent view of the lithium instructions.
-  isolate->TearDown();
-  delete isolate;
-
   Bootstrapper::TearDownExtensions();
   ElementsAccessor::TearDown();
   LOperand::TearDownCaches();

diff --git a/test/cctest/cctest.cc b/test/cctest/cctest.cc
index b1cf5ab..299c596 100644 (file)
--- a/test/cctest/cctest.cc
+++ b/test/cctest/cctest.cc
@@ -152,6 +152,7 @@ int main(int argc, char* argv[]) {
   i::TraceExtension trace_extension;
   v8::RegisterExtension(&trace_extension);
 
+  v8::V8::Initialize();
   int tests_run = 0;
   bool print_run_count = true;
   for (int i = 1; i < argc; i++) {

diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index df70d5c..1dd4337 100644 (file)
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -19269,7 +19269,6 @@ TEST(IsolateNewDispose) {
   v8::Isolate* current_isolate = CcTest::isolate();
   v8::Isolate* isolate = v8::Isolate::New();
   CHECK(isolate != NULL);
-  CHECK(!reinterpret_cast<i::Isolate*>(isolate)->IsDefaultIsolate());
   CHECK(current_isolate != isolate);
   CHECK(current_isolate == CcTest::isolate());
 
@@ -22339,6 +22338,7 @@ TEST(EventLogging) {
 
 TEST(Promises) {
   i::FLAG_harmony_promises = true;
+  i::FLAG_harmony_weak_collections = true;  // Implied
 
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();

diff --git a/test/cctest/test-microtask-delivery.cc b/test/cctest/test-microtask-delivery.cc
index cfe5d69..21177f7 100644 (file)
--- a/test/cctest/test-microtask-delivery.cc
+++ b/test/cctest/test-microtask-delivery.cc
@@ -37,6 +37,7 @@ class HarmonyIsolate {
  public:
   HarmonyIsolate() {
     i::FLAG_harmony_promises = true;
+    i::FLAG_harmony_weak_collections = true;  // Implied
     isolate_ = Isolate::New();
     isolate_->Enter();
   }