Upgrade V8 to 5.1.281.57 DO NOT MERGE
FPIIM-449
Change-Id: Id981b686b4d587ac31697662eb98bb34be42ad90
(cherry picked from commit 3b9bc31999c9787eb726ecdbfd5796bfdec32a18)
diff --git a/src/heap/gc-tracer.cc b/src/heap/gc-tracer.cc
index ec1ad65..3c46f52 100644
--- a/src/heap/gc-tracer.cc
+++ b/src/heap/gc-tracer.cc
@@ -24,6 +24,13 @@
GCTracer::Scope::Scope(GCTracer* tracer, ScopeId scope)
: tracer_(tracer), scope_(scope) {
start_time_ = tracer_->heap_->MonotonicallyIncreasingTimeInMs();
+ // TODO(cbruni): remove once we fully moved to a trace-based system.
+ if (FLAG_runtime_call_stats) {
+ RuntimeCallStats* stats =
+ tracer_->heap_->isolate()->counters()->runtime_call_stats();
+ timer_.Initialize(&stats->GC, stats->current_timer());
+ stats->Enter(&timer_);
+ }
}
@@ -31,26 +38,25 @@
DCHECK(scope_ < NUMBER_OF_SCOPES); // scope_ is unsigned.
tracer_->current_.scopes[scope_] +=
tracer_->heap_->MonotonicallyIncreasingTimeInMs() - start_time_;
+ // TODO(cbruni): remove once we fully moved to a trace-based system.
+ if (FLAG_runtime_call_stats) {
+ tracer_->heap_->isolate()->counters()->runtime_call_stats()->Leave(&timer_);
+ }
}
-
-GCTracer::AllocationEvent::AllocationEvent(double duration,
- size_t allocation_in_bytes) {
- duration_ = duration;
- allocation_in_bytes_ = allocation_in_bytes;
+const char* GCTracer::Scope::Name(ScopeId id) {
+#define CASE(scope) \
+ case Scope::scope: \
+ return "V8.GC_" #scope;
+ switch (id) {
+ TRACER_SCOPES(CASE)
+ case Scope::NUMBER_OF_SCOPES:
+ break;
+ }
+#undef CASE
+ return "(unknown)";
}
-
-GCTracer::ContextDisposalEvent::ContextDisposalEvent(double time) {
- time_ = time;
-}
-
-
-GCTracer::SurvivalEvent::SurvivalEvent(double promotion_ratio) {
- promotion_ratio_ = promotion_ratio;
-}
-
-
GCTracer::Event::Event(Type type, const char* gc_reason,
const char* collector_reason)
: type(type),
@@ -182,9 +188,15 @@
start_time, committed_memory);
heap_->isolate()->counters()->aggregated_memory_heap_used()->AddSample(
start_time, used_memory);
+ // TODO(cbruni): remove once we fully moved to a trace-based system.
+ if (FLAG_runtime_call_stats) {
+ RuntimeCallStats* stats =
+ heap_->isolate()->counters()->runtime_call_stats();
+ timer_.Initialize(&stats->GC, stats->current_timer());
+ stats->Enter(&timer_);
+ }
}
-
void GCTracer::Stop(GarbageCollector collector) {
start_counter_--;
if (start_counter_ != 0) {
@@ -215,6 +227,7 @@
heap_->isolate()->counters()->aggregated_memory_heap_used()->AddSample(
current_.end_time, used_memory);
+ double duration = current_.end_time - current_.start_time;
if (current_.type == Event::SCAVENGER) {
current_.incremental_marking_steps =
current_.cumulative_incremental_marking_steps -
@@ -228,7 +241,10 @@
current_.pure_incremental_marking_duration =
current_.cumulative_pure_incremental_marking_duration -
previous_.cumulative_pure_incremental_marking_duration;
- scavenger_events_.push_front(current_);
+ recorded_scavenges_total_.Push(
+ MakeBytesAndDuration(current_.new_space_object_size, duration));
+ recorded_scavenges_survived_.Push(MakeBytesAndDuration(
+ current_.survived_new_space_object_size, duration));
} else if (current_.type == Event::INCREMENTAL_MARK_COMPACTOR) {
current_.incremental_marking_steps =
current_.cumulative_incremental_marking_steps -
@@ -247,20 +263,24 @@
previous_incremental_mark_compactor_event_
.cumulative_pure_incremental_marking_duration;
longest_incremental_marking_step_ = 0.0;
- incremental_mark_compactor_events_.push_front(current_);
+ recorded_incremental_marking_steps_.Push(
+ MakeBytesAndDuration(current_.incremental_marking_bytes,
+ current_.pure_incremental_marking_duration));
+ recorded_incremental_mark_compacts_.Push(
+ MakeBytesAndDuration(current_.start_object_size, duration));
combined_mark_compact_speed_cache_ = 0.0;
} else {
DCHECK(current_.incremental_marking_bytes == 0);
DCHECK(current_.incremental_marking_duration == 0);
DCHECK(current_.pure_incremental_marking_duration == 0);
longest_incremental_marking_step_ = 0.0;
- mark_compactor_events_.push_front(current_);
+ recorded_mark_compacts_.Push(
+ MakeBytesAndDuration(current_.start_object_size, duration));
combined_mark_compact_speed_cache_ = 0.0;
}
// TODO(ernstm): move the code below out of GCTracer.
- double duration = current_.end_time - current_.start_time;
double spent_in_mutator = Max(current_.start_time - previous_.end_time, 0.0);
heap_->UpdateCumulativeGCStatistics(duration, spent_in_mutator,
@@ -281,6 +301,10 @@
longest_incremental_marking_finalization_step_ = 0.0;
cumulative_incremental_marking_finalization_steps_ = 0;
cumulative_incremental_marking_finalization_duration_ = 0.0;
+ // TODO(cbruni): remove once we fully moved to a trace-based system.
+ if (FLAG_runtime_call_stats) {
+ heap_->isolate()->counters()->runtime_call_stats()->Leave(&timer_);
+ }
}
@@ -313,11 +337,14 @@
void GCTracer::AddAllocation(double current_ms) {
allocation_time_ms_ = current_ms;
- new_space_allocation_events_.push_front(AllocationEvent(
- allocation_duration_since_gc_, new_space_allocation_in_bytes_since_gc_));
- old_generation_allocation_events_.push_front(
- AllocationEvent(allocation_duration_since_gc_,
- old_generation_allocation_in_bytes_since_gc_));
+ if (allocation_duration_since_gc_ > 0) {
+ recorded_new_generation_allocations_.Push(
+ MakeBytesAndDuration(new_space_allocation_in_bytes_since_gc_,
+ allocation_duration_since_gc_));
+ recorded_old_generation_allocations_.Push(
+ MakeBytesAndDuration(old_generation_allocation_in_bytes_since_gc_,
+ allocation_duration_since_gc_));
+ }
allocation_duration_since_gc_ = 0;
new_space_allocation_in_bytes_since_gc_ = 0;
old_generation_allocation_in_bytes_since_gc_ = 0;
@@ -325,19 +352,19 @@
void GCTracer::AddContextDisposalTime(double time) {
- context_disposal_events_.push_front(ContextDisposalEvent(time));
+ recorded_context_disposal_times_.Push(time);
}
void GCTracer::AddCompactionEvent(double duration,
intptr_t live_bytes_compacted) {
- compaction_events_.push_front(
- CompactionEvent(duration, live_bytes_compacted));
+ recorded_compactions_.Push(
+ MakeBytesAndDuration(live_bytes_compacted, duration));
}
void GCTracer::AddSurvivalRatio(double promotion_ratio) {
- survival_events_.push_front(SurvivalEvent(promotion_ratio));
+ recorded_survival_ratios_.Push(promotion_ratio);
}
@@ -394,9 +421,8 @@
static_cast<double>(current_.end_object_size) / MB,
static_cast<double>(current_.end_memory_size) / MB);
- int external_time = static_cast<int>(current_.scopes[Scope::EXTERNAL]);
double duration = current_.end_time - current_.start_time;
- Output("%.1f / %d ms", duration, external_time);
+ Output("%.1f / %.1f ms", duration, TotalExternalTime());
if (current_.type == Event::SCAVENGER) {
if (current_.incremental_marking_steps > 0) {
@@ -448,10 +474,12 @@
"code=%.2f "
"semispace=%.2f "
"object_groups=%.2f "
+ "external_prologue=%.2f "
+ "external_epilogue=%.2f "
+ "external_weak_global_handles=%.2f "
"steps_count=%d "
"steps_took=%.1f "
- "scavenge_throughput=%" V8_PTR_PREFIX
- "d "
+ "scavenge_throughput=%.f "
"total_size_before=%" V8_PTR_PREFIX
"d "
"total_size_after=%" V8_PTR_PREFIX
@@ -473,8 +501,7 @@
"average_survival_ratio=%.1f%% "
"promotion_rate=%.1f%% "
"semi_space_copy_rate=%.1f%% "
- "new_space_allocation_throughput=%" V8_PTR_PREFIX
- "d "
+ "new_space_allocation_throughput=%.1f "
"context_disposal_rate=%.1f\n",
heap_->isolate()->time_millis_since_init(), duration,
spent_in_mutator, current_.TypeName(true),
@@ -486,6 +513,9 @@
current_.scopes[Scope::SCAVENGER_CODE_FLUSH_CANDIDATES],
current_.scopes[Scope::SCAVENGER_SEMISPACE],
current_.scopes[Scope::SCAVENGER_OBJECT_GROUPS],
+ current_.scopes[Scope::SCAVENGER_EXTERNAL_PROLOGUE],
+ current_.scopes[Scope::SCAVENGER_EXTERNAL_EPILOGUE],
+ current_.scopes[Scope::EXTERNAL_WEAK_GLOBAL_HANDLES],
current_.incremental_marking_steps,
current_.incremental_marking_duration,
ScavengeSpeedInBytesPerMillisecond(),
@@ -509,7 +539,6 @@
"mutator=%.1f "
"gc=%s "
"reduce_memory=%d "
- "external=%.1f "
"clear=%1.f "
"clear.code_flush=%.1f "
"clear.dependent_code=%.1f "
@@ -524,18 +553,27 @@
"evacuate=%.1f "
"evacuate.candidates=%.1f "
"evacuate.clean_up=%.1f "
- "evacuate.new_space=%.1f "
+ "evacuate.copy=%.1f "
"evacuate.update_pointers=%.1f "
"evacuate.update_pointers.between_evacuated=%.1f "
"evacuate.update_pointers.to_evacuated=%.1f "
"evacuate.update_pointers.to_new=%.1f "
"evacuate.update_pointers.weak=%.1f "
+ "external.mc_prologue=%.1f "
+ "external.mc_epilogue=%.1f "
+ "external.mc_incremental_prologue=%.1f "
+ "external.mc_incremental_epilogue=%.1f "
+ "external.weak_global_handles=%.1f "
"finish=%.1f "
"mark=%.1f "
"mark.finish_incremental=%.1f "
"mark.prepare_code_flush=%.1f "
"mark.roots=%.1f "
"mark.weak_closure=%.1f "
+ "mark.weak_closure.ephemeral=%.1f "
+ "mark.weak_closure.weak_handles=%.1f "
+ "mark.weak_closure.weak_roots=%.1f "
+ "mark.weak_closure.harmony=%.1f "
"sweep=%.1f "
"sweep.code=%.1f "
"sweep.map=%.1f "
@@ -547,8 +585,7 @@
"finalization_steps_count=%d "
"finalization_steps_took=%.1f "
"finalization_longest_step=%.1f "
- "incremental_marking_throughput=%" V8_PTR_PREFIX
- "d "
+ "incremental_marking_throughput=%.f "
"total_size_before=%" V8_PTR_PREFIX
"d "
"total_size_after=%" V8_PTR_PREFIX
@@ -570,13 +607,12 @@
"average_survival_ratio=%.1f%% "
"promotion_rate=%.1f%% "
"semi_space_copy_rate=%.1f%% "
- "new_space_allocation_throughput=%" V8_PTR_PREFIX
- "d "
+ "new_space_allocation_throughput=%.1f "
"context_disposal_rate=%.1f "
- "compaction_speed=%" V8_PTR_PREFIX "d\n",
+ "compaction_speed=%.f\n",
heap_->isolate()->time_millis_since_init(), duration,
spent_in_mutator, current_.TypeName(true), current_.reduce_memory,
- current_.scopes[Scope::EXTERNAL], current_.scopes[Scope::MC_CLEAR],
+ current_.scopes[Scope::MC_CLEAR],
current_.scopes[Scope::MC_CLEAR_CODE_FLUSH],
current_.scopes[Scope::MC_CLEAR_DEPENDENT_CODE],
current_.scopes[Scope::MC_CLEAR_GLOBAL_HANDLES],
@@ -590,17 +626,26 @@
current_.scopes[Scope::MC_EVACUATE],
current_.scopes[Scope::MC_EVACUATE_CANDIDATES],
current_.scopes[Scope::MC_EVACUATE_CLEAN_UP],
- current_.scopes[Scope::MC_EVACUATE_NEW_SPACE],
+ current_.scopes[Scope::MC_EVACUATE_COPY],
current_.scopes[Scope::MC_EVACUATE_UPDATE_POINTERS],
current_.scopes[Scope::MC_EVACUATE_UPDATE_POINTERS_BETWEEN_EVACUATED],
current_.scopes[Scope::MC_EVACUATE_UPDATE_POINTERS_TO_EVACUATED],
current_.scopes[Scope::MC_EVACUATE_UPDATE_POINTERS_TO_NEW],
current_.scopes[Scope::MC_EVACUATE_UPDATE_POINTERS_WEAK],
+ current_.scopes[Scope::MC_EXTERNAL_PROLOGUE],
+ current_.scopes[Scope::MC_EXTERNAL_EPILOGUE],
+ current_.scopes[Scope::MC_INCREMENTAL_EXTERNAL_PROLOGUE],
+ current_.scopes[Scope::MC_INCREMENTAL_EXTERNAL_EPILOGUE],
+ current_.scopes[Scope::EXTERNAL_WEAK_GLOBAL_HANDLES],
current_.scopes[Scope::MC_FINISH], current_.scopes[Scope::MC_MARK],
current_.scopes[Scope::MC_MARK_FINISH_INCREMENTAL],
current_.scopes[Scope::MC_MARK_PREPARE_CODE_FLUSH],
current_.scopes[Scope::MC_MARK_ROOTS],
current_.scopes[Scope::MC_MARK_WEAK_CLOSURE],
+ current_.scopes[Scope::MC_MARK_WEAK_CLOSURE_EPHEMERAL],
+ current_.scopes[Scope::MC_MARK_WEAK_CLOSURE_WEAK_HANDLES],
+ current_.scopes[Scope::MC_MARK_WEAK_CLOSURE_WEAK_ROOTS],
+ current_.scopes[Scope::MC_MARK_WEAK_CLOSURE_HARMONY],
current_.scopes[Scope::MC_SWEEP],
current_.scopes[Scope::MC_SWEEP_CODE],
current_.scopes[Scope::MC_SWEEP_MAP],
@@ -632,181 +677,72 @@
}
}
-
-double GCTracer::MeanDuration(const EventBuffer& events) const {
- if (events.empty()) return 0.0;
-
- double mean = 0.0;
- EventBuffer::const_iterator iter = events.begin();
- while (iter != events.end()) {
- mean += iter->end_time - iter->start_time;
- ++iter;
- }
-
- return mean / events.size();
+double GCTracer::AverageSpeed(const RingBuffer<BytesAndDuration>& buffer,
+ const BytesAndDuration& initial, double time_ms) {
+ BytesAndDuration sum = buffer.Sum(
+ [time_ms](BytesAndDuration a, BytesAndDuration b) {
+ if (time_ms != 0 && a.second >= time_ms) return a;
+ return std::make_pair(a.first + b.first, a.second + b.second);
+ },
+ initial);
+ uint64_t bytes = sum.first;
+ double durations = sum.second;
+ if (durations == 0.0) return 0;
+ double speed = bytes / durations;
+ const int max_speed = 1024 * MB;
+ const int min_speed = 1;
+ if (speed >= max_speed) return max_speed;
+ if (speed <= min_speed) return min_speed;
+ return speed;
}
-
-double GCTracer::MaxDuration(const EventBuffer& events) const {
- if (events.empty()) return 0.0;
-
- double maximum = 0.0f;
- EventBuffer::const_iterator iter = events.begin();
- while (iter != events.end()) {
- maximum = Max(iter->end_time - iter->start_time, maximum);
- ++iter;
- }
-
- return maximum;
+double GCTracer::AverageSpeed(const RingBuffer<BytesAndDuration>& buffer) {
+ return AverageSpeed(buffer, MakeBytesAndDuration(0, 0), 0);
}
-
-double GCTracer::MeanIncrementalMarkingDuration() const {
- if (cumulative_incremental_marking_steps_ == 0) return 0.0;
-
- // We haven't completed an entire round of incremental marking, yet.
- // Use data from GCTracer instead of data from event buffers.
- if (incremental_mark_compactor_events_.empty()) {
- return cumulative_incremental_marking_duration_ /
- cumulative_incremental_marking_steps_;
- }
-
- int steps = 0;
- double durations = 0.0;
- EventBuffer::const_iterator iter = incremental_mark_compactor_events_.begin();
- while (iter != incremental_mark_compactor_events_.end()) {
- steps += iter->incremental_marking_steps;
- durations += iter->incremental_marking_duration;
- ++iter;
- }
-
- if (steps == 0) return 0.0;
-
- return durations / steps;
-}
-
-
-double GCTracer::MaxIncrementalMarkingDuration() const {
- // We haven't completed an entire round of incremental marking, yet.
- // Use data from GCTracer instead of data from event buffers.
- if (incremental_mark_compactor_events_.empty())
- return longest_incremental_marking_step_;
-
- double max_duration = 0.0;
- EventBuffer::const_iterator iter = incremental_mark_compactor_events_.begin();
- while (iter != incremental_mark_compactor_events_.end())
- max_duration = Max(iter->longest_incremental_marking_step, max_duration);
-
- return max_duration;
-}
-
-
-intptr_t GCTracer::IncrementalMarkingSpeedInBytesPerMillisecond() const {
+double GCTracer::IncrementalMarkingSpeedInBytesPerMillisecond() const {
if (cumulative_incremental_marking_duration_ == 0.0) return 0;
-
// We haven't completed an entire round of incremental marking, yet.
// Use data from GCTracer instead of data from event buffers.
- if (incremental_mark_compactor_events_.empty()) {
- return static_cast<intptr_t>(cumulative_incremental_marking_bytes_ /
- cumulative_pure_incremental_marking_duration_);
+ if (recorded_incremental_marking_steps_.Count() == 0) {
+ return cumulative_incremental_marking_bytes_ /
+ cumulative_pure_incremental_marking_duration_;
}
-
- intptr_t bytes = 0;
- double durations = 0.0;
- EventBuffer::const_iterator iter = incremental_mark_compactor_events_.begin();
- while (iter != incremental_mark_compactor_events_.end()) {
- bytes += iter->incremental_marking_bytes;
- durations += iter->pure_incremental_marking_duration;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
+ return AverageSpeed(recorded_incremental_marking_steps_);
}
-
-intptr_t GCTracer::ScavengeSpeedInBytesPerMillisecond(
+double GCTracer::ScavengeSpeedInBytesPerMillisecond(
ScavengeSpeedMode mode) const {
- intptr_t bytes = 0;
- double durations = 0.0;
- EventBuffer::const_iterator iter = scavenger_events_.begin();
- while (iter != scavenger_events_.end()) {
- bytes += mode == kForAllObjects ? iter->new_space_object_size
- : iter->survived_new_space_object_size;
- durations += iter->end_time - iter->start_time;
- ++iter;
+ if (mode == kForAllObjects) {
+ return AverageSpeed(recorded_scavenges_total_);
+ } else {
+ return AverageSpeed(recorded_scavenges_survived_);
}
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
}
-
-intptr_t GCTracer::CompactionSpeedInBytesPerMillisecond() const {
- if (compaction_events_.size() == 0) return 0;
- intptr_t bytes = 0;
- double durations = 0.0;
- CompactionEventBuffer::const_iterator iter = compaction_events_.begin();
- while (iter != compaction_events_.end()) {
- bytes += iter->live_bytes_compacted;
- durations += iter->duration;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<intptr_t>(static_cast<intptr_t>(bytes / durations + 0.5), 1);
+double GCTracer::CompactionSpeedInBytesPerMillisecond() const {
+ return AverageSpeed(recorded_compactions_);
}
-
-intptr_t GCTracer::MarkCompactSpeedInBytesPerMillisecond() const {
- intptr_t bytes = 0;
- double durations = 0.0;
- EventBuffer::const_iterator iter = mark_compactor_events_.begin();
- while (iter != mark_compactor_events_.end()) {
- bytes += iter->start_object_size;
- durations += iter->end_time - iter->start_time;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
+double GCTracer::MarkCompactSpeedInBytesPerMillisecond() const {
+ return AverageSpeed(recorded_mark_compacts_);
}
-
-intptr_t GCTracer::FinalIncrementalMarkCompactSpeedInBytesPerMillisecond()
- const {
- intptr_t bytes = 0;
- double durations = 0.0;
- EventBuffer::const_iterator iter = incremental_mark_compactor_events_.begin();
- while (iter != incremental_mark_compactor_events_.end()) {
- bytes += iter->start_object_size;
- durations += iter->end_time - iter->start_time;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
+double GCTracer::FinalIncrementalMarkCompactSpeedInBytesPerMillisecond() const {
+ return AverageSpeed(recorded_incremental_mark_compacts_);
}
-
double GCTracer::CombinedMarkCompactSpeedInBytesPerMillisecond() {
if (combined_mark_compact_speed_cache_ > 0)
return combined_mark_compact_speed_cache_;
const double kMinimumMarkingSpeed = 0.5;
- double speed1 =
- static_cast<double>(IncrementalMarkingSpeedInBytesPerMillisecond());
- double speed2 = static_cast<double>(
- FinalIncrementalMarkCompactSpeedInBytesPerMillisecond());
+ double speed1 = IncrementalMarkingSpeedInBytesPerMillisecond();
+ double speed2 = FinalIncrementalMarkCompactSpeedInBytesPerMillisecond();
if (speed1 < kMinimumMarkingSpeed || speed2 < kMinimumMarkingSpeed) {
// No data for the incremental marking speed.
// Return the non-incremental mark-compact speed.
combined_mark_compact_speed_cache_ =
- static_cast<double>(MarkCompactSpeedInBytesPerMillisecond());
+ MarkCompactSpeedInBytesPerMillisecond();
} else {
// Combine the speed of incremental step and the speed of the final step.
// 1 / (1 / speed1 + 1 / speed2) = speed1 * speed2 / (speed1 + speed2).
@@ -815,101 +751,59 @@
return combined_mark_compact_speed_cache_;
}
-
-size_t GCTracer::NewSpaceAllocationThroughputInBytesPerMillisecond(
+double GCTracer::NewSpaceAllocationThroughputInBytesPerMillisecond(
double time_ms) const {
size_t bytes = new_space_allocation_in_bytes_since_gc_;
double durations = allocation_duration_since_gc_;
- AllocationEventBuffer::const_iterator iter =
- new_space_allocation_events_.begin();
- const size_t max_bytes = static_cast<size_t>(-1);
- while (iter != new_space_allocation_events_.end() &&
- bytes < max_bytes - bytes && (time_ms == 0 || durations < time_ms)) {
- bytes += iter->allocation_in_bytes_;
- durations += iter->duration_;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
+ return AverageSpeed(recorded_new_generation_allocations_,
+ MakeBytesAndDuration(bytes, durations), time_ms);
}
-
-size_t GCTracer::OldGenerationAllocationThroughputInBytesPerMillisecond(
+double GCTracer::OldGenerationAllocationThroughputInBytesPerMillisecond(
double time_ms) const {
size_t bytes = old_generation_allocation_in_bytes_since_gc_;
double durations = allocation_duration_since_gc_;
- AllocationEventBuffer::const_iterator iter =
- old_generation_allocation_events_.begin();
- const size_t max_bytes = static_cast<size_t>(-1);
- while (iter != old_generation_allocation_events_.end() &&
- bytes < max_bytes - bytes && (time_ms == 0 || durations < time_ms)) {
- bytes += iter->allocation_in_bytes_;
- durations += iter->duration_;
- ++iter;
- }
-
- if (durations == 0.0) return 0;
- // Make sure the result is at least 1.
- return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
+ return AverageSpeed(recorded_old_generation_allocations_,
+ MakeBytesAndDuration(bytes, durations), time_ms);
}
-
-size_t GCTracer::AllocationThroughputInBytesPerMillisecond(
+double GCTracer::AllocationThroughputInBytesPerMillisecond(
double time_ms) const {
return NewSpaceAllocationThroughputInBytesPerMillisecond(time_ms) +
OldGenerationAllocationThroughputInBytesPerMillisecond(time_ms);
}
-
-size_t GCTracer::CurrentAllocationThroughputInBytesPerMillisecond() const {
+double GCTracer::CurrentAllocationThroughputInBytesPerMillisecond() const {
return AllocationThroughputInBytesPerMillisecond(kThroughputTimeFrameMs);
}
-
-size_t GCTracer::CurrentOldGenerationAllocationThroughputInBytesPerMillisecond()
+double GCTracer::CurrentOldGenerationAllocationThroughputInBytesPerMillisecond()
const {
return OldGenerationAllocationThroughputInBytesPerMillisecond(
kThroughputTimeFrameMs);
}
-
double GCTracer::ContextDisposalRateInMilliseconds() const {
- if (context_disposal_events_.size() < kRingBufferMaxSize) return 0.0;
-
+ if (recorded_context_disposal_times_.Count() <
+ recorded_context_disposal_times_.kSize)
+ return 0.0;
double begin = heap_->MonotonicallyIncreasingTimeInMs();
- double end = 0.0;
- ContextDisposalEventBuffer::const_iterator iter =
- context_disposal_events_.begin();
- while (iter != context_disposal_events_.end()) {
- end = iter->time_;
- ++iter;
- }
-
- return (begin - end) / context_disposal_events_.size();
+ double end = recorded_context_disposal_times_.Sum(
+ [](double a, double b) { return b; }, 0.0);
+ return (begin - end) / recorded_context_disposal_times_.Count();
}
-
double GCTracer::AverageSurvivalRatio() const {
- if (survival_events_.size() == 0) return 0.0;
-
- double sum_of_rates = 0.0;
- SurvivalEventBuffer::const_iterator iter = survival_events_.begin();
- while (iter != survival_events_.end()) {
- sum_of_rates += iter->promotion_ratio_;
- ++iter;
- }
-
- return sum_of_rates / static_cast<double>(survival_events_.size());
+ if (recorded_survival_ratios_.Count() == 0) return 0.0;
+ double sum = recorded_survival_ratios_.Sum(
+ [](double a, double b) { return a + b; }, 0.0);
+ return sum / recorded_survival_ratios_.Count();
}
-
bool GCTracer::SurvivalEventsRecorded() const {
- return survival_events_.size() > 0;
+ return recorded_survival_ratios_.Count() > 0;
}
-
-void GCTracer::ResetSurvivalEvents() { survival_events_.reset(); }
+void GCTracer::ResetSurvivalEvents() { recorded_survival_ratios_.Reset(); }
} // namespace internal
} // namespace v8