Initial design for background compilation

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 17 matching lines @@
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/regexp_parser.h"
 #include "vm/regexp_assembler.h"
 #include "vm/scanner.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
+#include "vm/thread_registry.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, allocation_sinking, true,
     "Attempt to sink temporary allocations to side exits");
 DEFINE_FLAG(bool, common_subexpression_elimination, true,
     "Do common subexpression elimination.");
 DEFINE_FLAG(bool, constant_propagation, true,
     "Do conditional constant propagation/unreachable code elimination.");
@@ skipping 1347 matching lines @@
     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 workqueue containing functions to be optimized.
+// TODO(srdjan): Write a more efficient implementation.
+class CompilationWorkQueue : public ValueObject {
+ public:
+  explicit CompilationWorkQueue(Isolate* isolate) :
+      data_(GrowableObjectArray::Handle()) {
+    data_ = isolate->background_compilation_queue();
+  }
+
+  intptr_t IsEmpty() const { return data_.Length() == 0; }
+
+  // Adds to the queue only if not already in there.
+  void AddUnique(const Function& function) {
+    for (intptr_t i = 0; i < data_.Length(); i++) {
+      if (data_.At(i) == function.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_.SetAt(0, function);
+  }
+
+
+  RawFunction* Remove() {
+    ASSERT(!IsEmpty());
+    Object& result = Object::Handle();
+    result = data_.At(data_.Length() - 1);
+    data_.SetLength(data_.Length() - 1);
+    return Function::Cast(result).raw();
+  }
+
+ private:
+  GrowableObjectArray& data_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationWorkQueue);
+};
+
+
+CompileOptimizedTask::CompileOptimizedTask(Isolate* isolate)
+    : isolate_(isolate), running_(true), done_(new bool()),
+      monitor_(new Monitor()), done_monitor_(new Monitor())  {
+  *done_ = false;
+}
+
+
+void CompileOptimizedTask::Run() {
+  while (running_) {
+    {
+      // Wait to be notified when the workqueue is not empty.
+      MonitorLocker ml(monitor_);
+      ml.Wait();
+    }
+
+    Thread::EnterIsolateAsHelper(isolate_);
+    {
+      Thread* thread = Thread::Current();
+      StackZone stack_zone(thread);
+      HANDLESCOPE(thread);
+      // In case the thread was awoken because of a safepoint request.
+      isolate_->thread_registry()->CheckSafepoint();
+      Function& function = Function::Handle();
+      function = RemoveOrNull();
+      while (!function.IsNull()) {
+        // Debugging printing
+        // THR_Print("Background compilation: %s\n",
+        //     function.ToQualifiedCString());
+        const Error& error = Error::Handle(
+            Compiler::CompileOptimizedFunction(thread, function));
+        // TODO(srdjan): We do not expect errors in optimized code. If it
+        // still happens mark function as not optimizable.
+        ASSERT(error.IsNull());
+        function = RemoveOrNull();
+      }
+    }
+    Thread::ExitIsolateAsHelper();
+  }
+  {
+    // Notify that the thread is done.
+    MonitorLocker ml_done(done_monitor_);
+    *done_ = true;
+    ml_done.Notify();
+  }
+}
+
+
+void CompileOptimizedTask::CompileOptimized(const Function& function) {
+  Add(function);
+}
+
+
+void CompileOptimizedTask::Add(const Function& f) {
+  MonitorLocker ml(monitor_);
+  CompilationWorkQueue queue(isolate_);
+  queue.AddUnique(f);
+  ml.Notify();
+}
+
+
+RawFunction* CompileOptimizedTask::RemoveOrNull() {
+  MonitorLocker ml(monitor_);
+  CompilationWorkQueue queue(isolate_);
+  return queue.IsEmpty() ? Function::null() : queue.Remove();
+}
+
+
+void CompileOptimizedTask::Stop(CompileOptimizedTask* task) {
+  if (task == NULL) {
+    return;
+  }
+  Monitor* monitor = task->monitor_;
+  Monitor* done_monitor = task->done_monitor_;
+  bool* task_done = task->done_;
+  // Wake up compiler task and stop it.
+  {
+    MonitorLocker ml(task->monitor_);
+    task->running_ = false;
+    task = NULL;
+    // 'task' will be deleted by thread pool.
+    ml.Notify();
+  }
+
+  {
+    MonitorLocker ml_done(done_monitor);
+    while (!(*task_done)) {
+      ml_done.Wait();
+    }
+  }
+  delete task_done;
+  delete done_monitor;
+  delete monitor;
+}
+
+
+void CompileOptimizedTask::EnsureInit(Isolate* isolate) {
+  MutexLocker ml(isolate->mutex());
+  if (isolate->compile_optimized_task() == NULL) {
+    CompileOptimizedTask* task = new CompileOptimizedTask(isolate);
+    isolate->set_compile_optimized_task(task);
+    isolate->set_background_compilation_queue(
+        GrowableObjectArray::Handle(isolate, GrowableObjectArray::New()));
+    Dart::thread_pool()->Run(task);
+  }
+}
+
 }  // namespace dart