Make ICData changes thread safe (first compute array, then set it). Install code in the main thread…

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 360 matching lines @@
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 // 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) {
+                                        intptr_t osr_id,
+                                        Code* optimized_result_code) {
   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 45 matching lines @@
                                               *ic_data_array,
                                               osr_id);
       }
 
       const bool print_flow_graph =
           (FLAG_print_flow_graph ||
           (optimized && FLAG_print_flow_graph_optimized)) &&
           FlowGraphPrinter::ShouldPrint(function);
 
       if (print_flow_graph) {
-        if (osr_id == Thread::kNoDeoptId) {
+        if (osr_id == Compiler::kNoOSRDeoptId) {
           FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
         } else {
           FlowGraphPrinter::PrintGraph("For OSR", flow_graph);
         }
       }
 
       BlockScheduler block_scheduler(flow_graph);
       const bool reorder_blocks =
           FlowGraph::ShouldReorderBlocks(function, optimized);
       if (reorder_blocks) {
@@ skipping 262 matching lines @@
         CSTAT_TIMER_SCOPE(thread, codefinalizer_timer);
         // CreateDeoptInfo uses the object pool and needs to be done before
         // FinalizeCode.
         const Array& deopt_info_array =
             Array::Handle(zone, graph_compiler.CreateDeoptInfo(&assembler));
         INC_STAT(thread, total_code_size,
                  deopt_info_array.Length() * sizeof(uword));
         const Code& code = Code::Handle(
             Code::FinalizeCode(function, &assembler, optimized));
         code.set_is_optimized(optimized);
+        code.set_owner(function);
 
         const Array& intervals = graph_compiler.inlined_code_intervals();
         INC_STAT(thread, total_code_size,
                  intervals.Length() * sizeof(uword));
         code.SetInlinedIntervals(intervals);
 
         const Array& inlined_id_array =
             Array::Handle(zone, graph_compiler.InliningIdToFunction());
         INC_STAT(thread, total_code_size,
                  inlined_id_array.Length() * sizeof(uword));
         code.SetInlinedIdToFunction(inlined_id_array);
 
         const Array& caller_inlining_id_map_array =
             Array::Handle(zone, graph_compiler.CallerInliningIdMap());
         INC_STAT(thread, total_code_size,
                  caller_inlining_id_map_array.Length() * sizeof(uword));
         code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
 
         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) {
-          // We may not have previous code if 'always_optimize' is set.
-          if ((osr_id == Thread::kNoDeoptId) && function.HasCode()) {
-            Code::Handle(function.CurrentCode()).DisableDartCode();
+          if (optimized_result_code != NULL) {
+            // 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();
+          } else {
+            const bool is_osr = osr_id != Compiler::kNoOSRDeoptId;
+            function.InstallOptimizedCode(code, is_osr);
           }
-          function.AttachCode(code);
 
+          // 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();
                ++i) {
             thread->cha()->leaf_classes()[i]->RegisterCHACode(code);
           }
 
           for (intptr_t i = 0;
                i < flow_graph->guarded_fields()->length();
                i++) {
@@ skipping 217 matching lines @@
     ASSERT(inlined_functions[inlined_functions.length() - 1]->raw() ==
            function.raw());
   }
 }
 #endif
 
 
 static RawError* CompileFunctionHelper(CompilationPipeline* pipeline,
                                        const Function& function,
                                        bool optimized,
-                                       intptr_t osr_id) {
+                                       intptr_t osr_id,
+                                       Code* result_code) {
   // 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);
     Zone* const zone = stack_zone.GetZone();
     Timer per_compile_timer(FLAG_trace_compiler, "Compilation time");
     per_compile_timer.Start();
 
     ParsedFunction* parsed_function = new(zone) ParsedFunction(
         thread, Function::ZoneHandle(zone, function.raw()));
     if (FLAG_trace_compiler) {
       THR_Print("Compiling %s%sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
-                (osr_id == Thread::kNoDeoptId ? "" : "osr "),
+                (osr_id == Compiler::kNoOSRDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos(),
                 (function.end_token_pos() - function.token_pos()));
     }
     INC_STAT(thread, num_functions_compiled, 1);
     if (optimized) {
       INC_STAT(thread, num_functions_optimized, 1);
     }
     {
       HANDLESCOPE(thread);
       const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
       pipeline->ParseFunction(parsed_function);
       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);
+                                                     osr_id,
+                                                     result_code);
     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 57 matching lines @@
            function.token_pos(),
            Function::KindToCString(function.kind()));
   }
 
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
 
   const bool optimized =
       Compiler::always_optimize() && function.IsOptimizable();
 
-  return CompileFunctionHelper(pipeline, function, optimized,
-      Thread::kNoDeoptId);
+  return CompileFunctionHelper(pipeline,
+                               function,
+                               optimized,
+                               kNoOSRDeoptId,  /* not OSR */
+                               NULL /* no result code */);
 }
 
 
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                           const Function& function) {
   if (function.unoptimized_code() != Object::null()) {
     return Error::null();
   }
   Code& original_code = Code::ZoneHandle(thread->zone());
   if (function.HasCode()) {
     original_code = function.CurrentCode();
   }
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
   const Error& error = Error::Handle(
-      CompileFunctionHelper(pipeline, function, false, Thread::kNoDeoptId));
+      CompileFunctionHelper(pipeline,
+                            function,
+                            false,  /* not optimized */
+                            kNoOSRDeoptId,  /* not OSR */
+                            NULL  /* no result code */));
   if (!error.IsNull()) {
     return error.raw();
   }
   // Since CompileFunctionHelper replaces the current code, re-attach the
   // the original code if the function was already compiled.
   if (!original_code.IsNull() &&
       (original_code.raw() != function.CurrentCode())) {
     function.AttachCode(original_code);
   }
   ASSERT(function.unoptimized_code() != Object::null());
   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) {
+                                             intptr_t osr_id,
+                                             Code* result_code) {
   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 != Thread::kNoDeoptId) || !FLAG_background_compilation ||
+  ASSERT((osr_id != kNoOSRDeoptId) || !FLAG_background_compilation ||
          !thread->IsMutatorThread());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
-  return CompileFunctionHelper(pipeline, function, true, osr_id);
+  return CompileFunctionHelper(pipeline,
+                               function,
+                               true,  /* optimized */
+                               osr_id,
+                               result_code);
 }
 
 
 // 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;
     CompileParsedFunctionHelper(&pipeline,
                                 parsed_function,
                                 false,
-                                Thread::kNoDeoptId);
+                                kNoOSRDeoptId,
+                                NULL /* no result code */);
     if (FLAG_disassemble) {
       DisassembleCode(parsed_function->function(), false);
     }
     return Error::null();
   } else {
     Isolate* const isolate = Isolate::Current();
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
@@ skipping 85 matching lines @@
   StackZone zone(thread);
 
   ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
 
   parsed_function->AllocateVariables();
   // Non-optimized code generator.
   DartCompilationPipeline pipeline;
   CompileParsedFunctionHelper(&pipeline,
                               parsed_function,
                               false,  // optimized
-                              Thread::kNoDeoptId);
+                              kNoOSRDeoptId,
+                              NULL /* no result code */);
 
   const Function& initializer = parsed_function->function();
   field.SetPrecompiledInitializer(initializer);
 }
 
 
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
@@ skipping 10 matching lines @@
       StackZone zone(thread);
       ParsedFunction* parsed_function =
           Parser::ParseStaticFieldInitializer(field);
 
       parsed_function->AllocateVariables();
       // Non-optimized code generator.
       DartCompilationPipeline pipeline;
       CompileParsedFunctionHelper(&pipeline,
                                   parsed_function,
                                   false,  // optimized
-                                  Thread::kNoDeoptId);
+                                  kNoOSRDeoptId,
+                                  NULL /* no result code */);
       initializer = parsed_function->function().raw();
       Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
           Object::empty_var_descriptors());
     } else {
       initializer ^= field.PrecompiledInitializer();
     }
     // Invoke the function to evaluate the expression.
     return DartEntry::InvokeFunction(initializer, Object::empty_array());
   } else {
     Thread* const thread = Thread::Current();
@@ skipping 49 matching lines @@
     fragment->scope()->AddVariable(parsed_function->EnsureExpressionTemp());
     fragment->scope()->AddVariable(
         parsed_function->current_context_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper(&pipeline,
                                 parsed_function,
                                 false,
-                                Thread::kNoDeoptId);
+                                kNoOSRDeoptId,
+                                NULL /* no result code */);
     Code::Handle(func.unoptimized_code()).set_var_descriptors(
         Object::empty_var_descriptors());
 
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     return result.raw();
   } else {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
-// A simple work queue containing functions to be optimized. Use
-// PushFront and PopBack to add and read from queue.
+// A simple work queue containing functions to be optimized or code generated.
+// Use PushFrontFunction and PopBackFunction to add and remove from the function
+// queue and PushBackCode and PopBackCode to add and remove from the code queue.
 // TODO(srdjan): Write a more efficient implementation.
 class CompilationWorkQueue : public ValueObject {
  public:
-  explicit CompilationWorkQueue(Isolate* isolate) :
-      data_(GrowableObjectArray::Handle()) {
-    data_ = isolate->background_compilation_queue();
-  }
+  explicit CompilationWorkQueue(GrowableObjectArray* data) : data_(data) {}
 
-  intptr_t IsEmpty() const { return data_.Length() == 0; }
-  intptr_t Length() const { return data_.Length(); }
+  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); }
+  RawCode* PopBackCode() { return Code::RawCast(PopBack()); }
+  RawCode* LastCode() { return Code::RawCast(Last()); }
+
+ private:
   // Adds to the queue only if 'function' is not already in there.
-  void PushFront(const Function& function) {
-    for (intptr_t i = 0; i < data_.Length(); i++) {
-      if (data_.At(i) == function.raw()) {
+  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.
     Object& f = Object::Handle();
-    data_.Add(f);
-    for (intptr_t i = data_.Length() - 1; i > 0; i--) {
-      f = data_.At(i - 1);
-      data_.SetAt(i, f);
+    data_->Add(f);
+    for (intptr_t i = data_->Length() - 1; i > 0; i--) {
+      f = data_->At(i - 1);
+      data_->SetAt(i, f);
     }
-    data_.SetAt(0, function);
+    data_->SetAt(0, value);
   }
 
-  RawFunction* PopBack() {
+
+  void PushBack(const Object& value) {
+    data_->Add(value, Heap::kOld);
+  }
+
+
+  RawObject* PopBack() {
     ASSERT(!IsEmpty());
     Object& result = Object::Handle();
-    result = data_.At(data_.Length() - 1);
-    data_.SetLength(data_.Length() - 1);
-    return Function::Cast(result).raw();
+    result = data_->At(data_->Length() - 1);
+    data_->SetLength(data_->Length() - 1);
+    return result.raw();
   }
 
-  RawFunction* Last() {
+  RawObject* Last() {
     ASSERT(!IsEmpty());
-    return Function::RawCast(data_.At(data_.Length() - 1));
+    return data_->At(data_->Length() - 1);
   }
 
- private:
-  GrowableObjectArray& data_;
+  GrowableObjectArray* data_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationWorkQueue);
 };
 
 
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate), running_(true), done_(new bool()),
       queue_monitor_(new Monitor()), done_monitor_(new Monitor()),
-      queue_length_(0) {
+      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);
-      function = LastOrNull();
-      while (!function.IsNull() && running_) {
+      Code& code = Code::Handle(zone);
+      function = LastFunctionOrNull();
+      // Finish all compilation before exiting (even if running_ is changed to
+      // false).
+      while (!function.IsNull()) {
         const Error& error = Error::Handle(zone,
-            Compiler::CompileOptimizedFunction(thread, function));
+            Compiler::CompileOptimizedFunction(thread,
+                                               function,
+                                               Compiler::kNoOSRDeoptId,
+                                               &code));
         // 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 = RemoveOrNull();
+        temp_function = RemoveFunctionOrNull();
         ASSERT(temp_function.raw() == function.raw());
         // Reset to 0 so that it can be recompiled if needed.
         function.set_usage_counter(0);
-        function = LastOrNull();
+        function = LastFunctionOrNull();
+        AddCode(code);
       }
     }
     Thread::ExitIsolateAsHelper();
     {
       // Wait to be notified when the work queue is not empty.
       MonitorLocker ml(queue_monitor_);
-      while ((queue_length() == 0) && running_) {
+      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) {
-  Add(function);
+  AddFunction(function);
 }
 
 
-void BackgroundCompiler::Add(const Function& f) {
+void BackgroundCompiler::InstallGeneratedCode() {
   MonitorLocker ml(queue_monitor_);
-  CompilationWorkQueue queue(isolate_);
-  queue.PushFront(f);
-  set_queue_length(queue.Length());
+  CompilationWorkQueue queue(CodesQueue());
+  Code& code = Code::Handle();
+  Object& owner = Object::Handle();
+  for (intptr_t i = 0; i < queue.Length(); i++) {
+    code = queue.PopBackCode();
+    if (code.IsDisabled()) continue;
+    owner = code.owner();
+    ASSERT(owner.IsFunction());
+    Function::Cast(owner).InstallOptimizedCode(code, false /* not OSR */);
+  }
+}
+
+
+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());
+}
+
+
+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::RemoveOrNull() {
+RawFunction* BackgroundCompiler::RemoveFunctionOrNull() {
   MonitorLocker ml(queue_monitor_);
-  CompilationWorkQueue queue(isolate_);
+  CompilationWorkQueue queue(FunctionsQueue());
   if (queue.IsEmpty()) return Function::null();
-  set_queue_length(queue.Length() - 1);
-  return queue.PopBack();
+  set_function_queue_length(queue.Length() - 1);
+  return queue.PopBackFunction();
 }
 
 
-RawFunction* BackgroundCompiler::LastOrNull() const {
+RawFunction* BackgroundCompiler::LastFunctionOrNull() const {
   MonitorLocker ml(queue_monitor_);
-  CompilationWorkQueue queue(isolate_);
-  return queue.IsEmpty() ? Function::null() : queue.Last();
+  CompilationWorkQueue queue(FunctionsQueue());
+  return queue.IsEmpty() ? Function::null() : queue.LastFunction();
+}
+
+
+void BackgroundCompiler::AddCode(const Code& c) {
+  MonitorLocker ml(queue_monitor_);
+  CompilationWorkQueue queue(CodesQueue());
+  queue.PushBackCode(c);
 }
 
 
 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_;
   bool* task_done = task->done_;
   // Wake up compiler task and stop it.
   {
     MonitorLocker ml(task->queue_monitor_);
     task->running_ = false;
     // 'task' will be deleted by thread pool.
     task = NULL;
     ml.Notify();   // Stop waiting for the queue.
   }
 
   {
     MonitorLocker ml_done(done_monitor);
     while (!(*task_done)) {
       ml_done.Wait();
     }
   }
   delete task_done;
   delete done_monitor;
   delete monitor;
+  Isolate::Current()->set_background_compiler(NULL);
 }
 
 
 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_background_compilation_queue(GrowableObjectArray::Handle(
+      isolate->set_compilation_function_queue(GrowableObjectArray::Handle(
+          thread->zone(), GrowableObjectArray::New()));
+      isolate->set_compilation_code_queue(GrowableObjectArray::Handle(
           thread->zone(), GrowableObjectArray::New()));
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart