Print messages when aborting background compilation (--trace-compiler); turn on background compilat…

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 639 matching lines @@
                  (function.deoptimization_counter() <
                      FLAG_max_deoptimization_counter_threshold));
 
           // 'Freeze' ICData in background compilation so that it does not
           // change while compiling.
           const bool clone_ic_data = Compiler::IsBackgroundCompilation();
           function.RestoreICDataMap(ic_data_array, clone_ic_data);
 
           if (Compiler::IsBackgroundCompilation() &&
               (function.ic_data_array() == Array::null())) {
-            Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);
+            Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
+                "RestoreICDataMap: ICData array cleared.");
           }
           if (FLAG_print_ic_data_map) {
             for (intptr_t i = 0; i < ic_data_array->length(); i++) {
               if ((*ic_data_array)[i] != NULL) {
                 THR_Print("%" Pd " ", i);
                 FlowGraphPrinter::PrintICData(*(*ic_data_array)[i]);
               }
             }
           }
         }
@@ skipping 389 matching lines @@
           // instruction object, since the creation of instruction object
           // changes code page access permissions (makes them temporary not
           // executable).
           {
             SafepointOperationScope safepoint_scope(thread());
             // Do not Garbage collect during this stage and instead allow the
             // heap to grow.
             NoHeapGrowthControlScope no_growth_control;
             if (!isolate()->background_compiler()->is_running()) {
               // The background compiler is being stopped.
-              Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);
+              Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
+                  "Background compilation is being stopped");
             }
             FinalizeCompilation(&assembler, &graph_compiler, flow_graph);
           }
           if (isolate()->heap()->NeedsGarbageCollection()) {
             isolate()->heap()->CollectAllGarbage();
           }
         }
       }
       // Mark that this isolate now has compiled code.
       isolate()->set_has_compiled_code(true);
@@ skipping 107 matching lines @@
 
 
     CompileParsedFunctionHelper helper(parsed_function, optimized, osr_id);
 
     if (Compiler::IsBackgroundCompilation()) {
       if (isolate->IsTopLevelParsing() ||
               (loading_invalidation_gen_at_start !=
                isolate->loading_invalidation_gen())) {
         // Loading occured while parsing. We need to abort here because state
         // changed while compiling.
-        Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);
+        Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
+            "Invalidated state during parsing because of script loading");
       }
     }
 
     const bool success = helper.Compile(pipeline);
     if (success) {
       if (!optimized) {
         function.set_was_compiled(true);
       }
     } else {
       if (optimized) {
@@ skipping 363 matching lines @@
     Thread* const thread = Thread::Current();
     const Object& result = PassiveObject::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
-void Compiler::AbortBackgroundCompilation(intptr_t deopt_id) {
+void Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   if (FLAG_trace_compiler) {
-    THR_Print("ABORT background compilation\n");
+    THR_Print("ABORT background compilation: %s\n", msg);
+  }
+  TimelineStream* stream = Timeline::GetCompilerStream();
+  ASSERT(stream != NULL);
+  TimelineEvent* event = stream->StartEvent();
+  if (event != NULL) {
+    event->Instant("AbortBackgroundCompilation");
+    event->SetNumArguments(1);
+    event->CopyArgument(0, "reason", msg);
+    event->Complete();
   }
   ASSERT(Compiler::IsBackgroundCompilation());
   Thread::Current()->long_jump_base()->Jump(
       deopt_id, Object::background_compilation_error());
 }
 
 
 // C-heap allocated background compilation queue element.
 class QueueElement {
  public:
@@ skipping 365 matching lines @@
   return DartEntry::InvokeFunction(initializer, Object::empty_array());
 }
 
 
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
   UNREACHABLE();
   return Object::null();
 }
 
 
-void Compiler::AbortBackgroundCompilation(intptr_t deopt_id) {
+void Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   UNREACHABLE();
 }
 
 
 void BackgroundCompiler::CompileOptimized(const Function& function) {
   UNREACHABLE();
 }
 
 
 void BackgroundCompiler::VisitPointers(ObjectPointerVisitor* visitor) {
   UNREACHABLE();
 }
 
 
 void BackgroundCompiler::Stop(BackgroundCompiler* task) {
   UNREACHABLE();
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart