Track loading happening in parallel with background compilation and abort compilation if necessary.

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 360 matching lines @@
 
 class CompileParsedFunctionHelper : public ValueObject {
  public:
   CompileParsedFunctionHelper(ParsedFunction* parsed_function,
                               bool optimized,
                               intptr_t osr_id)
       : parsed_function_(parsed_function),
         optimized_(optimized),
         osr_id_(osr_id),
         thread_(Thread::Current()),
-        cha_invalidation_gen_at_start_(isolate()->cha_invalidation_gen()),
         field_invalidation_gen_at_start_(isolate()->field_invalidation_gen()),
-        prefix_invalidation_gen_at_start_(
-            isolate()->prefix_invalidation_gen()) {
+        loading_invalidation_gen_at_start_(
+            isolate()->loading_invalidation_gen()) {
   }
 
   bool Compile(CompilationPipeline* pipeline);
-  uint32_t prefix_invalidation_gen_at_start() const {
-    return prefix_invalidation_gen_at_start_;
-  }
 
  private:
   ParsedFunction* parsed_function() const { return parsed_function_; }
   bool optimized() const { return optimized_; }
   intptr_t osr_id() const { return osr_id_; }
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
-  uint32_t cha_invalidation_gen_at_start() const {
-    return cha_invalidation_gen_at_start_;
-  }
   uint32_t field_invalidation_gen_at_start() const {
     return field_invalidation_gen_at_start_;
   }
+  uint32_t loading_invalidation_gen_at_start() const {
+    return loading_invalidation_gen_at_start_;
+  }
   void FinalizeCompilation(Assembler* assembler,
                            FlowGraphCompiler* graph_compiler,
                            FlowGraph* flow_graph);
 
   ParsedFunction* parsed_function_;
   const bool optimized_;
   const intptr_t osr_id_;
   Thread* const thread_;
-  const uint32_t cha_invalidation_gen_at_start_;
   const uint32_t field_invalidation_gen_at_start_;
-  const uint32_t prefix_invalidation_gen_at_start_;
+  const uint32_t loading_invalidation_gen_at_start_;
 
   DISALLOW_COPY_AND_ASSIGN(CompileParsedFunctionHelper);
 };
 
 
 void CompileParsedFunctionHelper::FinalizeCompilation(
     Assembler* assembler,
     FlowGraphCompiler* graph_compiler,
     FlowGraph* flow_graph) {
   ASSERT(!FLAG_precompiled_mode);
@@ skipping 69 matching lines @@
       const bool is_osr = osr_id() != Compiler::kNoOSRDeoptId;
       function.InstallOptimizedCode(code, is_osr);
       code_was_installed = true;
     } else {
       // Background compilation.
       // Before installing code check generation counts if the code may
       // have become invalid.
       const bool trace_compiler =
           FLAG_trace_compiler || FLAG_trace_optimizing_compiler;
       bool code_is_valid = true;
-      if (!thread()->cha()->leaf_classes().is_empty()) {
-        if (cha_invalidation_gen_at_start() !=
-            isolate()->cha_invalidation_gen()) {
-          code_is_valid = false;
-          if (trace_compiler) {
-            THR_Print("--> FAIL: CHA invalidation.");
-          }
-        }
-      }
       if (!flow_graph->parsed_function().guarded_fields()->is_empty()) {
         if (field_invalidation_gen_at_start() !=
             isolate()->field_invalidation_gen()) {
           code_is_valid = false;
           if (trace_compiler) {
             THR_Print("--> FAIL: Field invalidation.");
           }
         }
       }
-      if (parsed_function()->HasDeferredPrefixes()) {
-        if (prefix_invalidation_gen_at_start() !=
-            isolate()->prefix_invalidation_gen()) {
-          code_is_valid = false;
-          if (trace_compiler) {
-            THR_Print("--> FAIL: Prefix invalidation.");
-          }
+      if (loading_invalidation_gen_at_start() !=
+          isolate()->loading_invalidation_gen()) {
+        code_is_valid = false;
+        if (trace_compiler) {
+          THR_Print("--> FAIL: Loading invalidation.");
         }
       }
       if (code_is_valid) {
         const bool is_osr = osr_id() != Compiler::kNoOSRDeoptId;
         ASSERT(!is_osr);  // OSR is not compiled in background.
         function.InstallOptimizedCode(code, is_osr);
         code_was_installed = true;
       }
       if (function.usage_counter() < 0) {
         // Reset to 0 so that it can be recompiled if needed.
@@ skipping 608 matching lines @@
                 (optimized ? "optimized " : ""),
                 (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos().ToCString(),
                 token_size);
     }
     INC_STAT(thread, num_functions_compiled, 1);
     if (optimized) {
       INC_STAT(thread, num_functions_optimized, 1);
     }
-    // Makes sure no libraries are loaded during parsing.
-    const uint32_t prefix_invalidation_gen_at_start =
-        isolate->prefix_invalidation_gen();
+    // Makes sure no classes are loaded during parsing in background.
+    const uint32_t loading_invalidation_gen_at_start =
+        isolate->loading_invalidation_gen();
     {
       HANDLESCOPE(thread);
       const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
       pipeline->ParseFunction(parsed_function);
       const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
       INC_STAT(thread,
                num_func_tokens_compiled,
                num_tokens_after - num_tokens_before);
     }
 
+
     CompileParsedFunctionHelper helper(parsed_function, optimized, osr_id);
-    if (prefix_invalidation_gen_at_start !=
-        helper.prefix_invalidation_gen_at_start()) {
-      ASSERT(Compiler::IsBackgroundCompilation());
-      // Deferred loading occured while parsing or copying ICData. We need
-      // to abort here because deopt-ids may have changed.
-      Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);
+
+    if (Compiler::IsBackgroundCompilation()) {
+      if (isolate->top_level_parsing() ||

[siva, 2016/03/28 17:20:14]

top level parsing is set in the mutator thread and accessed here without any
locks, seems racy.

Is this check needed, won't top level parsing result in the invalidation_gen
value being incremented?

[srdjan, 2016/03/28 19:54:54]

As discussed, we need to make top_level_parsing flag and increment counters
atomically updated.
We need this check in case loading takes longer than compilation.

+              (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);
+      }
     }
+
     const bool success = helper.Compile(pipeline);
     if (!success) {
       if (optimized) {
         if (Compiler::IsBackgroundCompilation()) {
           // Try again later, background compilation may abort because of
           // state change during compilation.
           if (FLAG_trace_compiler) {
             THR_Print("Aborted background compilation: %s\n",
                 function.ToFullyQualifiedCString());
           }
@@ skipping 720 matching lines @@
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart