Object* Heap::roots_[Heap::kRootListLength];
Object* Heap::global_contexts_list_;
+
NewSpace Heap::new_space_;
OldSpace* Heap::old_pointer_space_ = NULL;
OldSpace* Heap::old_data_space_ = NULL;
CellSpace* Heap::cell_space_ = NULL;
LargeObjectSpace* Heap::lo_space_ = NULL;
+static const intptr_t kMinimumPromotionLimit = 2 * MB;
+static const intptr_t kMinimumAllocationLimit = 8 * MB;
+
intptr_t Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;
intptr_t Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;
}
-void Heap::CollectAllGarbage(bool force_compaction,
- CollectionPolicy collectionPolicy) {
+void Heap::CollectAllGarbage(bool force_compaction) {
// Since we are ignoring the return value, the exact choice of space does
// not matter, so long as we do not specify NEW_SPACE, which would not
// cause a full GC.
MarkCompactCollector::SetForceCompaction(force_compaction);
- CollectGarbage(OLD_POINTER_SPACE, collectionPolicy);
+ CollectGarbage(OLD_POINTER_SPACE);
MarkCompactCollector::SetForceCompaction(false);
}
-void Heap::CollectAllAvailableGarbage() {
- CompilationCache::Clear();
- CollectAllGarbage(true, AGGRESSIVE);
-}
-
-
-void Heap::CollectGarbage(AllocationSpace space,
- CollectionPolicy collectionPolicy) {
+void Heap::CollectGarbage(AllocationSpace space) {
// The VM is in the GC state until exiting this function.
VMState state(GC);
? &Counters::gc_scavenger
: &Counters::gc_compactor;
rate->Start();
- PerformGarbageCollection(collector, &tracer, collectionPolicy);
+ PerformGarbageCollection(collector, &tracer);
rate->Stop();
GarbageCollectionEpilogue();
void Heap::PerformScavenge() {
GCTracer tracer;
- PerformGarbageCollection(SCAVENGER, &tracer, NORMAL);
+ PerformGarbageCollection(SCAVENGER, &tracer);
}
}
void Heap::PerformGarbageCollection(GarbageCollector collector,
- GCTracer* tracer,
- CollectionPolicy collectionPolicy) {
+ GCTracer* tracer) {
if (collector != SCAVENGER) {
PROFILE(CodeMovingGCEvent());
}
UpdateSurvivalRateTrend(start_new_space_size);
- UpdateOldSpaceLimits();
-
- // Major GC would invoke weak handle callbacks on weakly reachable
- // handles, but won't collect weakly reachable objects until next
- // major GC. Therefore if we collect aggressively and weak handle callback
- // has been invoked, we rerun major GC to release objects which become
- // garbage.
- if (collectionPolicy == AGGRESSIVE) {
- // Note: as weak callbacks can execute arbitrary code, we cannot
- // hope that eventually there will be no weak callbacks invocations.
- // Therefore stop recollecting after several attempts.
- const int kMaxNumberOfAttempts = 7;
- for (int attempt = 0; attempt < kMaxNumberOfAttempts; attempt++) {
- { DisableAssertNoAllocation allow_allocation;
- GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
- if (!GlobalHandles::PostGarbageCollectionProcessing()) break;
- }
- MarkCompact(tracer);
- // Weak handle callbacks can allocate data, so keep limits correct.
- UpdateOldSpaceLimits();
- }
- } else {
- if (high_survival_rate_during_scavenges &&
- IsStableOrIncreasingSurvivalTrend()) {
- // Stable high survival rates of young objects both during partial and
- // full collection indicate that mutator is either building or modifying
- // a structure with a long lifetime.
- // In this case we aggressively raise old generation memory limits to
- // postpone subsequent mark-sweep collection and thus trade memory
- // space for the mutation speed.
- old_gen_promotion_limit_ *= 2;
- old_gen_allocation_limit_ *= 2;
- }
+ intptr_t old_gen_size = PromotedSpaceSize();
+ old_gen_promotion_limit_ =
+ old_gen_size + Max(kMinimumPromotionLimit, old_gen_size / 3);
+ old_gen_allocation_limit_ =
+ old_gen_size + Max(kMinimumAllocationLimit, old_gen_size / 2);
+
+ if (high_survival_rate_during_scavenges &&
+ IsStableOrIncreasingSurvivalTrend()) {
+ // Stable high survival rates of young objects both during partial and
+ // full collection indicate that mutator is either building or modifying
+ // a structure with a long lifetime.
+ // In this case we aggressively raise old generation memory limits to
+ // postpone subsequent mark-sweep collection and thus trade memory
+ // space for the mutation speed.
+ old_gen_promotion_limit_ *= 2;
+ old_gen_allocation_limit_ *= 2;
}
- { DisableAssertNoAllocation allow_allocation;
- GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
- GlobalHandles::PostGarbageCollectionProcessing();
- }
+ old_gen_exhausted_ = false;
} else {
tracer_ = tracer;
Scavenge();
Counters::objs_since_last_young.Set(0);
+ if (collector == MARK_COMPACTOR) {
+ DisableAssertNoAllocation allow_allocation;
+ GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
+ GlobalHandles::PostGarbageCollectionProcessing();
+ }
+
// Update relocatables.
Relocatable::PostGarbageCollectionProcessing();
static void GarbageCollectionPrologue();
static void GarbageCollectionEpilogue();
- enum CollectionPolicy { NORMAL, AGGRESSIVE };
-
// Performs garbage collection operation.
// Returns whether required_space bytes are available after the collection.
- static void CollectGarbage(AllocationSpace space,
- CollectionPolicy collectionPolicy = NORMAL);
+ static void CollectGarbage(AllocationSpace space);
// Performs a full garbage collection. Force compaction if the
// parameter is true.
- static void CollectAllGarbage(bool force_compaction,
- CollectionPolicy collectionPolicy = NORMAL);
-
- // Last hope GC, should try to squeeze as much as possible.
- static void CollectAllAvailableGarbage();
+ static void CollectAllGarbage(bool force_compaction);
// Notify the heap that a context has been disposed.
static int NotifyContextDisposed() { return ++contexts_disposed_; }
// Performs garbage collection
static void PerformGarbageCollection(GarbageCollector collector,
- GCTracer* tracer,
- CollectionPolicy collectionPolicy);
-
- static const intptr_t kMinimumPromotionLimit = 2 * MB;
- static const intptr_t kMinimumAllocationLimit = 8 * MB;
-
- inline static void UpdateOldSpaceLimits();
+ GCTracer* tracer);
// Allocate an uninitialized object in map space. The behavior is identical
// to Heap::AllocateRaw(size_in_bytes, MAP_SPACE), except that (a) it doesn't