code review 782041: runtime: run all finalizers in a single goroutine.

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 -- step 0.
 //
 // Stop the world, mark and sweep garbage collector.
 // NOT INTENDED FOR PRODUCTION USE.
 //
 // A mark and sweep collector provides a way to exercise
 // and test the memory allocator and the stack walking machinery
 // without also needing to get reference counting
 // exactly right.
 
 #include "runtime.h"
 #include "malloc.h"
 
 enum {
         Debug = 0
 };
 
 extern byte data[];
 extern byte etext[];
 extern byte end[];
 
+static G *fing;
 static Finalizer *finq;
 static void sweepblock(byte*, int64, uint32*, int32);
-static void runfinq(void*);
+static void runfinq(void);
 
 enum {
         PtrSize = sizeof(void*)
 };
 
 static void
 scanblock(int32 depth, byte *b, int64 n)
 {
         int32 off;
         void *obj;
@@ skipping 253 matching lines @@
         if(mheap.Lock.key != 0)
                 throw("mheap locked during gc");
         if(force || mstats.heap_alloc >= mstats.next_gc) {
                 mark();
                 sweep();
                 stealcache();
                 mstats.next_gc = mstats.heap_alloc+mstats.heap_alloc*gcpercent/100;
         }
         m->gcing = 0;
 
-        // kick off goroutines to run queued finalizers
         m->locks++;     // disable gc during the mallocs in newproc
         fp = finq;
-        if(fp != nil)
-                newproc1((byte*)runfinq, (byte*)&fp, sizeof(fp), 0);
-        finq = nil;
+        if(fp != nil) {
+                // kick off or wake up goroutine to run queued finalizers
+                if(fing == nil)
+                        fing = newproc1((byte*)runfinq, nil, 0, 0);
+                else if(fing->status == Gwaiting)
+                        ready(fing);
+        }
         m->locks--;
 
         t1 = nanotime();
         mstats.numgc++;
         mstats.pause_ns += t1 - t0;
         if(mstats.debuggc)
                 printf("pause %D\n", t1-t0);
         semrelease(&gcsema);
         starttheworld();
 ········
         // give the queued finalizers, if any, a chance to run
         if(fp != nil)
                 gosched();
 }
 
 static void
-runfinq(void *v)
+runfinq(void)
 {
         Finalizer *f, *next;
         byte *frame;
- ·······
-        f = v;
-        for(; f; f=next) {
-                next = f->next;
-                frame = mal(sizeof(uintptr) + f->nret);
-                *(void**)frame = f->arg;
-                reflect·call((byte*)f->fn, frame, sizeof(uintptr) + f->nret);
-                free(frame);
-                f->fn = nil;
-                f->arg = nil;
-                f->next = nil;
-        }
-        gc(1);  // force another gc to clean up the finalizer entries
-}
+
+        for(;;) {
+                // There's no need for a lock in this section
+                // because it only conflicts with the garbage
+                // collector, and the garbage collector only
+                // runs when everyone else is stopped, and
+                // runfinq only stops at the gosched() or
+                // during the calls in the for loop.
+                f = finq;
+                finq = nil;
+                if(f == nil) {
+                        g->status = Gwaiting;
+                        gosched();
+                        continue;
+                }
+                for(; f; f=next) {
+                        next = f->next;
+                        frame = mal(sizeof(uintptr) + f->nret);
+                        *(void**)frame = f->arg;
+                        reflect·call((byte*)f->fn, frame, sizeof(uintptr) + f->nret);
+                        free(frame);
+                        f->fn = nil;
+                        f->arg = nil;
+                        f->next = nil;
+                }
+                gc(1);  // trigger another gc to clean up the finalized objects, if possible
+        }
+}