Safepoint interface and unit tests.

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/intermediate_language.h"
 #include "vm/object_store.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/parser.h"
 #include "vm/report.h"
 #include "vm/resolver.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
+#include "vm/thread_registry.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, deoptimize_alot, false,
     "Deoptimizes all live frames when we are about to return to Dart code from"
     " native entries.");
 DEFINE_FLAG(int, max_subtype_cache_entries, 100,
     "Maximum number of subtype cache entries (number of checks cached).");
 DEFINE_FLAG(int, optimization_counter_threshold, 30000,
@@ skipping 1256 matching lines @@
       const int num_vars =
          Compiler::always_optimize() ? 0 : frame->NumLocalVariables();
       intptr_t unused;
       for (intptr_t v = 0; v < num_vars; v++) {
         frame->VariableAt(v, &var_name, &unused, &unused, &var_value);
       }
     }
   }
 
   uword interrupt_bits = isolate->GetAndClearInterrupts();
+  if ((interrupt_bits & Isolate::kSafepointInterrrupt) != 0) {
+    isolate->thread_registry()->CheckSafepoint();

[Ivan Posva, 2015/07/31 20:28:09]

Regardless of the interrupt reason we should check for pending safepoint
rendezvous. Before throwing stack overflow exceptions and other code which can
consume an arbitrary time.

[koda, 2015/07/31 22:40:44]

Done by creating single VM interrupt for all these kinds of checks. The new
version also avoids scheduling redundant GC when the store buffer is no longer
overflowed after the CheckSafepoint.

+    // TODO(koda): Merge safepoint + store buffer into simply "GC interrupt"?
+  }
   if ((interrupt_bits & Isolate::kStoreBufferInterrupt) != 0) {
     if (FLAG_verbose_gc) {
       OS::PrintErr("Scavenge scheduled by store buffer overflow.\n");
     }
     isolate->heap()->CollectGarbage(Heap::kNew);
   }
   if ((interrupt_bits & Isolate::kMessageInterrupt) != 0) {
     bool ok = isolate->message_handler()->HandleOOBMessages();
     if (!ok) {
       // False result from HandleOOBMessages signals that the isolate should
@@ skipping 478 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart