Commit 97c135fa authored by hpayer@chromium.org's avatar hpayer@chromium.org

Re-land "Add finalize sweeping event to GCIdleTimeHandler."

BUG=
R=ulan@chromium.org

Review URL: https://codereview.chromium.org/496303002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23309 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 8b692bd8
......@@ -11,6 +11,7 @@ namespace internal {
const double GCIdleTimeHandler::kConservativeTimeRatio = 0.9;
const size_t GCIdleTimeHandler::kMaxMarkCompactTimeInMs = 1000000;
const size_t GCIdleTimeHandler::kMinTimeForFinalizeSweeping = 100;
size_t GCIdleTimeHandler::EstimateMarkingStepSize(
......@@ -30,8 +31,7 @@ size_t GCIdleTimeHandler::EstimateMarkingStepSize(
if (marking_step_size > kMaximumMarkingStepSize)
return kMaximumMarkingStepSize;
return static_cast<size_t>(marking_step_size *
GCIdleTimeHandler::kConservativeTimeRatio);
return static_cast<size_t>(marking_step_size * kConservativeTimeRatio);
}
......@@ -45,7 +45,7 @@ size_t GCIdleTimeHandler::EstimateMarkCompactTime(
}
GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms,
GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms,
HeapState heap_state,
GCTracer* gc_tracer) {
if (IsIdleRoundFinished()) {
......@@ -58,8 +58,8 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms,
if (heap_state.incremental_marking_stopped) {
size_t speed =
static_cast<size_t>(gc_tracer->MarkCompactSpeedInBytesPerMillisecond());
if (idle_time_in_ms >= static_cast<int>(EstimateMarkCompactTime(
heap_state.size_of_objects, speed))) {
if (idle_time_in_ms >=
EstimateMarkCompactTime(heap_state.size_of_objects, speed)) {
// If there are no more than two GCs left in this idle round and we are
// allowed to do a full GC, then make those GCs full in order to compact
// the code space.
......@@ -76,6 +76,12 @@ GCIdleTimeAction GCIdleTimeHandler::Compute(int idle_time_in_ms,
return GCIdleTimeAction::Nothing();
}
}
// TODO(hpayer): Estimate finalize sweeping time.
if (heap_state.sweeping_in_progress &&
idle_time_in_ms >= kMinTimeForFinalizeSweeping) {
return GCIdleTimeAction::FinalizeSweeping();
}
intptr_t speed = gc_tracer->IncrementalMarkingSpeedInBytesPerMillisecond();
size_t step_size =
static_cast<size_t>(EstimateMarkingStepSize(idle_time_in_ms, speed));
......
......@@ -14,7 +14,8 @@ enum GCIdleTimeActionType {
DO_NOTHING,
DO_INCREMENTAL_MARKING,
DO_SCAVENGE,
DO_FULL_GC
DO_FULL_GC,
DO_FINALIZE_SWEEPING
};
......@@ -26,18 +27,21 @@ class GCIdleTimeAction {
result.parameter = 0;
return result;
}
static GCIdleTimeAction IncrementalMarking(intptr_t step_size) {
GCIdleTimeAction result;
result.type = DO_INCREMENTAL_MARKING;
result.parameter = step_size;
return result;
}
static GCIdleTimeAction Scavenge() {
GCIdleTimeAction result;
result.type = DO_SCAVENGE;
result.parameter = 0;
return result;
}
static GCIdleTimeAction FullGC() {
GCIdleTimeAction result;
result.type = DO_FULL_GC;
......@@ -45,6 +49,13 @@ class GCIdleTimeAction {
return result;
}
static GCIdleTimeAction FinalizeSweeping() {
GCIdleTimeAction result;
result.type = DO_FINALIZE_SWEEPING;
result.parameter = 0;
return result;
}
GCIdleTimeActionType type;
intptr_t parameter;
};
......@@ -74,18 +85,23 @@ class GCIdleTimeHandler {
// Maximum mark-compact time returned by EstimateMarkCompactTime.
static const size_t kMaxMarkCompactTimeInMs;
// Minimum time to finalize sweeping phase. The main thread may wait for
// sweeper threads.
static const size_t kMinTimeForFinalizeSweeping;
struct HeapState {
int contexts_disposed;
size_t size_of_objects;
bool incremental_marking_stopped;
bool can_start_incremental_marking;
bool sweeping_in_progress;
};
GCIdleTimeHandler()
: mark_compacts_since_idle_round_started_(0),
scavenges_since_last_idle_round_(0) {}
GCIdleTimeAction Compute(int idle_time_in_ms, HeapState heap_state,
GCIdleTimeAction Compute(size_t idle_time_in_ms, HeapState heap_state,
GCTracer* gc_tracer);
void NotifyIdleMarkCompact() {
......
......@@ -4296,6 +4296,8 @@ bool Heap::IdleNotification(int idle_time_in_ms) {
heap_state.incremental_marking_stopped = incremental_marking()->IsStopped();
// TODO(ulan): Start incremental marking only for large heaps.
heap_state.can_start_incremental_marking = true;
heap_state.sweeping_in_progress =
mark_compact_collector()->sweeping_in_progress();
GCIdleTimeAction action =
gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state, tracer());
......@@ -4321,18 +4323,13 @@ bool Heap::IdleNotification(int idle_time_in_ms) {
case DO_SCAVENGE:
CollectGarbage(NEW_SPACE, "idle notification: scavenge");
break;
case DO_FINALIZE_SWEEPING:
mark_compact_collector()->EnsureSweepingCompleted();
break;
case DO_NOTHING:
result = true;
break;
}
// If the IdleNotifcation is called with a large hint we will wait for
// the sweepter threads here.
// TODO(ulan): move this in GCIdleTimeHandler.
const int kMinHintForFullGC = 100;
if (idle_time_in_ms >= kMinHintForFullGC &&
mark_compact_collector()->sweeping_in_progress()) {
mark_compact_collector()->EnsureSweepingCompleted();
}
return result;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment