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

src/mark-compact.cc

 // Copyright 2012 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
@@ skipping 988 matching lines @@
   JSFunction* next_candidate;
   while (candidate != NULL) {
     next_candidate = GetNextCandidate(candidate);
     ClearNextCandidate(candidate, undefined);
 
     SharedFunctionInfo* shared = candidate->shared();
 
     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);
     } else {
       candidate->set_code(code);
     }
 
     // We are in the middle of a GC cycle so the write barrier in the code
     // setter did not record the slot update and we have to do that manually.
     Address slot = candidate->address() + JSFunction::kCodeEntryOffset;
@@ skipping 23 matching lines @@
     ClearNextCandidate(candidate);
 
     Code* code = candidate->code();
     MarkBit code_mark = Marking::MarkBitFrom(code);
     if (!code_mark.Get()) {
       if (FLAG_trace_code_flushing && candidate->is_compiled()) {
         PrintF("[code-flushing clears: ");
         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);
     }
 
     Object** code_slot =
         HeapObject::RawField(candidate, SharedFunctionInfo::kCodeOffset);
     isolate_->heap()->mark_compact_collector()->
         RecordSlot(code_slot, code_slot, *code_slot);
 
     candidate = next_candidate;
   }
@@ skipping 3288 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal