This adds a mechanism to invalidate code that was generated in the background. The invalidation can…

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 372 matching lines @@
 }
 
 
 // Return false if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
 static bool CompileParsedFunctionHelper(CompilationPipeline* pipeline,
                                         ParsedFunction* parsed_function,
                                         bool optimized,
                                         intptr_t osr_id,
-                                        Code* optimized_result_code) {
+                                        BackgroundCompilationResult* result) {
   const Function& function = parsed_function->function();
   if (optimized && !function.IsOptimizable()) {
     return false;
   }
   bool is_compiled = false;
   Thread* const thread = Thread::Current();
   Zone* const zone = thread->zone();
   Isolate* const isolate = thread->isolate();
   CSTAT_TIMER_SCOPE(thread, codegen_timer);
   HANDLESCOPE(thread);
@@ skipping 361 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 (optimized_result_code != NULL) {
+          if (result != NULL) {
+            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);
-            *optimized_result_code = code.raw();
+            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->ClearFieldInnvalidationGen();
+            }
+            if (!parsed_function->HasDeferredPrefixes()) {
+              result->ClearPrefixInnvalidationGen();
+            }
           } else {
             const bool is_osr = osr_id != Compiler::kNoOSRDeoptId;
             function.InstallOptimizedCode(code, is_osr);
           }
 
           // TODO(srdjan): In background compilation, verify that CHA has not
           // been invalidated in the meantime.
           // Register code with the classes it depends on because of CHA.
           for (intptr_t i = 0;
                i < thread->cha()->leaf_classes().length();
@@ skipping 225 matching lines @@
            function.raw());
   }
 }
 #endif
 
 
 static RawError* CompileFunctionHelper(CompilationPipeline* pipeline,
                                        const Function& function,
                                        bool optimized,
                                        intptr_t osr_id,
-                                       Code* result_code) {
+                                       BackgroundCompilationResult* result) {
   // Check that we optimize if 'Compiler::always_optimize()' is set to true,
   // except if the function is marked as not optimizable.
   ASSERT(!function.IsOptimizable() ||
          !Compiler::always_optimize() || optimized);
   ASSERT(Compiler::allow_recompilation() || !function.HasCode());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     StackZone stack_zone(thread);
@@ skipping 22 matching lines @@
       const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
       INC_STAT(thread,
                num_func_tokens_compiled,
                num_tokens_after - num_tokens_before);
     }
 
     const bool success = CompileParsedFunctionHelper(pipeline,
                                                      parsed_function,
                                                      optimized,
                                                      osr_id,
-                                                     result_code);
+                                                     result);
     if (!success) {
       if (optimized) {
         ASSERT(!Compiler::always_optimize());  // Optimized is the only code.
         // Optimizer bailed out. Disable optimizations and never try again.
         if (FLAG_trace_compiler) {
           THR_Print("--> disabling optimizations for '%s'\n",
                     function.ToFullyQualifiedCString());
         } else if (FLAG_trace_failed_optimization_attempts) {
           THR_Print("Cannot optimize: %s\n",
                     function.ToFullyQualifiedCString());
@@ skipping 102 matching lines @@
   if (FLAG_trace_compiler) {
     THR_Print("Ensure unoptimized code for %s\n", function.ToCString());
   }
   return Error::null();
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id,
-                                             Code* result_code) {
+                                             BackgroundCompilationResult* res) {
   VMTagScope tagScope(thread, VMTag::kCompileOptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread,
                                          "OptimizedFunction", function);
 
   // 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());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline,
                                function,
                                true,  /* optimized */
                                osr_id,
-                               result_code);
+                               res);
 }
 
 
 // This is only used from unit tests.
 RawError* Compiler::CompileParsedFunction(
     ParsedFunction* parsed_function) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
@@ skipping 240 matching lines @@
   explicit CompilationWorkQueue(GrowableObjectArray* data) : data_(data) {}
 
   intptr_t IsEmpty() const { return data_->Length() == 0; }
   intptr_t Length() const { return data_->Length(); }
 
   void PushFrontFunction(const Function& function) { PushFront(function); }
   RawFunction* PopBackFunction() { return Function::RawCast(PopBack()); }
   RawFunction* LastFunction() { return Function::RawCast(Last()); }
 
   void PushBackCode(const Code& code) { PushBack(code); }
+  void PushBackInteger(const Integer& value) { PushBack(value); }
   RawCode* PopBackCode() { return Code::RawCast(PopBack()); }
-  RawCode* LastCode() { return Code::RawCast(Last()); }
+  RawInteger* PopBackInteger() {
+    Object& o = Object::Handle(PopBack());
+    if (o.IsNull()) {
+      return Integer::null();
+    } else {
+      return Integer::Cast(o).raw();
+    }
+  }
 
  private:
   // Adds to the queue only if 'function' is not already in there.
   void PushFront(const Object& value) {
     for (intptr_t i = 0; i < data_->Length(); i++) {
       if (data_->At(i) == value.raw()) {
         return;
       }
     }
     // Insert new element in front.
@@ skipping 24 matching lines @@
     ASSERT(!IsEmpty());
     return data_->At(data_->Length() - 1);
   }
 
   GrowableObjectArray* data_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationWorkQueue);
 };
 
 
+
+BackgroundCompilationResult::BackgroundCompilationResult()
+    : result_code_(Code::Handle()),
+      cha_invalidation_gen_(Integer::Handle()),
+      field_invalidation_gen_(Integer::Handle()),
+      prefix_invalidation_gen_(Integer::Handle()) {
+}
+
+
+void BackgroundCompilationResult::Init() {
+  Isolate* i = Isolate::Current();
+  result_code_ = Code::null();
+  cha_invalidation_gen_ = Integer::New(i->cha_invalidation_gen(),
+      Heap::kOld, true /* silent */);
+  field_invalidation_gen_ = Integer::New(i->field_invalidation_gen(),
+      Heap::kOld, true /* silent */);
+  prefix_invalidation_gen_ = Integer::New(i->prefix_invalidation_gen(),
+      Heap::kOld, true /* silent */);
+}
+
+
+bool BackgroundCompilationResult::IsValid() const {
+  if (result_code().IsNull() || result_code().IsDisabled()) {
+    return false;
+  }
+  Isolate* i = Isolate::Current();
+  if (!cha_invalidation_gen_.IsNull() &&
+      (cha_invalidation_gen_.AsInt64Value() != i->cha_invalidation_gen())) {
+    return false;
+  }
+  if (!field_invalidation_gen_.IsNull() &&
+      (field_invalidation_gen_.AsInt64Value() != i->field_invalidation_gen())) {
+    return false;
+  }
+  if (!prefix_invalidation_gen_.IsNull() &&
+      (prefix_invalidation_gen_.AsInt64Value() !=
+          i->prefix_invalidation_gen())) {
+    return false;
+  }
+  return true;
+}
+
+
+void BackgroundCompilationResult::PrintValidity() {
+  Object& o = Object::Handle(result_code().owner());
+  THR_Print("BackgroundCompilationResult: %s\n",
+      Function::Cast(o).ToQualifiedCString());
+  if (result_code().IsNull()) {
+    THR_Print(" result_code is NULL\n");
+    return;
+  }
+  if (result_code().IsDisabled()) {
+    THR_Print(" result_code is disabled\n");
+    return;
+  }
+  Isolate* i = Isolate::Current();
+  THR_Print("  cha_invalidation_gen: %s (current: %" Pd ")\n",
+      cha_invalidation_gen_.ToCString(), i->cha_invalidation_gen());
+  THR_Print("  field_invalidation_gen: %s (current: %" Pd ")\n",
+      field_invalidation_gen_.ToCString(), i->field_invalidation_gen());
+  THR_Print("  prefix_invalidation_gen: %s (current: %" Pd ")\n",
+      prefix_invalidation_gen_.ToCString(), i->prefix_invalidation_gen());
+}
+
+
+void BackgroundCompilationResult::PushOnQueue(
+    CompilationWorkQueue* queue) const {
+  queue->PushBackCode(result_code());
+  queue->PushBackInteger(cha_invalidation_gen_);
+  queue->PushBackInteger(field_invalidation_gen_);
+  queue->PushBackInteger(prefix_invalidation_gen_);
+}
+
+
+void BackgroundCompilationResult::PopFromQueue(CompilationWorkQueue* queue) {
+  prefix_invalidation_gen_ = queue->PopBackInteger();
+  field_invalidation_gen_ = queue->PopBackInteger();
+  cha_invalidation_gen_ = queue->PopBackInteger();
+  result_code_ = queue->PopBackCode();
+}
+
+
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate), running_(true), done_(new bool()),
       queue_monitor_(new Monitor()), done_monitor_(new Monitor()),
       function_queue_length_(0) {
   *done_ = false;
 }
 
 
 void BackgroundCompiler::Run() {
   while (running_) {
     // Maybe something is already in the queue, check first before waiting
     // to be notified.
     Thread::EnterIsolateAsHelper(isolate_);
     {
       Thread* thread = Thread::Current();
       StackZone stack_zone(thread);
       HANDLESCOPE(thread);
       Zone* zone = stack_zone.GetZone();
       Function& function = Function::Handle(zone);
       Function& temp_function = Function::Handle(zone);
-      Code& code = Code::Handle(zone);
       function = LastFunctionOrNull();
+      BackgroundCompilationResult result;
       // Finish all compilation before exiting (even if running_ is changed to
       // false).
       while (!function.IsNull()) {
+        result.Init();
         const Error& error = Error::Handle(zone,
             Compiler::CompileOptimizedFunction(thread,
                                                function,
                                                Compiler::kNoOSRDeoptId,
-                                               &code));
+                                               &result));
         // TODO(srdjan): We do not expect errors while compiling optimized
         // code, any errors should have been caught when compiling
         // unoptimized code.
         // If it still happens mark function as not optimizable.
         ASSERT(error.IsNull());
         temp_function = RemoveFunctionOrNull();
         ASSERT(temp_function.raw() == function.raw());
         function = LastFunctionOrNull();
-        ASSERT(!code.IsNull());
-        AddCode(code);
+        ASSERT(!result.result_code().IsNull());
+        AddResult(result);
       }
     }
     Thread::ExitIsolateAsHelper();
     {
       // Wait to be notified when the work queue is not empty.
       MonitorLocker ml(queue_monitor_);
       while ((function_queue_length() == 0) && running_) {
         ml.Wait();
       }
     }
   }
   {
     // Notify that the thread is done.
     MonitorLocker ml_done(done_monitor_);
     *done_ = true;
     ml_done.Notify();
   }
 }
 
 
 void BackgroundCompiler::CompileOptimized(const Function& function) {
   AddFunction(function);
 }
 
 
 void BackgroundCompiler::InstallGeneratedCode() {
+  ASSERT(Thread::Current()->IsMutatorThread());
   MonitorLocker ml(queue_monitor_);
-  CompilationWorkQueue queue(CodesQueue());
-  Code& code = Code::Handle();
+  CompilationWorkQueue queue(ResultQueue());
   Object& owner = Object::Handle();
   for (intptr_t i = 0; i < queue.Length(); i++) {
-    code = queue.PopBackCode();
-    if (code.IsDisabled()) continue;
-    owner = code.owner();
+    BackgroundCompilationResult result;
+    result.PopFromQueue(&queue);
+    owner = result.result_code().owner();
     const Function& function = Function::Cast(owner);
-    function.InstallOptimizedCode(code, false /* not OSR */);
+    if (result.IsValid()) {
+      function.InstallOptimizedCode(result.result_code(), false /* not OSR */);
+    }
     if (function.usage_counter() < 0) {
       // Reset to 0 so that it can be recompiled if needed.
       function.set_usage_counter(0);
     }
   }
 }
 
 
 GrowableObjectArray* BackgroundCompiler::FunctionsQueue() const {
   return
       &GrowableObjectArray::ZoneHandle(isolate_->compilation_function_queue());
 }
 
 
-GrowableObjectArray* BackgroundCompiler::CodesQueue() const {
-  // Use code queue
-  return &GrowableObjectArray::ZoneHandle(isolate_->compilation_code_queue());
+GrowableObjectArray* BackgroundCompiler::ResultQueue() const {
+  return &GrowableObjectArray::ZoneHandle(isolate_->compilation_result_queue());
 }
 
 
 void BackgroundCompiler::AddFunction(const Function& f) {
   MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(FunctionsQueue());
   queue.PushFrontFunction(f);
   set_function_queue_length(queue.Length());
   // Notify waiting background compiler task.
   ml.Notify();
 }
 
 
 RawFunction* BackgroundCompiler::RemoveFunctionOrNull() {
   MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(FunctionsQueue());
   if (queue.IsEmpty()) return Function::null();
   set_function_queue_length(queue.Length() - 1);
   return queue.PopBackFunction();
 }
 
 
 RawFunction* BackgroundCompiler::LastFunctionOrNull() const {
   MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(FunctionsQueue());
   return queue.IsEmpty() ? Function::null() : queue.LastFunction();
 }
 
 
-void BackgroundCompiler::AddCode(const Code& c) {
+void BackgroundCompiler::AddResult(const BackgroundCompilationResult& value) {
   MonitorLocker ml(queue_monitor_);
-  CompilationWorkQueue queue(CodesQueue());
-  queue.PushBackCode(c);
+  CompilationWorkQueue queue(ResultQueue());
+  value.PushOnQueue(&queue);
 }
 
 
 void BackgroundCompiler::Stop(BackgroundCompiler* task) {
   ASSERT(Isolate::Current()->background_compiler() == task);
   if (task == NULL) {
     return;
   }
   Monitor* monitor = task->queue_monitor_;
   Monitor* done_monitor = task->done_monitor_;
@@ skipping 23 matching lines @@
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   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);
       isolate->set_compilation_function_queue(GrowableObjectArray::Handle(
           thread->zone(), GrowableObjectArray::New()));
-      isolate->set_compilation_code_queue(GrowableObjectArray::Handle(
+      isolate->set_compilation_result_queue(GrowableObjectArray::Handle(
           thread->zone(), GrowableObjectArray::New()));
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart