Initial isolate reload support

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1434 matching lines @@
   if (osr_id != kNoOSRDeoptId) {
     event_name = "CompileFunctionOptimizedOSR";
   } else if (IsBackgroundCompilation()) {
     event_name = "CompileFunctionOptimizedBackground";
   } else {
     event_name = "CompileFunctionOptimized";
   }
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, event_name, function);
 )  // !PRODUCT
 
-  // Optimization must happen in non-mutator/Dart thread if background
-  // compilation is on. OSR compilation still occurs in the main thread.
-  ASSERT((osr_id != kNoOSRDeoptId) || !FLAG_background_compilation ||
-         !thread->IsMutatorThread());
+  // If we are in the optimizing in the mutator/Dart thread, then
+  // this is either an OSR compilation or background compilation is
+  // not currently allowed.
+  ASSERT(!thread->IsMutatorThread() ||
+         (osr_id != kNoOSRDeoptId) ||
+         !FLAG_background_compilation || BackgroundCompiler::IsDisabled());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline,
                                function,
                                true,  /* optimized */
                                osr_id);
 }
 
 
 // This is only used from unit tests.
@@ skipping 87 matching lines @@
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::EvaluateStaticInitializer(field);
   }
 #endif
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
   LongJumpScope jump;
+  Thread* thread = Thread::Current();
   if (setjmp(*jump.Set()) == 0) {
+    NoOOBMessageScope no_msg_scope(thread);
+    NoReloadScope no_reload_scope(thread->isolate(), thread);
     // Under lazy compilation initializer has not yet been created, so create
     // it now, but don't bother remembering it because it won't be used again.
     ASSERT(!field.HasPrecompiledInitializer());
     Thread* const thread = Thread::Current();
     Function& initializer = Function::Handle(thread->zone());
     {
       NOT_IN_PRODUCT(
         VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
         TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                                   "CompileStaticInitializer");
@@ skipping 37 matching lines @@
     return Precompiler::ExecuteOnce(fragment);
   }
 #endif
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
 
     // Don't allow message interrupts while executing constant
     // expressions.  They can cause bogus recursive compilation.
     NoOOBMessageScope no_msg_scope(thread);
+
+    // Don't allow reload requests to come in.
+    NoReloadScope no_reload_scope(thread->isolate(), thread);
+
     if (FLAG_trace_compiler) {
       THR_Print("compiling expression: ");
       if (FLAG_support_ast_printer) {
         AstPrinter::PrintNode(fragment);
       }
     }
 
     // Create a dummy function object for the code generator.
     // The function needs to be associated with a named Class: the interface
     // Function fits the bill.
@@ skipping 334 matching lines @@
     }
   }
   delete task_done;
   delete done_monitor;
   delete queue_monitor;
   delete function_queue;
   isolate->set_background_compiler(NULL);
 }
 
 
+void BackgroundCompiler::Disable() {
+  Thread* thread = Thread::Current();
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
+  MutexLocker ml(isolate->mutex());
+  BackgroundCompiler* task = isolate->background_compiler();
+  if (task != NULL) {
+    // We should only ever have to stop the task if this is the first call to
+    // Disable.
+    ASSERT(!isolate->is_background_compiler_disabled());
+    BackgroundCompiler::Stop(isolate);
+  }
+  ASSERT(isolate->background_compiler() == NULL);
+  isolate->disable_background_compiler();
+}
+
+
+bool BackgroundCompiler::IsDisabled() {
+  Thread* thread = Thread::Current();
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
+  MutexLocker ml(isolate->mutex());
+  return isolate->is_background_compiler_disabled();
+}
+
+
+void BackgroundCompiler::Enable() {
+  Thread* thread = Thread::Current();
+  ASSERT(thread != NULL);
+  Isolate* isolate = thread->isolate();
+  MutexLocker ml(isolate->mutex());
+  isolate->enable_background_compiler();
+}
+
+
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   ASSERT(thread->IsMutatorThread());
   // Finalize NoSuchMethodError, _Mint; occasionally needed in optimized
   // compilation.
   Class& cls = Class::Handle(thread->zone(),
       Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   Error& error = Error::Handle(thread->zone(),
       cls.EnsureIsFinalized(thread));
   ASSERT(error.IsNull());
@@ skipping 131 matching lines @@
 
 void BackgroundCompiler::Stop(Isolate* isolate) {
   UNREACHABLE();
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
+
+void BackgroundCompiler::Disable() {
+  UNREACHABLE();
+}
+
+
+void BackgroundCompiler::Enable() {
+  UNREACHABLE();
+}
+
+
+bool BackgroundCompiler::IsDisabled() {
+  UNREACHABLE();
+  return true;
+}
+
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart