code review 7413049: runtime: add garbage collector statistics

src/pkg/runtime/mgc0.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Garbage collector.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "stack.h"
@@ skipping 153 matching lines @@
 
 enum {
         GC_DEFAULT_PTR = GC_NUM_INSTR,
         GC_MAP_NEXT,
         GC_CHAN,
 
         GC_NUM_INSTR2
 };
 
 static struct {
-        uint64 ptr_sum;
-        uint64 ptr_cnt;
+        struct {
+                uint64 sum;
+                uint64 cnt;
+        } ptr;
         uint64 nbytes;
-        uint64 nobj_sum;
-        uint64 nobj_cnt;
-        uint64 nobj_notype;
-        uint64 nobj_typelookups_ok;
-        uint64 rescans;
-        uint64 rescan_nbytes;
+        struct {
+                uint64 sum;
+                uint64 cnt;
+                uint64 notype;
+                uint64 typelookup;
+        } obj;
+        uint64 rescan;
+        uint64 rescanbytes;
         uint64 instr[GC_NUM_INSTR2];
         uint64 putempty;
         uint64 getfull;
 } gcstats;
 
 // markonly marks an object. It returns true if the object
 // has been marked by this function, false otherwise.
 // This function isn't thread-safe and doesn't append the object to any buffer.
 static bool
 markonly(void *obj)
@@ skipping 134 matching lines @@
 
         wp = *_wp;
         wbuf = *_wbuf;
         nobj = *_nobj;
 
         ptrbuf_end = *ptrbufpos;
         n = ptrbuf_end - ptrbuf;
         *ptrbufpos = ptrbuf;
 
         if(CollectStats) {
-                runtime·xadd64(&gcstats.ptr_sum, n);
-                runtime·xadd64(&gcstats.ptr_cnt, 1);
+                runtime·xadd64(&gcstats.ptr.sum, n);
+                runtime·xadd64(&gcstats.ptr.cnt, 1);
         }
 
         // If buffer is nearly full, get a new one.
         if(wbuf == nil || nobj+n >= nelem(wbuf->obj)) {
                 if(wbuf != nil)
                         wbuf->nobj = nobj;
                 wbuf = getempty(wbuf);
                 wp = wbuf->obj;
                 nobj = 0;
 
@@ skipping 290 matching lines @@
 
         for(;;) {
                 // Each iteration scans the block b of length n, queueing pointers in
                 // the work buffer.
                 if(Debug > 1) {
                         runtime·printf("scanblock %p %D\n", b, (int64)n);
                 }
 
                 if(CollectStats) {
                         runtime·xadd64(&gcstats.nbytes, n);
-                        runtime·xadd64(&gcstats.nobj_sum, nobj);
-                        runtime·xadd64(&gcstats.nobj_cnt, 1);
+                        runtime·xadd64(&gcstats.obj.sum, nobj);
+                        runtime·xadd64(&gcstats.obj.cnt, 1);
                 }
 
                 if(ti != 0) {
                         pc = (uintptr*)(ti & ~(uintptr)PC_BITS);
                         precise_type = (ti & PRECISE);
                         stack_top.elemsize = pc[0];
                         if(!precise_type)
                                 nominal_size = pc[0];
                         if(ti & LOOP) {
                                 stack_top.count = 0;    // 0 means an infinite number of iterations
                                 stack_top.loop_or_ret = pc+1;
                         } else {
                                 stack_top.count = 1;
                         }
                 } else if(UseSpanType) {
                         if(CollectStats)
-                                runtime·xadd64(&gcstats.nobj_notype, 1);
+                                runtime·xadd64(&gcstats.obj.notype, 1);
 
                         type = runtime·gettype(b);
                         if(type != 0) {
                                 if(CollectStats)
-                                        runtime·xadd64(&gcstats.nobj_typelookups_ok, 1);
+                                        runtime·xadd64(&gcstats.obj.typelookup, 1);
 
                                 t = (Type*)(type & ~(uintptr)(PtrSize-1));
                                 switch(type & (PtrSize-1)) {
                                 case TypeInfo_SingleObject:
                                         pc = (uintptr*)t->gc;
                                         precise_type = true;  // type information about 'b' is precise
                                         stack_top.count = 1;
                                         stack_top.elemsize = pc[0];
                                         break;
                                 case TypeInfo_Array:
@@ skipping 155 matching lines @@
                                 }
                                 i = (uintptr)b + nominal_size;
                         }
                         if(!precise_type) {
                                 // Quickly scan [b+i,b+n) for possible pointers.
                                 for(; i<=end_b; i+=PtrSize) {
                                         if(*(byte**)i != nil) {
                                                 // Found a value that may be a pointer.
                                                 // Do a rescan of the entire block.
                                                 enqueue((Obj){b, n, 0}, &wbuf, &wp, &nobj);
+                                                if(CollectStats) {
+                                                        runtime·xadd64(&gcstats.rescan, 1);
+                                                        runtime·xadd64(&gcstats.rescanbytes, n);
+                                                }
                                                 break;
                                         }
                                 }
                         }
                         goto next_block;
 
                 case GC_ARRAY_START:
                         i = stack_top.b + pc[1];
                         count = pc[2];
                         elemsize = pc[3];
@@ skipping 1043 matching lines @@
                 runtime·printf("gc%d(%d): %D+%D+%D ms, %D -> %D MB %D -> %D (%D-%D) objects,"
                                 " %D(%D) handoff, %D(%D) steal, %D/%D/%D yields\n",
                         mstats.numgc, work.nproc, (t2-t1)/1000000, (t3-t2)/1000000, (t1-t0+t4-t3)/1000000,
                         heap0>>20, heap1>>20, obj0, obj1,
                         mstats.nmalloc, mstats.nfree,
                         stats.nhandoff, stats.nhandoffcnt,
                         work.sweepfor->nsteal, work.sweepfor->nstealcnt,
                         stats.nprocyield, stats.nosyield, stats.nsleep);
                 if(CollectStats) {
                         runtime·printf("scan: %D bytes, %D objects, %D untyped, %D types from MSpan\n",
-                                gcstats.nbytes, gcstats.nobj_cnt, gcstats.nobj_notype, gcstats.nobj_typelookups_ok);
-                        if(gcstats.ptr_cnt != 0)
+                                gcstats.nbytes, gcstats.obj.cnt, gcstats.obj.notype, gcstats.obj.typelookup);
+                        if(gcstats.ptr.cnt != 0)
                                 runtime·printf("avg ptrbufsize: %D (%D/%D)\n",
-                                        gcstats.ptr_sum/gcstats.ptr_cnt, gcstats.ptr_sum, gcstats.ptr_cnt);
-                        if(gcstats.nobj_cnt != 0)
+                                        gcstats.ptr.sum/gcstats.ptr.cnt, gcstats.ptr.sum, gcstats.ptr.cnt);
+                        if(gcstats.obj.cnt != 0)
                                 runtime·printf("avg nobj: %D (%D/%D)\n",
-                                        gcstats.nobj_sum/gcstats.nobj_cnt, gcstats.nobj_sum, gcstats.nobj_cnt);
-                        runtime·printf("rescans: %D, %D bytes\n", gcstats.rescans, gcstats.rescan_nbytes);
+                                        gcstats.obj.sum/gcstats.obj.cnt, gcstats.obj.sum, gcstats.obj.cnt);
+                        runtime·printf("rescans: %D, %D bytes\n", gcstats.rescan, gcstats.rescanbytes);
 
                         runtime·printf("instruction counts:\n");
                         ninstr = 0;
                         for(i=0; i<nelem(gcstats.instr); i++) {
                                 runtime·printf("\t%d:\t%D\n", i, gcstats.instr[i]);
                                 ninstr += gcstats.instr[i];
                         }
                         runtime·printf("\ttotal:\t%D\n", ninstr);
 
                         runtime·printf("putempty: %D, getfull: %D\n", gcstats.putempty, gcstats.getfull);
@@ skipping 315 matching lines @@
         uintptr n;
 
         n = (h->arena_used - h->arena_start) / wordsPerBitmapWord;
         n = (n+bitmapChunk-1) & ~(bitmapChunk-1);
         if(h->bitmap_mapped >= n)
                 return;
 
         runtime·SysMap(h->arena_start - n, n - h->bitmap_mapped);
         h->bitmap_mapped = n;
 }