Queueing fix, 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 767 matching lines @@
             // 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);
             result->set_result_code(code);
             // Disable invalidation counters that are not relevant.
             if (thread->cha()->leaf_classes().is_empty()) {
               result->ClearCHAInvalidationGen();
             }
             if (flow_graph->guarded_fields()->is_empty()) {
-              result->ClearFieldInnvalidationGen();
+              result->ClearFieldInvalidationGen();
             }
             if (!parsed_function->HasDeferredPrefixes()) {
-              result->ClearPrefixInnvalidationGen();
+              result->ClearPrefixInvalidationGen();
             }
           } else {
             const bool is_osr = osr_id != Compiler::kNoOSRDeoptId;
             function.InstallOptimizedCode(code, is_osr);
           }
 
           // TODO(srdjan): In background compilation, verify that CHA and field
           // guards have not been invalidated in the meantime.
           // Register code with the classes it depends on because of CHA and
           // fields it depends on because of store guards, unless we cannot
@@ skipping 329 matching lines @@
 #endif
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     StackZone stack_zone(thread);
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
+    ASSERT(!optimized);
+    // Do not attempt to optimize functions that can cause errors.
+    function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
   Isolate* isolate = thread->isolate();
@@ skipping 334 matching lines @@
     ASSERT(Thread::Current()->IsMutatorThread());
     obj_ = Object::null();
   }
 
   void Clear() {
     next_ = NULL;
     obj_ = Object::null();
     cha_invalidation_gen_ = Isolate::kInvalidGen;
     field_invalidation_gen_ = Isolate::kInvalidGen;
     prefix_invalidation_gen_ = Isolate::kInvalidGen;
   }

[siva, 2015/11/06 23:12:54]

This is not used anymore, can be removed?

[srdjan, 2015/12/09 22:43:17]

Done.

 
   RawFunction* Function() const { return Function::RawCast(obj_); }
-  RawCode* Code() const {
-    return (obj_ == Object::null()) ? Code::null() : Code::RawCast(obj_);
-  }
+  RawCode* Code() const { return Code::RawCast(obj_); }
 
   uint32_t cha_invalidation_gen() const { return cha_invalidation_gen_; }
   uint32_t field_invalidation_gen() const { return field_invalidation_gen_; }
   uint32_t prefix_invalidation_gen() const { return prefix_invalidation_gen_; }
 
   void set_next(QueueElement* elem) { next_ = elem; }
   QueueElement* next() const { return next_; }
 
   RawObject** obj_ptr() { return &obj_; }
   RawObject* obj() const { return obj_; }
@@ skipping 188 matching lines @@
       BackgroundCompilationResult result;
       while (running_ && !function.IsNull()) {
         result.Init();
         const Error& error = Error::Handle(zone,
             Compiler::CompileOptimizedFunction(thread,
                                                function,
                                                Compiler::kNoOSRDeoptId,
                                                &result));
         // 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.
+        // unoptimized code. Any issues while optimizing are flagged by
+        // making the result invalid.
         ASSERT(error.IsNull());
-        // Reuse the input QueueElement to return the result.
-        QueueElement* qelem = function_queue()->Remove();
-        qelem->Clear();
-        result_queue()->Add(qelem);
-        // Add 'qelem' to the queue first so that it gets visited by GC.
-        qelem->SetFromResult(result);
+        AddResult(result);
         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();
       }
     }
   }  // while running
 
   {
     // Notify that the thread is done.
     MonitorLocker ml_done(done_monitor_);
     *done_ = true;
     ml_done.Notify();
   }
 }
 
 
+// Use to first queue element to form the result element.
+void BackgroundCompiler::AddResult(const BackgroundCompilationResult& result) {
+  ASSERT(!Thread::Current()->IsMutatorThread());
+  MonitorLocker ml(queue_monitor_);
+  // Reuse the input QueueElement to return the result.
+  QueueElement* qelem = function_queue()->Remove();
+  if (result.IsValid()) {
+    qelem->SetFromResult(result);
+    result_queue()->Add(qelem);
+  }
+}
+
+
 void BackgroundCompiler::CompileOptimized(const Function& function) {
   ASSERT(Thread::Current()->IsMutatorThread());
   MonitorLocker ml(queue_monitor_);
   if (function_queue()->ContainsObj(function)) {
     return;
   }
   QueueElement* elem = new QueueElement(function);
   function_queue()->Add(elem);
   ml.Notify();
 }
@@ skipping 77 matching lines @@
       isolate->set_background_compiler(task);
       start_task = true;
     }
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 }  // namespace dart