Revision: 22572
Author: machenb...@chromium.org
Date: Wed Jul 23 16:12:02 2014 UTC
Log: Revert "Track history of events in GCTracer."
This reverts commit 22567 for breaking win64 compile.
BUG=
TBR=ern...@chromium.org
Review URL: https://codereview.chromium.org/414743002
http://code.google.com/p/v8/source/detail?r=22572
Deleted:
/branches/bleeding_edge/test/cctest/test-gc-tracer.cc
Modified:
/branches/bleeding_edge/src/heap.cc
/branches/bleeding_edge/src/heap.h
/branches/bleeding_edge/src/incremental-marking.cc
/branches/bleeding_edge/src/incremental-marking.h
/branches/bleeding_edge/test/cctest/cctest.gyp
=======================================
--- /branches/bleeding_edge/test/cctest/test-gc-tracer.cc Wed Jul 23
15:16:53 2014 UTC
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <stdlib.h>
-#include <utility>
-
-#include "src/v8.h"
-
-#include "test/cctest/cctest.h"
-
-using namespace v8::internal;
-
-TEST(RingBufferPartialFill) {
- const size_t max_size = 6;
- typedef RingBuffer<size_t, max_size>::const_iterator Iter;
- RingBuffer<size_t, max_size> ring_buffer;
- CHECK(ring_buffer.empty());
- CHECK_EQ(ring_buffer.size(), 0);
- CHECK(ring_buffer.begin() == ring_buffer.end());
-
- // Fill ring_buffer partially: [0, 1, 2]
- for (size_t i = 0; i < max_size/2; i++)
- ring_buffer.push_back(i);
-
- CHECK(!ring_buffer.empty());
- CHECK(ring_buffer.size() == max_size/2);
- CHECK(ring_buffer.begin() != ring_buffer.end());
-
- // Test forward itartion
- size_t i = 0;
- for (Iter iter = ring_buffer.begin(); iter != ring_buffer.end(); ++iter)
{
- CHECK(*iter == i);
- ++i;
- }
- CHECK_EQ(i, 3); // one past last element.
-
- // Test backward iteration
- i = 2;
- Iter iter = ring_buffer.back();
- while (true) {
- CHECK(*iter == i);
- if (iter == ring_buffer.begin())
- break;
- --iter;
- --i;
- }
- CHECK_EQ(i, 0);
-}
-
-
-TEST(RingBufferWrapAround) {
- const size_t max_size = 6;
- typedef RingBuffer<size_t, max_size>::const_iterator Iter;
- RingBuffer<size_t, max_size> ring_buffer;
-
- // Fill ring_buffer (wrap around): [9, 10, 11, 12, 13, 14]
- for (size_t i = 0; i < 2 * max_size + 3; i++)
- ring_buffer.push_back(i);
-
- CHECK(!ring_buffer.empty());
- CHECK(ring_buffer.size() == max_size);
- CHECK(ring_buffer.begin() != ring_buffer.end());
-
- // Test forward iteration
- size_t i = 9;
- for (Iter iter = ring_buffer.begin(); iter != ring_buffer.end(); ++iter)
{
- CHECK(*iter == i);
- ++i;
- }
- CHECK_EQ(i, 15); // one past last element.
-
- // Test backward iteration
- i = 14;
- Iter iter = ring_buffer.back();
- while (true) {
- CHECK(*iter == i);
- if (iter == ring_buffer.begin())
- break;
- --iter;
- --i;
- }
- CHECK_EQ(i, 9);
-}
-
-
-TEST(RingBufferPushFront) {
- const size_t max_size = 6;
- typedef RingBuffer<size_t, max_size>::const_iterator Iter;
- RingBuffer<size_t, max_size> ring_buffer;
-
- // Fill ring_buffer (wrap around): [14, 13, 12, 11, 10, 9]
- for (size_t i = 0; i < 2 * max_size + 3; i++)
- ring_buffer.push_front(i);
-
- CHECK(!ring_buffer.empty());
- CHECK(ring_buffer.size() == max_size);
- CHECK(ring_buffer.begin() != ring_buffer.end());
-
- // Test forward iteration
- size_t i = 14;
- for (Iter iter = ring_buffer.begin(); iter != ring_buffer.end(); ++iter)
{
- CHECK(*iter == i);
- --i;
- }
- CHECK_EQ(i, 8); // one past last element.
-}
=======================================
--- /branches/bleeding_edge/src/heap.cc Wed Jul 23 15:16:53 2014 UTC
+++ /branches/bleeding_edge/src/heap.cc Wed Jul 23 16:12:02 2014 UTC
@@ -53,17 +53,18 @@
amount_of_external_allocated_memory_at_last_global_gc_(0),
isolate_(NULL),
code_range_size_(0),
-// semispace_size_ should be a power of 2 and old_generation_size_ should
be
-// a multiple of Page::kPageSize.
+ // semispace_size_ should be a power of 2 and old_generation_size_
should
+ // be
+ // a multiple of Page::kPageSize.
reserved_semispace_size_(8 * (kPointerSize / 4) * MB),
- max_semi_space_size_(8 * (kPointerSize / 4) * MB),
+ max_semi_space_size_(8 * (kPointerSize / 4) * MB),
initial_semispace_size_(Page::kPageSize),
max_old_generation_size_(700ul * (kPointerSize / 4) * MB),
max_executable_size_(256ul * (kPointerSize / 4) * MB),
-// Variables set based on semispace_size_ and old_generation_size_ in
-// ConfigureHeap.
-// Will be 4 * reserved_semispace_size_ to ensure that young
-// generation can be aligned to its size.
+ // Variables set based on semispace_size_ and old_generation_size_ in
+ // ConfigureHeap.
+ // Will be 4 * reserved_semispace_size_ to ensure that young
+ // generation can be aligned to its size.
maximum_committed_(0),
survived_since_last_expansion_(0),
sweep_generation_(0),
@@ -113,6 +114,8 @@
total_gc_time_ms_(0.0),
max_alive_after_gc_(0),
min_in_mutator_(kMaxInt),
+ alive_after_last_gc_(0),
+ last_gc_end_timestamp_(base::OS::TimeCurrentMillis()),
marking_time_(0.0),
sweeping_time_(0.0),
mark_compact_collector_(this),
@@ -838,7 +841,8 @@
bool next_gc_likely_to_collect_more = false;
- { tracer()->Start(collector, gc_reason, collector_reason);
+ {
+ tracer()->start(collector, gc_reason, collector_reason);
ASSERT(AllowHeapAllocation::IsAllowed());
DisallowHeapAllocation no_allocation_during_gc;
GarbageCollectionPrologue();
@@ -852,7 +856,7 @@
}
GarbageCollectionEpilogue();
- tracer()->Stop();
+ tracer()->stop();
}
// Start incremental marking for the next cycle. The heap snapshot
@@ -5965,13 +5969,16 @@
}
-void Heap::UpdateCumulativeGCStatistics(double duration,
- double spent_in_mutator,
- double marking_time) {
+void Heap::UpdateGCStatistics(double start_time, double end_time,
+ double spent_in_mutator, double
marking_time) {
+ double duration = end_time - start_time;
+ alive_after_last_gc_ = SizeOfObjects();
+ last_gc_end_timestamp_ = end_time;
+
if (FLAG_print_cumulative_gc_stat) {
total_gc_time_ms_ += duration;
max_gc_pause_ = Max(max_gc_pause_, duration);
- max_alive_after_gc_ = Max(max_alive_after_gc_, SizeOfObjects());
+ max_alive_after_gc_ = Max(max_alive_after_gc_, alive_after_last_gc_);
min_in_mutator_ = Min(min_in_mutator_, spent_in_mutator);
} else if (FLAG_trace_gc_verbose) {
total_gc_time_ms_ += duration;
@@ -5981,121 +5988,74 @@
}
-GCTracer::Event::Event(Type type,
- const char* gc_reason,
- const char* collector_reason)
- : type(type),
- gc_reason(gc_reason),
- collector_reason(collector_reason),
- start_time(0.0),
- end_time(0.0),
- start_object_size(0),
- end_object_size(0),
- start_memory_size(0),
- end_memory_size(0),
- start_holes_size(0),
- end_holes_size(0),
- incremental_marking_steps(0),
- incremental_marking_duration(0.0) {
+GCTracer::GCTracer(Heap* heap)
+ : start_time_(0.0),
+ end_time_(0.0),
+ start_object_size_(0),
+ end_object_size_(0),
+ start_memory_size_(0),
+ end_memory_size_(0),
+ in_free_list_or_wasted_before_gc_(0),
+ allocated_since_last_gc_(0),
+ spent_in_mutator_(0),
+ steps_count_(0),
+ steps_took_(0.0),
+ longest_step_(0.0),
+ steps_count_since_last_gc_(0),
+ steps_took_since_last_gc_(0.0),
+ heap_(heap),
+ gc_reason_(NULL),
+ collector_reason_(NULL) {
for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
- scopes[i] = 0;
+ scopes_[i] = 0;
}
}
-const char* GCTracer::Event::TypeName(bool short_name) const {
- switch (type) {
- case SCAVENGER:
- if (short_name) {
- return "s";
- } else {
- return "Scavenge";
- }
- case MARK_COMPACTOR:
- if (short_name) {
- return "ms";
- } else {
- return "Mark-sweep";
- }
- case START:
- if (short_name) {
- return "st";
- } else {
- return "Start";
- }
- }
- return "Unknown Event Type";
-}
-
-
-GCTracer::GCTracer(Heap* heap)
- : heap_(heap),
- incremental_marking_steps_(0),
- incremental_marking_duration_(0.0),
- longest_incremental_marking_step_(0.0) {
- current_ = Event(Event::START, NULL, NULL);
- current_.end_time = base::OS::TimeCurrentMillis();
- previous_ = previous_mark_compactor_event_ = current_;
-}
-
-
-void GCTracer::Start(GarbageCollector collector,
- const char* gc_reason,
+void GCTracer::start(GarbageCollector collector, const char* gc_reason,
const char* collector_reason) {
if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
- previous_ = current_;
- if (current_.type == Event::MARK_COMPACTOR)
- previous_mark_compactor_event_ = current_;
+ collector_ = collector;
+ gc_reason_ = gc_reason;
+ collector_reason_ = collector_reason;
- if (collector == SCAVENGER) {
- current_ = Event(Event::SCAVENGER, gc_reason, collector_reason);
- } else {
- current_ = Event(Event::MARK_COMPACTOR, gc_reason, collector_reason);
+ start_time_ = base::OS::TimeCurrentMillis();
+ start_object_size_ = heap_->SizeOfObjects();
+ start_memory_size_ = heap_->isolate()->memory_allocator()->Size();
+
+ for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
+ scopes_[i] = 0;
}
- current_.start_time = base::OS::TimeCurrentMillis();
- current_.start_object_size = heap_->SizeOfObjects();
- current_.start_memory_size =
heap_->isolate()->memory_allocator()->Size();
- current_.start_holes_size = CountTotalHolesSize(heap_);
+ in_free_list_or_wasted_before_gc_ = CountTotalHolesSize(heap_);
+
+ allocated_since_last_gc_ =
+ heap_->SizeOfObjects() - heap_->alive_after_last_gc_;
- current_.incremental_marking_steps = incremental_marking_steps_;
- current_.incremental_marking_duration = incremental_marking_duration_;
- current_.longest_incremental_marking_step =
longest_incremental_marking_step_;
+ spent_in_mutator_ = Max(start_time_ - heap_->last_gc_end_timestamp_,
0.0);
- for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
- current_.scopes[i] = 0;
- }
+ steps_count_ = heap_->incremental_marking()->steps_count();
+ steps_took_ = heap_->incremental_marking()->steps_took();
+ longest_step_ = heap_->incremental_marking()->longest_step();
+ steps_count_since_last_gc_ =
+ heap_->incremental_marking()->steps_count_since_last_gc();
+ steps_took_since_last_gc_ =
+ heap_->incremental_marking()->steps_took_since_last_gc();
}
-void GCTracer::Stop() {
+void GCTracer::stop() {
if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
- current_.end_time = base::OS::TimeCurrentMillis();
- current_.end_object_size = heap_->SizeOfObjects();
- current_.end_memory_size = heap_->isolate()->memory_allocator()->Size();
- current_.end_holes_size = CountTotalHolesSize(heap_);
+ end_time_ = base::OS::TimeCurrentMillis();
+ end_object_size_ = heap_->SizeOfObjects();
+ end_memory_size_ = heap_->isolate()->memory_allocator()->Size();
- if (current_.type == Event::SCAVENGER) {
- scavenger_events_.push_front(current_);
- } else {
- mark_compactor_events_.push_front(current_);
- }
+ heap_->UpdateGCStatistics(start_time_, end_time_, spent_in_mutator_,
+ scopes_[Scope::MC_MARK]);
- if (current_.type == Event::MARK_COMPACTOR)
- longest_incremental_marking_step_ = 0.0;
-
- 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,
- current_.scopes[Scope::MC_MARK]);
-
- if (current_.type == Event::SCAVENGER && FLAG_trace_gc_ignore_scavenger)
- return;
+ if (collector_ == SCAVENGER && FLAG_trace_gc_ignore_scavenger) return;
if (FLAG_trace_gc) {
if (FLAG_trace_gc_nvp)
@@ -6106,59 +6066,39 @@
heap_->PrintShortHeapStatistics();
}
}
-
-
-void GCTracer::AddIncrementalMarkingStep(double duration) {
- incremental_marking_steps_++;
- incremental_marking_duration_ += duration;
- longest_incremental_marking_step_ =
- Max(longest_incremental_marking_step_, duration);
-}
void GCTracer::Print() const {
PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
- PrintF("%s %.1f (%.1f) -> %.1f (%.1f) MB, ",
- current_.TypeName(false),
- static_cast<double>(current_.start_object_size) / MB,
- static_cast<double>(current_.start_memory_size) / MB,
- static_cast<double>(current_.end_object_size) / MB,
- static_cast<double>(current_.end_memory_size) / MB);
+ PrintF("%s %.1f (%.1f) -> %.1f (%.1f) MB, ", CollectorString(),
+ static_cast<double>(start_object_size_) / MB,
+ static_cast<double>(start_memory_size_) / MB,
+ static_cast<double>(end_object_size_) / MB,
+ static_cast<double>(end_memory_size_) / MB);
- int external_time = static_cast<int>(current_.scopes[Scope::EXTERNAL]);
+ int external_time = static_cast<int>(scopes_[Scope::EXTERNAL]);
if (external_time > 0) PrintF("%d / ", external_time);
- double duration = current_.end_time - current_.start_time;
- PrintF("%.1f ms", duration);
- if (current_.type == Event::SCAVENGER) {
- int steps = current_.incremental_marking_steps -
- previous_.incremental_marking_steps;
- if (steps > 0) {
+ PrintF("%.1f ms", end_time_ - start_time_);
+ if (steps_count_ > 0) {
+ if (collector_ == SCAVENGER) {
PrintF(" (+ %.1f ms in %d steps since last GC)",
- current_.incremental_marking_duration -
- previous_.incremental_marking_duration,
- steps);
- }
- } else {
- int steps = current_.incremental_marking_steps -
- previous_mark_compactor_event_.incremental_marking_steps;
- if (steps > 0) {
- PrintF(" (+ %.1f ms in %d steps since start of marking, "
- "biggest step %.1f ms)",
- current_.incremental_marking_duration -
- previous_mark_compactor_event_.incremental_marking_duration,
- steps,
- current_.longest_incremental_marking_step);
+ steps_took_since_last_gc_, steps_count_since_last_gc_);
+ } else {
+ PrintF(
+ " (+ %.1f ms in %d steps since start of marking, "
+ "biggest step %.1f ms)",
+ steps_took_, steps_count_, longest_step_);
}
}
- if (current_.gc_reason != NULL) {
- PrintF(" [%s]", current_.gc_reason);
+ if (gc_reason_ != NULL) {
+ PrintF(" [%s]", gc_reason_);
}
- if (current_.collector_reason != NULL) {
- PrintF(" [%s]", current_.collector_reason);
+ if (collector_reason_ != NULL) {
+ PrintF(" [%s]", collector_reason_);
}
PrintF(".\n");
@@ -6168,47 +6108,49 @@
void GCTracer::PrintNVP() const {
PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
- double duration = current_.end_time - current_.start_time;
- double spent_in_mutator = current_.start_time - previous_.end_time;
-
- PrintF("pause=%.1f ", duration);
- PrintF("mutator=%.1f ", spent_in_mutator);
- PrintF("gc=%s ", current_.TypeName(true));
+ PrintF("pause=%.1f ", end_time_ - start_time_);
+ PrintF("mutator=%.1f ", spent_in_mutator_);
+ PrintF("gc=");
+ switch (collector_) {
+ case SCAVENGER:
+ PrintF("s");
+ break;
+ case MARK_COMPACTOR:
+ PrintF("ms");
+ break;
+ default:
+ UNREACHABLE();
+ }
+ PrintF(" ");
- PrintF("external=%.1f ", current_.scopes[Scope::EXTERNAL]);
- PrintF("mark=%.1f ", current_.scopes[Scope::MC_MARK]);
- PrintF("sweep=%.2f ", current_.scopes[Scope::MC_SWEEP]);
- PrintF("sweepns=%.2f ", current_.scopes[Scope::MC_SWEEP_NEWSPACE]);
- PrintF("sweepos=%.2f ", current_.scopes[Scope::MC_SWEEP_OLDSPACE]);
- PrintF("sweepcode=%.2f ", current_.scopes[Scope::MC_SWEEP_CODE]);
- PrintF("sweepcell=%.2f ", current_.scopes[Scope::MC_SWEEP_CELL]);
- PrintF("sweepmap=%.2f ", current_.scopes[Scope::MC_SWEEP_MAP]);
- PrintF("evacuate=%.1f ", current_.scopes[Scope::MC_EVACUATE_PAGES]);
- PrintF("new_new=%.1f ",
- current_.scopes[Scope::MC_UPDATE_NEW_TO_NEW_POINTERS]);
- PrintF("root_new=%.1f ",
- current_.scopes[Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS]);
- PrintF("old_new=%.1f ",
- current_.scopes[Scope::MC_UPDATE_OLD_TO_NEW_POINTERS]);
+ PrintF("external=%.1f ", scopes_[Scope::EXTERNAL]);
+ PrintF("mark=%.1f ", scopes_[Scope::MC_MARK]);
+ PrintF("sweep=%.2f ", scopes_[Scope::MC_SWEEP]);
+ PrintF("sweepns=%.2f ", scopes_[Scope::MC_SWEEP_NEWSPACE]);
+ PrintF("sweepos=%.2f ", scopes_[Scope::MC_SWEEP_OLDSPACE]);
+ PrintF("sweepcode=%.2f ", scopes_[Scope::MC_SWEEP_CODE]);
+ PrintF("sweepcell=%.2f ", scopes_[Scope::MC_SWEEP_CELL]);
+ PrintF("sweepmap=%.2f ", scopes_[Scope::MC_SWEEP_MAP]);
+ PrintF("evacuate=%.1f ", scopes_[Scope::MC_EVACUATE_PAGES]);
+ PrintF("new_new=%.1f ", scopes_[Scope::MC_UPDATE_NEW_TO_NEW_POINTERS]);
+ PrintF("root_new=%.1f ", scopes_[Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS]);
+ PrintF("old_new=%.1f ", scopes_[Scope::MC_UPDATE_OLD_TO_NEW_POINTERS]);
PrintF("compaction_ptrs=%.1f ",
- current_.scopes[Scope::MC_UPDATE_POINTERS_TO_EVACUATED]);
+ scopes_[Scope::MC_UPDATE_POINTERS_TO_EVACUATED]);
PrintF("intracompaction_ptrs=%.1f ",
- current_.scopes[Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED]);
- PrintF("misc_compaction=%.1f ",
- current_.scopes[Scope::MC_UPDATE_MISC_POINTERS]);
+ scopes_[Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED]);
+ PrintF("misc_compaction=%.1f ", scopes_[Scope::MC_UPDATE_MISC_POINTERS]);
PrintF("weakcollection_process=%.1f ",
- current_.scopes[Scope::MC_WEAKCOLLECTION_PROCESS]);
- PrintF("weakcollection_clear=%.1f ",
- current_.scopes[Scope::MC_WEAKCOLLECTION_CLEAR]);
+ scopes_[Scope::MC_WEAKCOLLECTION_PROCESS]);
+ PrintF("weakcollection_clear=%.1f ",
scopes_[Scope::MC_WEAKCOLLECTION_CLEAR]);
- PrintF("total_size_before=%" V8_PTR_PREFIX "d ",
current_.start_object_size);
- PrintF("total_size_after=%" V8_PTR_PREFIX "d ",
current_.end_object_size);
- PrintF("holes_size_before=%" V8_PTR_PREFIX "d ",
current_.start_holes_size);
- PrintF("holes_size_after=%" V8_PTR_PREFIX "d ", current_.end_holes_size);
+ PrintF("total_size_before=%" V8_PTR_PREFIX "d ", start_object_size_);
+ PrintF("total_size_after=%" V8_PTR_PREFIX "d ", end_object_size_);
+ PrintF("holes_size_before=%" V8_PTR_PREFIX "d ",
+ in_free_list_or_wasted_before_gc_);
+ PrintF("holes_size_after=%" V8_PTR_PREFIX "d ",
CountTotalHolesSize(heap_));
- intptr_t allocated_since_last_gc =
- current_.start_object_size - previous_.end_object_size;
- PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc);
+ PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc_);
PrintF("promoted=%" V8_PTR_PREFIX "d ", heap_->promoted_objects_size_);
PrintF("semi_space_copied=%" V8_PTR_PREFIX "d ",
heap_->semi_space_copied_object_size_);
@@ -6218,21 +6160,28 @@
PrintF("promotion_rate=%.1f%% ", heap_->promotion_rate_);
PrintF("semi_space_copy_rate=%.1f%% ", heap_->semi_space_copied_rate_);
- if (current_.type == Event::SCAVENGER) {
- PrintF("stepscount=%d ", current_.incremental_marking_steps -
- previous_.incremental_marking_steps);
- PrintF("stepstook=%.1f ", current_.incremental_marking_duration -
- previous_.incremental_marking_duration);
+ if (collector_ == SCAVENGER) {
+ PrintF("stepscount=%d ", steps_count_since_last_gc_);
+ PrintF("stepstook=%.1f ", steps_took_since_last_gc_);
} else {
- PrintF("stepscount=%d ", current_.incremental_marking_steps -
- previous_mark_compactor_event_.incremental_marking_steps);
- PrintF("stepstook=%.1f ", current_.incremental_marking_duration -
- previous_mark_compactor_event_.incremental_marking_duration);
- PrintF("longeststep=%.1f ", current_.longest_incremental_marking_step);
+ PrintF("stepscount=%d ", steps_count_);
+ PrintF("stepstook=%.1f ", steps_took_);
+ PrintF("longeststep=%.1f ", longest_step_);
}
PrintF("\n");
}
+
+
+const char* GCTracer::CollectorString() const {
+ switch (collector_) {
+ case SCAVENGER:
+ return "Scavenge";
+ case MARK_COMPACTOR:
+ return "Mark-sweep";
+ }
+ return "Unknown GC";
+}
int KeyedLookupCache::Hash(Handle<Map> map, Handle<Name> name) {
=======================================
--- /branches/bleeding_edge/src/heap.h Wed Jul 23 15:16:53 2014 UTC
+++ /branches/bleeding_edge/src/heap.h Wed Jul 23 16:12:02 2014 UTC
@@ -547,91 +547,10 @@
INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE
};
-// TODO(ernstm): Move into GCTracer.
-// A simple ring buffer class with maximum size known at compile time.
-// The class only implements the functionality required in GCTracer.
-template<typename T, size_t MAX_SIZE>
-class RingBuffer {
- public:
- class const_iterator {
- public:
- const_iterator() : index_(0), elements_(NULL) {}
-
- const_iterator(size_t index, const T* elements) :
- index_(index), elements_(elements) {}
-
- bool operator==(const const_iterator& rhs) const {
- return elements_ == rhs.elements_ &&
- index_ == rhs.index_;
- }
-
- bool operator!=(const const_iterator& rhs) const {
- return elements_ != rhs.elements_ ||
- index_ != rhs.index_;
- }
-
- operator const T*() const {
- return elements_ + index_;
- }
-
- const T* operator->() const {
- return elements_ + index_;
- }
-
- const T& operator*() const {
- return elements_[index_];
- }
-
- const_iterator& operator++() {
- index_ = (index_ + 1) % (MAX_SIZE + 1);
- return *this;
- }
-
- const_iterator& operator--() {
- index_ = (index_ + MAX_SIZE) % (MAX_SIZE + 1);
- return *this;
- }
-
- private:
- size_t index_;
- const T* elements_;
- };
-
- RingBuffer() : begin_(0), end_(0) {}
-
- bool empty() const { return begin_ == end_; }
- size_t size() const {
- return (end_ - begin_ + MAX_SIZE + 1) % (MAX_SIZE + 1);
- }
- const_iterator begin() const { return const_iterator(begin_, elements_);
}
- const_iterator end() const { return const_iterator(end_, elements_); }
- const_iterator back() const { return --end(); }
- void push_back(const T& element) {
- elements_[end_] = element;
- end_ = (end_ + 1) % (MAX_SIZE + 1);
- if (end_ == begin_)
- begin_ = (begin_ + 1) % (MAX_SIZE + 1);
- }
- void push_front(const T& element) {
- begin_ = (begin_ + MAX_SIZE) % (MAX_SIZE + 1);
- if (begin_ == end_)
- end_ = (end_ + MAX_SIZE) % (MAX_SIZE + 1);
- elements_[begin_] = element;
- }
-
- private:
- T elements_[MAX_SIZE + 1];
- size_t begin_;
- size_t end_;
-
- DISALLOW_COPY_AND_ASSIGN(RingBuffer);
-};
-
// GCTracer collects and prints ONE line after each garbage collector
// invocation IFF --trace_gc is used.
-// TODO(ernstm): Unit tests. Move to separate file.
class GCTracer BASE_EMBEDDED {
public:
class Scope BASE_EMBEDDED {
@@ -666,8 +585,7 @@
~Scope() {
ASSERT(scope_ < NUMBER_OF_SCOPES); // scope_ is unsigned.
- tracer_->current_.scopes[scope_] +=
- base::OS::TimeCurrentMillis() - start_time_;
+ tracer_->scopes_[scope_] += base::OS::TimeCurrentMillis() -
start_time_;
}
private:
@@ -678,126 +596,72 @@
DISALLOW_COPY_AND_ASSIGN(Scope);
};
-
- class Event {
- public:
- enum Type {
- SCAVENGER = 0,
- MARK_COMPACTOR = 1,
- START = 2
- };
-
- // Default constructor leaves the event uninitialized.
- Event() {}
-
- Event(Type type,
- const char* gc_reason,
- const char* collector_reason);
-
- // Returns a string describing the event type.
- const char* TypeName(bool short_name) const;
-
- // Type of event
- Type type;
-
- const char* gc_reason;
- const char* collector_reason;
-
- // Timestamp set in the constructor.
- double start_time;
-
- // Timestamp set in the destructor.
- double end_time;
-
- // Size of objects in heap set in constructor.
- intptr_t start_object_size;
-
- // Size of objects in heap set in destructor.
- intptr_t end_object_size;
-
- // Size of memory allocated from OS set in constructor.
- intptr_t start_memory_size;
-
- // Size of memory allocated from OS set in destructor.
- intptr_t end_memory_size;
-
- // Total amount of space either wasted or contained in one of free
lists
- // before the current GC.
- intptr_t start_holes_size;
-
- // Total amount of space either wasted or contained in one of free
lists
- // after the current GC.
- intptr_t end_holes_size;
-
- // Number of incremental marking steps since creation of tracer.
- // (value at start of event)
- int incremental_marking_steps;
-
- // Cumulative duration of incremental marking steps since creation of
- // tracer. (value at start of event)
- double incremental_marking_duration;
-
- // Longest incremental marking step since start of marking.
- // (value at start of event)
- double longest_incremental_marking_step;
-
- // Amounts of time spent in different scopes during GC.
- double scopes[Scope::NUMBER_OF_SCOPES];
- };
-
- static const int kRingBufferMaxSize = 10;
-
- typedef RingBuffer<Event, kRingBufferMaxSize> EventBuffer;
-
explicit GCTracer(Heap* heap);
// Start collecting data.
- void Start(GarbageCollector collector,
- const char* gc_reason,
+ void start(GarbageCollector collector, const char* gc_reason,
const char* collector_reason);
// Stop collecting data and print results.
- void Stop();
-
- // Log an incremental marking step.
- void AddIncrementalMarkingStep(double duration);
+ void stop();
private:
+ // Returns a string matching the collector.
+ const char* CollectorString() const;
+
// Print one detailed trace line in name=value format.
- // TODO(ernstm): Move to Heap.
void PrintNVP() const;
// Print one trace line.
- // TODO(ernstm): Move to Heap.
void Print() const;
- // Pointer to the heap that owns this tracer.
- Heap* heap_;
+ // Timestamp set in the constructor.
+ double start_time_;
- // Current tracer event. Populated during Start/Stop cycle. Valid after
Stop()
- // has returned.
- Event current_;
+ // Timestamp set in the destructor.
+ double end_time_;
- // Previous tracer event.
- Event previous_;
+ // Size of objects in heap set in constructor.
+ intptr_t start_object_size_;
- // Previous MARK_COMPACTOR event.
- Event previous_mark_compactor_event_;
+ // Size of objects in heap set in destructor.
+ intptr_t end_object_size_;
- // RingBuffers for SCAVENGER events.
- EventBuffer scavenger_events_;
+ // Size of memory allocated from OS set in constructor.
+ intptr_t start_memory_size_;
- // RingBuffers for MARK_COMPACTOR events.
- EventBuffer mark_compactor_events_;
+ // Size of memory allocated from OS set in destructor.
+ intptr_t end_memory_size_;
+
+ // Type of collector.
+ GarbageCollector collector_;
+
+ // Amounts of time spent in different scopes during GC.
+ double scopes_[Scope::NUMBER_OF_SCOPES];
+
+ // Total amount of space either wasted or contained in one of free lists
+ // before the current GC.
+ intptr_t in_free_list_or_wasted_before_gc_;
+
+ // Difference between space used in the heap at the beginning of the
current
+ // collection and the end of the previous collection.
+ intptr_t allocated_since_last_gc_;
+
+ // Amount of time spent in mutator that is time elapsed between end of
the
+ // previous collection and the beginning of the current one.
+ double spent_in_mutator_;
- // Cumulative number of incremental marking steps since creation of
tracer.
- int incremental_marking_steps_;
+ // Incremental marking steps counters.
+ int steps_count_;
+ double steps_took_;
+ double longest_step_;
+ int steps_count_since_last_gc_;
+ double steps_took_since_last_gc_;
- // Cumulative duration of incremental marking steps since creation of
tracer.
- double incremental_marking_duration_;
+ Heap* heap_;
- // Longest incremental marking step since start of marking.
- double longest_incremental_marking_step_;
+ const char* gc_reason_;
+ const char* collector_reason_;
DISALLOW_COPY_AND_ASSIGN(GCTracer);
};
@@ -1503,9 +1367,8 @@
}
// Update GC statistics that are tracked on the Heap.
- void UpdateCumulativeGCStatistics(double duration,
- double spent_in_mutator,
- double marking_time);
+ void UpdateGCStatistics(double start_time, double end_time,
+ double spent_in_mutator, double marking_time);
// Returns maximum GC pause.
double get_max_gc_pause() { return max_gc_pause_; }
@@ -2375,6 +2238,11 @@
// Minimal interval between two subsequent collections.
double min_in_mutator_;
+ // Size of objects alive after last GC.
+ intptr_t alive_after_last_gc_;
+
+ double last_gc_end_timestamp_;
+
// Cumulative GC time spent in marking
double marking_time_;
=======================================
--- /branches/bleeding_edge/src/incremental-marking.cc Wed Jul 23 15:16:53
2014 UTC
+++ /branches/bleeding_edge/src/incremental-marking.cc Wed Jul 23 16:12:02
2014 UTC
@@ -22,14 +22,17 @@
marking_deque_memory_(NULL),
marking_deque_memory_committed_(false),
steps_count_(0),
+ steps_took_(0),
+ longest_step_(0.0),
old_generation_space_available_at_start_of_incremental_(0),
old_generation_space_used_at_start_of_incremental_(0),
+ steps_count_since_last_gc_(0),
+ steps_took_since_last_gc_(0),
should_hurry_(false),
marking_speed_(0),
allocated_(0),
no_marking_scope_depth_(0),
- unscanned_bytes_of_large_object_(0) {
-}
+ unscanned_bytes_of_large_object_(0) {}
void IncrementalMarking::TearDown() {
@@ -655,6 +658,9 @@
}
}
marking_deque_.set_top(new_top);
+
+ steps_took_since_last_gc_ = 0;
+ steps_count_since_last_gc_ = 0;
}
@@ -889,6 +895,7 @@
}
steps_count_++;
+ steps_count_since_last_gc_++;
bool speed_up = false;
@@ -957,7 +964,9 @@
FLAG_print_cumulative_gc_stat) {
double end = base::OS::TimeCurrentMillis();
double delta = (end - start);
- heap_->tracer()->AddIncrementalMarkingStep(delta);
+ longest_step_ = Max(longest_step_, delta);
+ steps_took_ += delta;
+ steps_took_since_last_gc_ += delta;
heap_->AddMarkingTime(delta);
}
}
@@ -965,10 +974,14 @@
void IncrementalMarking::ResetStepCounters() {
steps_count_ = 0;
+ steps_took_ = 0;
+ longest_step_ = 0.0;
old_generation_space_available_at_start_of_incremental_ =
SpaceLeftInOldSpace();
old_generation_space_used_at_start_of_incremental_ =
heap_->PromotedTotalSize();
+ steps_count_since_last_gc_ = 0;
+ steps_took_since_last_gc_ = 0;
bytes_rescanned_ = 0;
marking_speed_ = kInitialMarkingSpeed;
bytes_scanned_ = 0;
=======================================
--- /branches/bleeding_edge/src/incremental-marking.h Wed Jul 23 15:16:53
2014 UTC
+++ /branches/bleeding_edge/src/incremental-marking.h Wed Jul 23 16:12:02
2014 UTC
@@ -135,6 +135,16 @@
inline void BlackToGreyAndUnshift(HeapObject* obj, MarkBit mark_bit);
inline void WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit);
+
+ inline int steps_count() { return steps_count_; }
+
+ inline double steps_took() { return steps_took_; }
+
+ inline double longest_step() { return longest_step_; }
+
+ inline int steps_count_since_last_gc() { return
steps_count_since_last_gc_; }
+
+ inline double steps_took_since_last_gc() { return
steps_took_since_last_gc_; }
inline void SetOldSpacePageFlags(MemoryChunk* chunk) {
SetOldSpacePageFlags(chunk, IsMarking(), IsCompacting());
@@ -216,8 +226,12 @@
MarkingDeque marking_deque_;
int steps_count_;
+ double steps_took_;
+ double longest_step_;
int64_t old_generation_space_available_at_start_of_incremental_;
int64_t old_generation_space_used_at_start_of_incremental_;
+ int steps_count_since_last_gc_;
+ double steps_took_since_last_gc_;
int64_t bytes_rescanned_;
bool should_hurry_;
int marking_speed_;
=======================================
--- /branches/bleeding_edge/test/cctest/cctest.gyp Wed Jul 23 15:16:53 2014
UTC
+++ /branches/bleeding_edge/test/cctest/cctest.gyp Wed Jul 23 16:12:02 2014
UTC
@@ -78,7 +78,6 @@
'test-fixed-dtoa.cc',
'test-flags.cc',
'test-func-name-inference.cc',
- 'test-gc-tracer.cc',
'test-global-handles.cc',
'test-global-object.cc',
'test-hashing.cc',
--
--
v8-dev mailing list
v8-dev@googlegroups.com
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to v8-dev+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
