Fix background compilation queue access. Some cleanups.

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 1546 matching lines @@
 
 // C-heap allocated background compilation queue element.
 class QueueElement {
  public:
   explicit QueueElement(const Function& function)
       : next_(NULL),
         function_(function.raw()) {
     ASSERT(Thread::Current()->IsMutatorThread());
   }
 
-  ~QueueElement() {
+  virtual ~QueueElement() {
+    next_ = NULL;
     function_ = Function::null();
   }
 
   RawFunction* Function() const { return function_; }
 
 
   void set_next(QueueElement* elem) { next_ = elem; }
   QueueElement* next() const { return next_; }
 
   RawObject* function() const { return function_; }
   RawObject** function_ptr() {
     return reinterpret_cast<RawObject**>(&function_);
   }
 
  private:
   QueueElement* next_;
   RawFunction* function_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueElement);
 };
 
 
 // Allocated in C-heap. Handles both input and output of background compilation.
 // It implements a FIFO queue, using Peek, Add, Remove operations.
 class BackgroundCompilationQueue {
  public:
   BackgroundCompilationQueue() : first_(NULL), last_(NULL) {}
-  ~BackgroundCompilationQueue() {
+  virtual ~BackgroundCompilationQueue() {
     while (!IsEmpty()) {
       QueueElement* e = Remove();
       delete e;
     }
     ASSERT((first_ == NULL) && (last_ == NULL));
   }
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ASSERT(visitor != NULL);
     QueueElement* p = first_;
     while (p != NULL) {
       visitor->VisitPointer(p->function_ptr());
       p = p->next();
     }
   }
 
   bool IsEmpty() const { return first_ == NULL; }
 
   void Add(QueueElement* value) {
     ASSERT(value != NULL);
+    ASSERT(value->next() == NULL);
     if (first_ == NULL) {
       first_ = value;
+      ASSERT(last_ == NULL);
     } else {
       ASSERT(last_ != NULL);
       last_->set_next(value);
     }
-    value->set_next(NULL);
     last_ = value;
+    ASSERT(first_ != NULL && last_ != NULL);
   }
 
   QueueElement* Peek() const {
     return first_;
   }
 
   RawFunction* PeekFunction() const {
     QueueElement* e = Peek();
     if (e == NULL) {
       return Function::null();
@@ skipping 32 matching lines @@
 
 
 BackgroundCompiler::BackgroundCompiler(Isolate* isolate)
     : isolate_(isolate), running_(true), done_(new bool()),
       queue_monitor_(new Monitor()), done_monitor_(new Monitor()),
       function_queue_(new BackgroundCompilationQueue()) {
   *done_ = false;
 }
 
 
+// Fields all deleted in ::Stop; here clear them.
+BackgroundCompiler::~BackgroundCompiler() {
+  isolate_ = NULL;
+  running_ = false;
+  done_ = NULL;
+  queue_monitor_ = NULL;
+  done_monitor_ = NULL;
+  function_queue_ = NULL;
+}
+
+
 void BackgroundCompiler::Run() {
   while (running_) {
     // Maybe something is already in the queue, check first before waiting
     // to be notified.
     bool result = Thread::EnterIsolateAsHelper(isolate_, Thread::kCompilerTask);
     ASSERT(result);
     {
       Thread* thread = Thread::Current();
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       HANDLESCOPE(thread);
       Function& function = Function::Handle(zone);
-      function = function_queue()->PeekFunction();
+      { MonitorLocker ml(queue_monitor_);
+        function = function_queue()->PeekFunction();
+      }
       while (running_ && !function.IsNull()) {
         // Check that we have aggregated and cleared the stats.
         ASSERT(thread->compiler_stats()->IsCleared());
         const Error& error = Error::Handle(zone,
             Compiler::CompileOptimizedFunction(thread,
                                                function,
                                                Compiler::kNoOSRDeoptId));
         // TODO(srdjan): We do not expect errors while compiling optimized
         // code, any errors should have been caught when compiling
         // unoptimized code. Any issues while optimizing are flagged by
         // making the result invalid.
         ASSERT(error.IsNull());
 #ifndef PRODUCT
         Isolate* isolate = thread->isolate();
         // We cannot aggregate stats if isolate is shutting down.
         if (isolate->HasMutatorThread()) {
           isolate->aggregate_compiler_stats()->Add(*thread->compiler_stats());
         }
         thread->compiler_stats()->Clear();
 #endif  // PRODUCT
-        QueueElement* qelem = function_queue()->Remove();
+
+        QueueElement* qelem = NULL;
+        { MonitorLocker ml(queue_monitor_);
+          qelem = function_queue()->Remove();
+          function = function_queue()->PeekFunction();
+        }
         delete qelem;
-        function = function_queue()->PeekFunction();
       }
     }
     Thread::ExitIsolateAsHelper();
     {
       // Wait to be notified when the work queue is not empty.
       MonitorLocker ml(queue_monitor_);
       while (function_queue()->IsEmpty() && running_) {
         ml.Wait();
       }
     }
@@ skipping 199 matching lines @@
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart