Allocate some data structures in old instead of in new space. Early inlining bailout for native fun…

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 1479 matching lines @@
  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.
     Object& f = Object::Handle();
-    data_->Add(f);
+    data_->Add(f, Heap::kOld);
     for (intptr_t i = data_->Length() - 1; i > 0; i--) {
       f = data_->At(i - 1);
       data_->SetAt(i, f);
     }
     data_->SetAt(0, value);
   }
 
 
   void PushBack(const Object& value) {
     data_->Add(value, Heap::kOld);
@@ skipping 111 matching lines @@
 
 
 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);
+      Zone* zone = stack_zone.GetZone();
       HANDLESCOPE(thread);
-      Zone* zone = stack_zone.GetZone();
       Function& function = Function::Handle(zone);
       Function& temp_function = Function::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,
@@ skipping 13 matching lines @@
       }
     }
     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();
       }
     }
-  }
+  }  // while running
+
+  compilation_function_queue_ = GrowableObjectArray::null();
+  compilation_result_queue_ = GrowableObjectArray::null();
   {
     // Notify that the thread is done.
     MonitorLocker ml_done(done_monitor_);
     *done_ = true;
     ml_done.Notify();
   }
 }
 
 
 void BackgroundCompiler::CompileOptimized(const Function& function) {
@@ skipping 87 matching lines @@
   visitor->VisitPointer(reinterpret_cast<RawObject**>(
       &compilation_result_queue_));
 }
 
 
 void BackgroundCompiler::Stop(BackgroundCompiler* task) {
   ASSERT(Isolate::Current()->background_compiler() == task);
   if (task == NULL) {
     return;
   }
-  Monitor* monitor = task->queue_monitor_;
+  Monitor* queue_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;
+  delete queue_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);
-      task->set_compilation_function_queue(GrowableObjectArray::Handle(
-          thread->zone(), GrowableObjectArray::New()));
-      task->set_compilation_result_queue(GrowableObjectArray::Handle(
-          thread->zone(), GrowableObjectArray::New()));
+      // TODO(srdjan): Temporary fix to prevent growing (and thus GC-ing) of
+      // queues while inside a MonitorLocker. Will replace GrowableObjectArray
+      // with C heap allocated linked list.
+      GrowableObjectArray& a = GrowableObjectArray::Handle(
+          thread->zone(), GrowableObjectArray::New(Heap::kOld));
+      a.Grow(1000, Heap::kOld);
+      task->set_compilation_function_queue(a);
+
+      a = GrowableObjectArray::New(Heap::kOld);
+      a.Grow(1000, Heap::kOld);
+      task->set_compilation_result_queue(a);
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart