Background compilation work:

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 759 matching lines @@
         graph_compiler.FinalizePcDescriptors(code);
         code.set_deopt_info_array(deopt_info_array);
 
         graph_compiler.FinalizeStackmaps(code);
         graph_compiler.FinalizeVarDescriptors(code);
         graph_compiler.FinalizeExceptionHandlers(code);
         graph_compiler.FinalizeStaticCallTargetsTable(code);
 
         if (optimized) {
           if (result != NULL) {
+            // Background compilation, store compilation result in 'result'.
             ASSERT(!Thread::Current()->IsMutatorThread());
             // Do not install code, but return it instead.
             // Since code dependencies (CHA, fields) are defined eagerly,
             // the code may be disabled before installing it.
             code.set_owner(function);
             result->set_result_code(code);
             // Disable invalidation counters that are not relevant.
             if (thread->cha()->leaf_classes().is_empty()) {
               result->ClearCHAInvalidationGen();
             }
             if (flow_graph->guarded_fields()->is_empty()) {
               result->ClearFieldInvalidationGen();
             }
             if (!parsed_function->HasDeferredPrefixes()) {
               result->ClearPrefixInvalidationGen();
             }
           } else {
             const bool is_osr = osr_id != Compiler::kNoOSRDeoptId;
             function.InstallOptimizedCode(code, is_osr);
           }
 
-          // TODO(srdjan): In background compilation, verify that CHA and field
-          // guards have not been invalidated in the meantime.
           // Register code with the classes it depends on because of CHA and
           // fields it depends on because of store guards, unless we cannot
           // deopt.
           if (Compiler::allow_recompilation()) {
-            for (intptr_t i = 0;
-                 i < thread->cha()->leaf_classes().length();
-                 ++i) {
-              thread->cha()->leaf_classes()[i]->RegisterCHACode(code);
-            }
-            for (intptr_t i = 0;
-                 i < flow_graph->guarded_fields()->length();
-                 i++) {
-              const Field* field = (*flow_graph->guarded_fields())[i];
-              field->RegisterDependentCode(code);
+            if (result != NULL) {
+              // Background compilation: delay registering code until we are
+              // in the MutatorThread.
+              result->SetLeafClasses(thread->cha()->leaf_classes());
+              result->SetGuardedFields(*flow_graph->guarded_fields());
+              result->SetDeoptimizeDependentFields(
+                  flow_graph->deoptimize_dependent_code());
+            } else {
+              for (intptr_t i = 0;
+                   i < thread->cha()->leaf_classes().length();
+                   ++i) {
+                thread->cha()->leaf_classes()[i]->RegisterCHACode(code);
+              }
+              for (intptr_t i = 0;
+                   i < flow_graph->guarded_fields()->length();
+                   i++) {
+                const Field* field = (*flow_graph->guarded_fields())[i];
+                field->RegisterDependentCode(code);
+              }
+              for (intptr_t i = 0;
+                   i < flow_graph->deoptimize_dependent_code().length();
+                   i++) {
+                const Field* field = flow_graph->deoptimize_dependent_code()[i];
+                field->DeoptimizeDependentCode();
+              }
             }
           }
         } else {  // not optimized.
           if (!Compiler::always_optimize() &&
               (function.ic_data_array() == Array::null())) {
             function.SaveICDataMap(
                 graph_compiler.deopt_id_to_ic_data(),
                 Array::Handle(zone, graph_compiler.edge_counters_array()));
           }
           function.set_unoptimized_code(code);
@@ skipping 647 matching lines @@
   return Object::null();
 }
 
 
 // C-heap allocated background compilation queue element.
 class QueueElement {
  public:
   explicit QueueElement(const Function& function)
       : next_(NULL),
         obj_(function.raw()),
+        leaf_classes_(Array::null()),
+        guarded_fields_(Array::null()),
+        deoptimize_dependent_fields_(Array::null()),
         cha_invalidation_gen_(Isolate::kInvalidGen),
         field_invalidation_gen_(Isolate::kInvalidGen),
         prefix_invalidation_gen_(Isolate::kInvalidGen) {
     ASSERT(Thread::Current()->IsMutatorThread());
   }
 
   ~QueueElement() {
     ASSERT(Thread::Current()->IsMutatorThread());
     obj_ = Object::null();
   }
 
   RawFunction* Function() const { return Function::RawCast(obj_); }
   RawCode* Code() const { return Code::RawCast(obj_); }
 
+  RawArray* leaf_classes() const { return leaf_classes_; }
+  RawArray* guarded_fields() const { return guarded_fields_; }
+  RawArray* deoptimize_dependent_fields() const {
+    return deoptimize_dependent_fields_;
+  }
+
   uint32_t cha_invalidation_gen() const { return cha_invalidation_gen_; }
   uint32_t field_invalidation_gen() const { return field_invalidation_gen_; }
   uint32_t prefix_invalidation_gen() const { return prefix_invalidation_gen_; }
 
   void set_next(QueueElement* elem) { next_ = elem; }
   QueueElement* next() const { return next_; }
 
+  RawObject* obj() const { return obj_; }
   RawObject** obj_ptr() { return &obj_; }
-  RawObject* obj() const { return obj_; }
+
+  RawObject** leaf_classses_ptr() {
+    return reinterpret_cast<RawObject**>(&leaf_classes_);
+  }
+
+  RawObject** guarded_fields_ptr() {
+    return reinterpret_cast<RawObject**>(&guarded_fields_);
+  }
+
+  RawObject** deoptimize_dependent_fields_ptr() {
+    return reinterpret_cast<RawObject**>(&deoptimize_dependent_fields_);
+  }
 
   void SetFromResult(const BackgroundCompilationResult& value) {
     ASSERT(!value.result_code().IsNull());
     obj_ = value.result_code().raw();
+    leaf_classes_ = value.leaf_classes().raw();
+    guarded_fields_ = value.guarded_fields().raw();
+    deoptimize_dependent_fields_ = value.deoptimize_dependent_fields().raw();
     cha_invalidation_gen_ = value.cha_invalidation_gen();
     field_invalidation_gen_ = value.field_invalidation_gen();
     prefix_invalidation_gen_ = value.prefix_invalidation_gen();
   }
 
  private:
   QueueElement* next_;
 
   RawObject* obj_;  // Code or Function.
+  RawArray* leaf_classes_;
+  RawArray* guarded_fields_;
+  RawArray* deoptimize_dependent_fields_;
   uint32_t cha_invalidation_gen_;
   uint32_t field_invalidation_gen_;
   uint32_t prefix_invalidation_gen_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueElement);
 };
 
 
 // Allocated in C-heap. Handles both input and output of background compilation.
 // It implements a FIFO queue, using Peek, Add, Remove operations.
 class BackgroundCompilationQueue {
  public:
   BackgroundCompilationQueue() : first_(NULL), last_(NULL) {}
   ~BackgroundCompilationQueue() {
     while (!IsEmpty()) {
       QueueElement* e = Remove();
       delete e;
     }
     ASSERT((first_ == NULL) && (last_ == NULL));
   }
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ASSERT(visitor != NULL);
     QueueElement* p = first_;
     while (p != NULL) {
       visitor->VisitPointer(p->obj_ptr());
+      visitor->VisitPointer(p->leaf_classses_ptr());
+      visitor->VisitPointer(p->guarded_fields_ptr());
+      visitor->VisitPointer(p->deoptimize_dependent_fields_ptr());
       p = p->next();
     }
   }
 
   bool IsEmpty() const { return first_ == NULL; }
 
   void Add(QueueElement* value) {
     ASSERT(value != NULL);
     if (first_ == NULL) {
       first_ = value;
@@ skipping 41 matching lines @@
  private:
   QueueElement* first_;
   QueueElement* last_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundCompilationQueue);
 };
 
 
 BackgroundCompilationResult::BackgroundCompilationResult()
     : result_code_(Code::Handle()),
+      leaf_classes_(Array::Handle()),
+      guarded_fields_(Array::Handle()),
+      deoptimize_dependent_fields_(Array::Handle()),
       cha_invalidation_gen_(Isolate::kInvalidGen),
       field_invalidation_gen_(Isolate::kInvalidGen),
       prefix_invalidation_gen_(Isolate::kInvalidGen) {
 }
 
 
 void BackgroundCompilationResult::Init() {
   Isolate* i = Isolate::Current();
   result_code_ = Code::null();
+  leaf_classes_ = Array::null();
+  guarded_fields_ = Array::null();
+  deoptimize_dependent_fields_ = Array::null();
   cha_invalidation_gen_ = i->cha_invalidation_gen();
   field_invalidation_gen_ = i->field_invalidation_gen();
   prefix_invalidation_gen_ = i->prefix_invalidation_gen();
 }
 
 
 void BackgroundCompilationResult::SetFromQElement(QueueElement* value) {
   ASSERT(value != NULL);
   result_code_ = value->Code();
+  leaf_classes_ = value->leaf_classes();
+  guarded_fields_ = value->guarded_fields();
+  deoptimize_dependent_fields_ = value->deoptimize_dependent_fields();
   cha_invalidation_gen_ = value->cha_invalidation_gen();
   field_invalidation_gen_ = value->field_invalidation_gen();
   prefix_invalidation_gen_ = value->prefix_invalidation_gen();
 }
 
 
+void BackgroundCompilationResult::SetLeafClasses(
+    const GrowableArray<Class*>& leaf_classes) {
+  const Array& a = Array::Handle(Array::New(leaf_classes.length(), Heap::kOld));
+  for (intptr_t i = 0; i < leaf_classes.length(); i++) {
+    a.SetAt(i, *leaf_classes[i]);
+  }
+  leaf_classes_ = a.raw();
+}
+
+
+void BackgroundCompilationResult::SetGuardedFields(
+    const ZoneGrowableArray<const Field*>& guarded_fields) {
+  const Array& a =
+      Array::Handle(Array::New(guarded_fields.length(), Heap::kOld));
+  for (intptr_t i = 0; i < guarded_fields.length(); i++) {
+    a.SetAt(i, *guarded_fields[i]);
+  }
+  guarded_fields_ = a.raw();
+}
+
+
+void BackgroundCompilationResult::SetDeoptimizeDependentFields(
+    const GrowableArray<const Field*>& fields) {
+  const Array& a = Array::Handle(Array::New(fields.length(), Heap::kOld));
+  for (intptr_t i = 0; i < fields.length(); i++) {
+    a.SetAt(i, *fields[i]);
+  }
+  deoptimize_dependent_fields_ = a.raw();
+}
+
+
 bool BackgroundCompilationResult::IsValid() const {
   if (result_code().IsNull() || result_code().IsDisabled()) {
     return false;
   }
   Isolate* i = Isolate::Current();
   if ((cha_invalidation_gen_ != Isolate::kInvalidGen) &&
       (cha_invalidation_gen_ != i->cha_invalidation_gen())) {
     return false;
   }
   if ((field_invalidation_gen_ != Isolate::kInvalidGen) &&
@@ skipping 108 matching lines @@
   }
   QueueElement* elem = new QueueElement(function);
   function_queue()->Add(elem);
   ml.Notify();
 }
 
 
 void BackgroundCompiler::InstallGeneratedCode() {
   ASSERT(Thread::Current()->IsMutatorThread());
   MonitorLocker ml(queue_monitor_);
-  Object& owner = Object::Handle();
+  Function& function = Function::Handle();
   while (result_queue()->Peek() != NULL) {
     BackgroundCompilationResult result;
     QueueElement* elem = result_queue()->Remove();
     ASSERT(elem != NULL);
     result.SetFromQElement(elem);
     delete elem;
 
-    owner = result.result_code().owner();
-    const Function& function = Function::Cast(owner);
+    const Code& code = result.result_code();
+    function ^= code.owner();
     if (result.IsValid()) {
       function.InstallOptimizedCode(result.result_code(), false /* not OSR */);
+      // Install leaf classes and fields dependencies.
+      Class& cls = Class::Handle();
+      for (intptr_t i = 0; i < result.leaf_classes().Length(); i++) {
+        cls ^= result.leaf_classes().At(i);
+        cls.RegisterCHACode(code);
+      }
+      Field& field = Field::Handle();
+      for (intptr_t i = 0; i < result.guarded_fields().Length(); i++) {
+        field ^= result.guarded_fields().At(i);
+        field.RegisterDependentCode(code);
+      }
+      for (intptr_t i = 0; i < result.deoptimize_dependent_fields().Length();
+           i++) {
+        field ^= result.deoptimize_dependent_fields().At(i);
+        field.DeoptimizeDependentCode();
+      }
     } else if (FLAG_trace_compiler) {
       THR_Print("Drop code generated in the background compiler:\n");
       result.PrintValidity();
     }
     if (function.usage_counter() < 0) {
       // Reset to 0 so that it can be recompiled if needed.
       function.set_usage_counter(0);
     }
   }
 }
@@ skipping 34 matching lines @@
   delete task_done;
   delete done_monitor;
   delete queue_monitor;
   delete function_queue;
   delete result_queue;
   Isolate::Current()->set_background_compiler(NULL);
 }
 
 
 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()));
+  Error& error = Error::Handle(thread->zone(),
+      cls.EnsureIsFinalized(thread));
+  ASSERT(error.IsNull());
+  cls = Library::LookupCoreClass(Symbols::_Mint());
+  error = cls.EnsureIsFinalized(thread);
+  ASSERT(error.IsNull());
+
   bool start_task = false;
   Isolate* isolate = thread->isolate();
   {
     MutexLocker ml(isolate->mutex());
     if (isolate->background_compiler() == NULL) {
       BackgroundCompiler* task = new BackgroundCompiler(isolate);
       isolate->set_background_compiler(task);
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart