Invalidate background compilation only if relevant fields were invalidated.

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 363 matching lines @@
   CompileParsedFunctionHelper(ParsedFunction* parsed_function,
                               bool optimized,
                               intptr_t osr_id)
       : parsed_function_(parsed_function),
         optimized_(optimized),
         osr_id_(osr_id),
         thread_(Thread::Current()),
         field_invalidation_gen_at_start_(isolate()->field_invalidation_gen()),
         loading_invalidation_gen_at_start_(
             isolate()->loading_invalidation_gen()) {
+    if (Compiler::IsBackgroundCompilation()) {
+      Isolate::Current()->ClearDisablingFieldList();

[siva, 2016/04/12 17:46:45]

maybe use 'isolate()' here to avoid another Thread::Current()

[srdjan, 2016/04/12 19:47:18]

Done in next CL.

+    }
   }
 
   bool Compile(CompilationPipeline* pipeline);
 
  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(); }
@@ skipping 11 matching lines @@
   const bool optimized_;
   const intptr_t osr_id_;
   Thread* const thread_;
   const intptr_t field_invalidation_gen_at_start_;
   const intptr_t loading_invalidation_gen_at_start_;
 
   DISALLOW_COPY_AND_ASSIGN(CompileParsedFunctionHelper);
 };
 
 
+// Returns true if any of disabling fields is inside the guarded_fields.
+// The number of guarded_fields and disabling-fields is expected to be small
+// (less than 5).
+static bool CheckDisablingFields(
+    Thread* thread,
+    const ZoneGrowableArray<const Field*>& guarded_fields) {
+  Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
+  Field& field = Field::Handle(zone, isolate->GetDisablingField());
+  while (!field.IsNull()) {
+    for (intptr_t i = 0; i < guarded_fields.length(); i++) {
+      if (guarded_fields.At(i)->raw() == field.raw()) {
+        return true;
+      }
+    }
+    // Get next field.
+    field = isolate->GetDisablingField();
+  }

[siva, 2016/04/12 17:46:45]

This loop acquires/release lock with every access to the Disabling Field list
wouldn't it be better to pass the guarded_fields list into a function
isolate->CheckDisablingFields that acquires the lock once and checks if any
field in guarded fields list is present in the disabling field list.

[srdjan, 2016/04/12 19:47:18]

Since this occurs only while background compiler is at a safepoint, will remove
the lock in GetDisablingField and assert that we are at a safepoint.

+  return false;
+}
+
+
 void CompileParsedFunctionHelper::FinalizeCompilation(
     Assembler* assembler,
     FlowGraphCompiler* graph_compiler,
     FlowGraph* flow_graph) {
   ASSERT(!FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   Zone* const zone = thread()->zone();
 
   CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
   // CreateDeoptInfo uses the object pool and needs to be done before
@@ skipping 67 matching lines @@
     } 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 (!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.");
-          }
+          const ZoneGrowableArray<const Field*>& guarded_fields =
+              *flow_graph->parsed_function().guarded_fields();
+          bool field_conflict = CheckDisablingFields(thread(), guarded_fields);
+          if (field_conflict) {
+            code_is_valid = false;
+            if (trace_compiler) {
+              THR_Print("--> FAIL: Field 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) {
@@ skipping 1441 matching lines @@
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart