code review 37540043: runtime: heap dump experiment

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 (GC).
 //
 // GC is:
 // - mark&sweep
 // - mostly precise (with the exception of some C-allocated objects, assembly frames/arguments, etc)
 // - parallel (up to MaxGcproc threads)
@@ skipping 1434 matching lines @@
         enqueue1(wbufp, (Obj){scanp+PtrSize, PtrSize, 0});
 }
 
 // Starting from scanp, scans words corresponding to set bits.
 static void
 scanbitvector(byte *scanp, BitVector *bv, bool afterprologue, void *wbufp)
 {
         uintptr word, bits;
         uint32 *wordp;
         int32 i, remptrs;
+        byte *p;
 
         wordp = bv->data;
         for(remptrs = bv->n; remptrs > 0; remptrs -= 32) {
                 word = *wordp++;
                 if(remptrs < 32)
                         i = remptrs;
                 else
                         i = 32;
                 i /= BitsPerPointer;
                 for(; i > 0; i--) {
                         bits = word & 3;
-                        if(bits != BitsNoPointer && *(void**)scanp != nil)
-                                if(bits == BitsPointer)
+                        switch(bits) {
+                        case BitsDead:
+                                if(runtime·debug.gcdead)
+                                        *(uintptr*)scanp = (uintptr)0x6969696969696969LL;
+                                break;
+                        case BitsScalar:
+                                break;
+                        case BitsPointer:
+                                p = *(byte**)scanp;
+                                if(p != nil)
                                         enqueue1(wbufp, (Obj){scanp, PtrSize, 0});
-                                else
-                                        scaninterfacedata(bits, scanp, afterprologue, wbufp);
+                                break;
+                        case BitsMultiWord:
+                                p = *(byte**)scanp;
+                                if(p != nil) {
+                                        word >>= BitsPerPointer;
+                                        scanp += PtrSize;
+                                        i--;
+                                        if(i == 0) {
+                                                // Get next chunk of bits
+                                                remptrs -= 32;
+                                                word = *wordp++;
+                                                if(remptrs < 32)
+                                                        i = remptrs;
+                                                else
+                                                        i = 32;
+                                                i /= BitsPerPointer;
+                                        }
+                                        switch(word & 3) {
+                                        case BitsString:
+                                                if(((String*)(scanp - PtrSize))->len != 0)
+                                                        markonly(p);
+                                                break;
+                                        case BitsSlice:
+                                                if(((Slice*)(scanp - PtrSize))->cap < ((Slice*)(scanp - PtrSize))->len)
+                                                        runtime·throw("slice capacity smaller than length");
+                                                if(((Slice*)(scanp - PtrSize))->cap != 0)
+                                                        enqueue1(wbufp, (Obj){scanp - PtrSize, PtrSize, 0});
+                                                break;
+                                        case BitsIface:
+                                        case BitsEface:
+                                                scaninterfacedata(word & 3, scanp - PtrSize, afterprologue, wbufp);
+                                                break;
+                                        }
+                                }
+                        }
                         word >>= BitsPerPointer;
                         scanp += PtrSize;
                 }
         }
 }
 
 // Scan a stack frame: local variables and function arguments/results.
 static bool
 scanframe(Stkframe *frame, void *wbufp)
 {
@@ skipping 523 matching lines @@
         uint32 spanidx;
 
         for(spanidx=0; spanidx<runtime·mheap.nspan; spanidx++) {
                 dumpspan(spanidx);
         }
 }
 
 void
 runtime·gchelper(void)
 {
-        int32 nproc;
+        uint32 nproc;
 
         gchelperstart();
 
         // parallel mark for over gc roots
         runtime·parfordo(work.markfor);
 
         // help other threads scan secondary blocks
         scanblock(nil, true);
 
         bufferList[m->helpgc].busy = 0;
@@ skipping 719 matching lines @@
                 bitmapChunk = 8192
         };
         uintptr n;
 
         n = (h->arena_used - h->arena_start) / wordsPerBitmapWord;
         n = ROUND(n, bitmapChunk);
         n = ROUND(n, PhysPageSize);
         if(h->bitmap_mapped >= n)
                 return;
 
-        runtime·SysMap(h->arena_start - n, n - h->bitmap_mapped, &mstats.gc_sys);
+        runtime·SysMap(h->arena_start - n, n - h->bitmap_mapped, h->arena_reserved, &mstats.gc_sys);
         h->bitmap_mapped = n;
 }