Add histograms to track fraction of heap spaces and percentage of crankshaft code.

src/mark-compact.cc

Index: src/mark-compact.cc
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 65d838cdf95b895a8c86430f452f9b8e1715dcf2..963d95cd486d48efbaa784518bd0f96010e67218 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -1006,10 +1006,14 @@ void CodeFlusher::ProcessJSFunctionCandidates() {
     Code* code = shared->code();
     MarkBit code_mark = Marking::MarkBitFrom(code);
     if (!code_mark.Get()) {
-      if (FLAG_trace_code_flushing && shared->is_compiled()) {
-        PrintF("[code-flushing clears: ");
-        shared->ShortPrint();
-        PrintF(" - age: %d]\n", code->GetAge());
+      if (shared->is_compiled()) {
+        isolate_->heap()->DecrementCodeGeneratedBytes(

[Michael Starzinger, 2013/10/14 09:18:37]

IIUC, this tries to keep the new code-bytes counters in the heap accurate.
Unfortunately this is not possible as code can just become unreachable (e.g.
closure becomes unreachable, whole context becomes unreachable). In general
there is no place that visits "dead code" before it's memory is reclaimed. The
flushed code is just a subset of the code being reclaimed.

We should clarify what this new counter actually wants to represent. If we
really need a fully accurate number, one accurate way to track it would be to
reset it to zero before marking starts and then let the tracer count anew for
every GC cycle. But that is hard to get right, especially in light of
incremental marking, where the same object might be visited more than once.

I would split this part out in a separate CL, as it is not entirely trivial to
get this accounting right.

[rmcilroy, 2013/10/14 11:24:14]

Ahh right - I thought code would be added to this candidate list when
contexts/closures went out of scope, but what you say makes sense. I've updated
the CL to make this counter a measure of the fraction of crankshafted v.s.
non-crankshafted code that is generated overall (not the amount live in the
heap).  This should be accurate enough.

+            code->is_crankshafted(), code->instruction_size());
+        if (FLAG_trace_code_flushing) {
+          PrintF("[code-flushing clears: ");
+          shared->ShortPrint();
+          PrintF(" - age: %d]\n", code->GetAge());
+        }
       }
       shared->set_code(lazy_compile);
       candidate->set_code(lazy_compile);
@@ -1053,6 +1057,10 @@ void CodeFlusher::ProcessSharedFunctionInfoCandidates() {
         candidate->ShortPrint();
         PrintF(" - age: %d]\n", code->GetAge());
       }
+      if (candidate->is_compiled()) {
+        isolate_->heap()->DecrementCodeGeneratedBytes(
+            code->is_crankshafted(), code->instruction_size());
+      }
       candidate->set_code(lazy_compile);
     }