Remove GC prologue and epilogue callbacks.

runtime/vm/scavenger.cc

 // Copyright (c) 2011, 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/scavenger.h"
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 354 matching lines @@
   }
   double garbage = stats_history_.Get(0).GarbageFraction();
   if (garbage < (FLAG_new_gen_garbage_threshold / 100.0)) {
     return Utils::Minimum(max_semi_capacity_in_words_,
                           old_size_in_words * FLAG_new_gen_growth_factor);
   } else {
     return old_size_in_words;
   }
 }
 
-SemiSpace* Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
-  if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
-    (isolate->gc_prologue_callback())();
-  }
+SemiSpace* Scavenger::Prologue(Isolate* isolate) {
   isolate->PrepareForGC();
 
   // Flip the two semi-spaces so that to_ is always the space for allocating
   // objects.
   SemiSpace* from = to_;
 
   const intptr_t kVmNameSize = 128;
   char vm_name[kVmNameSize];
   Heap::RegionName(heap_, Heap::kNew, vm_name, kVmNameSize);
   to_ = SemiSpace::New(NewSizeInWords(from->size_in_words()), vm_name);
   if (to_ == NULL) {
     // TODO(koda): We could try to recover (collect old space, wait for another
     // isolate to finish scavenge, etc.).
     OUT_OF_MEMORY();
   }
   UpdateMaxHeapCapacity();
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 
   return from;
 }
 
-void Scavenger::Epilogue(Isolate* isolate,
-                         SemiSpace* from,
-                         bool invoke_api_callbacks) {
+void Scavenger::Epilogue(Isolate* isolate, SemiSpace* from) {
   // All objects in the to space have been copied from the from space at this
   // moment.
 
   // Ensure the mutator thread will fail the next allocation. This will force
   // mutator to allocate a new TLAB
   Thread* mutator_thread = isolate->mutator_thread();
   ASSERT((mutator_thread == NULL) || (!mutator_thread->HasActiveTLAB()));
 
   double avg_frac = stats_history_.Get(0).PromoCandidatesSuccessFraction();
   if (stats_history_.Size() >= 2) {
@@ skipping 20 matching lines @@
       VerifyStoreBufferPointerVisitor verify_store_buffer_visitor(isolate, to_);
       heap_->old_space()->VisitObjectPointers(&verify_store_buffer_visitor);
     }
   }
 #endif  // defined(DEBUG)
   from->Delete();
   UpdateMaxHeapUsage();
   if (heap_ != NULL) {
     heap_->UpdateGlobalMaxUsed();
   }
-  if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
-    (isolate->gc_epilogue_callback())();
-  }
 }
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
   // Iterating through the store buffers.
   // Grab the deduplication sets out of the isolate's consolidated store buffer.
   StoreBufferBlock* pending = isolate->store_buffer()->Blocks();
   intptr_t total_count = 0;
   while (pending != NULL) {
     StoreBufferBlock* next = pending->next();
@@ skipping 330 matching lines @@
         return raw_obj;  // Found object, return it.
       }
       cur = next;
     }
     ASSERT(cur == top_);
   }
   return Object::null();
 }
 
 void Scavenger::Scavenge() {
-  // TODO(cshapiro): Add a decision procedure for determining when the
-  // the API callbacks should be invoked.
-  Scavenge(false);
-}
-
-void Scavenger::Scavenge(bool invoke_api_callbacks) {
   Isolate* isolate = heap_->isolate();
   // Ensure that all threads for this isolate are at a safepoint (either stopped
   // or in native code). If two threads are racing at this point, the loser
   // will continue with its scavenge after waiting for the winner to complete.
   // TODO(koda): Consider moving SafepointThreads into allocation failure/retry
   // logic to avoid needless collections.
 
   int64_t pre_safe_point = OS::GetCurrentMonotonicMicros();
 
   Thread* thread = Thread::Current();
@@ skipping 17 matching lines @@
   if (FLAG_verify_before_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying before Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
   // Prepare for a scavenge.
   SpaceUsage usage_before = GetCurrentUsage();
   intptr_t promo_candidate_words =
       (survivor_end_ - FirstObjectStart()) / kWordSize;
-  SemiSpace* from = Prologue(isolate, invoke_api_callbacks);
+  SemiSpace* from = Prologue(isolate);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
     StackZone zone(thread);
     // Setup the visitor and run the scavenge.
     ScavengerVisitor visitor(isolate, this, from);
     page_space->AcquireDataLock();
     IterateRoots(isolate, &visitor);
     int64_t start = OS::GetCurrentMonotonicMicros();
     ProcessToSpace(&visitor);
     int64_t middle = OS::GetCurrentMonotonicMicros();
     {
       TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
       ScavengerWeakVisitor weak_visitor(thread, this);
       IterateWeakRoots(isolate, &weak_visitor);
     }
     ProcessWeakReferences();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentMonotonicMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
     stats_history_.Add(ScavengeStats(
         start, end, usage_before, GetCurrentUsage(), promo_candidate_words,
         visitor.bytes_promoted() >> kWordSizeLog2));
   }
-  Epilogue(isolate, from, invoke_api_callbacks);
+  Epilogue(isolate, from);
 
   // TODO(koda): Make verification more compatible with concurrent sweep.
   if (FLAG_verify_after_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying after Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
@@ skipping 83 matching lines @@
   return free_space >> kWordSizeLog2;
 }
 
 int64_t Scavenger::UsedInWords() const {
   int64_t free_space_in_tlab = FreeSpaceInWords(heap_->isolate());
   int64_t max_space_used = (top_ - FirstObjectStart()) >> kWordSizeLog2;
   return max_space_used - free_space_in_tlab;
 }
 
 }  // namespace dart