More work for background compilation; move pending_functions_ from ObjectStore to 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 1145 matching lines @@
 
 
 RawError* Compiler::CompileOptimizedFunction(Thread* thread,
                                              const Function& function,
                                              intptr_t osr_id) {
   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.
-  ASSERT(!FLAG_background_compilation ||
+  // compilation is on. OSR compilation still occura in the main thread.

[siva, 2015/10/16 23:29:40]

still occurs

[srdjan, 2015/10/16 23:50:17]

Done.

+  ASSERT((osr_id != Thread::kNoDeoptId) || !FLAG_background_compilation ||
          !thread->isolate()->MutatorThreadIsCurrentThread());
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
   return CompileFunctionHelper(pipeline, function, true, osr_id);
 }
 
 
 // This is only used from unit tests.
 RawError* Compiler::CompileParsedFunction(
     ParsedFunction* parsed_function) {
@@ skipping 261 matching lines @@
   }
 
   RawFunction* PopBack() {
     ASSERT(!IsEmpty());
     Object& result = Object::Handle();
     result = data_.At(data_.Length() - 1);
     data_.SetLength(data_.Length() - 1);
     return Function::Cast(result).raw();
   }
 
+  RawFunction* Last() {
+    ASSERT(!IsEmpty());
+    Object& result = Object::Handle();
+    result = data_.At(data_.Length() - 1);
+    return Function::Cast(result).raw();

[siva, 2015/10/16 23:29:40]

maybe just:

return RawFunction::RawCast(data_.At(data_.Length() - 1));

[srdjan, 2015/10/16 23:50:17]

Done: Function::RawCast.

+  }
+
  private:
   GrowableObjectArray& data_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationWorkQueue);
 };
 
 
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate), running_(true), done_(new bool()),
-      monitor_(new Monitor()), done_monitor_(new Monitor())  {
+      queue_monitor_(new Monitor()), done_monitor_(new Monitor()) {
   *done_ = false;
 }
 
 
 void BackgroundCompiler::Run() {
   while (running_) {
-    {
-      // Wait to be notified when the work queue is not empty.
-      MonitorLocker ml(monitor_);
-      ml.Wait();
-    }
-
+    // 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);
-      Function& function = Function::Handle();
-      function = RemoveOrNull();
-      while (!function.IsNull()) {
-        const Error& error = Error::Handle(
+      Zone* zone = stack_zone.GetZone();
+      Function& function = Function::Handle(zone);
+      Function& temp_function = Function::Handle(zone);
+      function = LastOrNull();
+      while (!function.IsNull() && running_) {
+        const Error& error = Error::Handle(zone,
             Compiler::CompileOptimizedFunction(thread, function));
         // 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());
-        function = RemoveOrNull();
+        temp_function = RemoveOrNull();
+        ASSERT(temp_function.raw() == function.raw());
+        function = LastOrNull();
       }
     }
     Thread::ExitIsolateAsHelper();
+    {
+      // Wait to be notified when the work queue is not empty.
+      MonitorLocker ml(queue_monitor_);
+      // TODO(srdjan): Add a loop here, while queue is empty. Figure out how.
+      // Currently we may block while there is still something in the queue.
+      // We cannot access the queue as we cannot create handles here.
+      // We cannot call EnterIsolateAsHelper to allocate handles because
+      // safepoint would not be reachable here otherwise.
+      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);
 }
 
 
 void BackgroundCompiler::Add(const Function& f) const {
-  MonitorLocker ml(monitor_);
+  MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(isolate_);
   queue.PushFront(f);
   ml.Notify();
 }
 
 
 RawFunction* BackgroundCompiler::RemoveOrNull() const {
-  MonitorLocker ml(monitor_);
+  MonitorLocker ml(queue_monitor_);
   CompilationWorkQueue queue(isolate_);
   return queue.IsEmpty() ? Function::null() : queue.PopBack();
 }
 
 
+RawFunction* BackgroundCompiler::LastOrNull() const {
+  MonitorLocker ml(queue_monitor_);
+  CompilationWorkQueue queue(isolate_);
+  return queue.IsEmpty() ? Function::null() : queue.Last();
+}
+
+
 void BackgroundCompiler::Stop(BackgroundCompiler* task) {
   if (task == NULL) {
     return;
   }
-  Monitor* monitor = task->monitor_;
+  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->monitor_);
+    MonitorLocker ml(task->queue_monitor_);
     task->running_ = false;
     // 'task' will be deleted by thread pool.
     task = NULL;
-    ml.Notify();
+    ml.Notify();   // Stop waiting for the queue.
   }
 
   {
     MonitorLocker ml_done(done_monitor);
     while (!(*task_done)) {
       ml_done.Wait();
     }
   }
   delete task_done;
   delete done_monitor;
@@ skipping 12 matching lines @@
           isolate->current_zone(), GrowableObjectArray::New()));
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart