struct Fintab
{
void **key;
- struct {
- void *fn;
- int32 nret;
- } *val;
+ Finalizer **val;
int32 nkey; // number of non-nil entries in key
int32 ndead; // number of dead (-1) entries in key
int32 max; // size of key, val allocations
};
static void
-addfintab(Fintab *t, void *k, void *fn, int32 nret)
+addfintab(Fintab *t, void *k, Finalizer *v)
{
int32 i, j;
ret:
t->key[i] = k;
- t->val[i].fn = fn;
- t->val[i].nret = nret;
+ t->val[i] = v;
}
-static void*
-lookfintab(Fintab *t, void *k, bool del, int32 *nret)
+static Finalizer*
+lookfintab(Fintab *t, void *k, bool del)
{
int32 i, j;
- void *v;
+ Finalizer *v;
if(t->max == 0)
return nil;
if(t->key[i] == nil)
return nil;
if(t->key[i] == k) {
- v = t->val[i].fn;
- if(nret)
- *nret = t->val[i].nret;
+ v = t->val[i];
if(del) {
t->key[i] = (void*)-1;
- t->val[i].fn = nil;
- t->val[i].nret = 0;
+ t->val[i] = nil;
t->ndead++;
}
return v;
int32 i;
uint32 *ref;
byte *base;
+ Finalizer *e;
+
+ e = nil;
+ if(f != nil) {
+ e = mal(sizeof *e);
+ e->fn = f;
+ e->nret = nret;
+ }
lock(&finlock);
if(!mlookup(p, &base, nil, nil, &ref) || p != base) {
}
if(f == nil) {
if(*ref & RefHasFinalizer) {
- lookfintab(&fintab, p, 1, nil);
+ lookfintab(&fintab, p, 1);
*ref &= ~RefHasFinalizer;
}
unlock(&finlock);
k = fintab.key[i];
if(k != nil && k != (void*)-1)
- addfintab(&newtab, k, fintab.val[i].fn, fintab.val[i].nret);
+ addfintab(&newtab, k, fintab.val[i]);
}
free(fintab.key);
free(fintab.val);
fintab = newtab;
}
- addfintab(&fintab, p, f, nret);
+ addfintab(&fintab, p, e);
unlock(&finlock);
}
// get finalizer; if del, delete finalizer.
// caller is responsible for updating RefHasFinalizer bit.
-void*
-getfinalizer(void *p, bool del, int32 *nret)
+Finalizer*
+getfinalizer(void *p, bool del)
{
- void *f;
+ Finalizer *f;
lock(&finlock);
- f = lookfintab(&fintab, p, del, nret);
+ f = lookfintab(&fintab, p, del);
unlock(&finlock);
return f;
}
+
+void
+walkfintab(void (*fn)(void*))
+{
+ void **key;
+ void **ekey;
+
+ lock(&finlock);
+ key = fintab.key;
+ ekey = key + fintab.max;
+ for(; key < ekey; key++)
+ if(*key != nil && *key != ((void*)-1))
+ fn(*key);
+ unlock(&finlock);
+}
extern byte etext[];
extern byte end[];
-typedef struct Finq Finq;
-struct Finq
-{
- void (*fn)(void*);
- void *p;
- int32 nret;
-};
-
-static Finq finq[128]; // finalizer queue - two elements per entry
-static Finq *pfinq = finq;
-static Finq *efinq = finq+nelem(finq);
-
+static G *fing;
+static Finalizer *finq;
static void sweepblock(byte*, int64, uint32*, int32);
+static void runfinq(void);
enum {
PtrSize = sizeof(void*)
if(mlookup(obj, &obj, &size, nil, &refp)) {
ref = *refp;
switch(ref & ~RefFlags) {
- case RefFinalize:
- // If marked for finalization already, some other finalization-ready
- // object has a pointer: turn off finalization until that object is gone.
- // This means that cyclic finalizer loops never get collected,
- // so don't do that.
- /* fall through */
case RefNone:
if(Debug > 1)
printf("%d found at %p: ", depth, &vp[i]);
}
}
+static void
+markfin(void *v)
+{
+ uintptr size;
+ uint32 *refp;
+
+ size = 0;
+ refp = nil;
+ if(!mlookup(v, &v, &size, nil, &refp) || !(*refp & RefHasFinalizer))
+ throw("mark - finalizer inconsistency");
+
+ // do not mark the finalizer block itself. just mark the things it points at.
+ scanblock(1, v, size);
+}
+
static void
mark(void)
{
break;
}
}
-}
-// pass 0: mark RefNone with finalizer as RefFinalize and trace
-static void
-sweepspan0(MSpan *s)
-{
- byte *p;
- uint32 ref, *gcrefp, *gcrefep;
- int32 n, size, npages;
-
- p = (byte*)(s->start << PageShift);
- if(s->sizeclass == 0) {
- // Large block.
- ref = s->gcref0;
- if((ref&~(RefFlags^RefHasFinalizer)) == (RefNone|RefHasFinalizer)) {
- // Mark as finalizable.
- s->gcref0 = RefFinalize | RefHasFinalizer | (ref&(RefFlags^RefHasFinalizer));
- if(!(ref & RefNoPointers))
- scanblock(100, p, s->npages<<PageShift);
- }
- return;
- }
-
- // Chunk full of small blocks.
- MGetSizeClassInfo(s->sizeclass, &size, &npages, &n);
- gcrefp = s->gcref;
- gcrefep = s->gcref + n;
- for(; gcrefp < gcrefep; gcrefp++) {
- ref = *gcrefp;
- if((ref&~(RefFlags^RefHasFinalizer)) == (RefNone|RefHasFinalizer)) {
- // Mark as finalizable.
- *gcrefp = RefFinalize | RefHasFinalizer | (ref&(RefFlags^RefHasFinalizer));
- if(!(ref & RefNoPointers))
- scanblock(100, p+(gcrefp-s->gcref)*size, size);
- }
- }
-}
+ // mark things pointed at by objects with finalizers
+ walkfintab(markfin);
+}
-// pass 1: free RefNone, queue RefFinalize, reset RefSome
+// free RefNone, free & queue finalizers for RefNone|RefHasFinalizer, reset RefSome
static void
-sweepspan1(MSpan *s)
+sweepspan(MSpan *s)
{
int32 n, npages, size;
byte *p;
uint32 ref, *gcrefp, *gcrefep;
MCache *c;
+ Finalizer *f;
p = (byte*)(s->start << PageShift);
if(s->sizeclass == 0) {
// Large block.
ref = s->gcref0;
- switch(ref & ~RefFlags) {
+ switch(ref & ~(RefFlags^RefHasFinalizer)) {
case RefNone:
// Free large object.
mstats.alloc -= s->npages<<PageShift;
s->gcref0 = RefFree;
MHeap_Free(&mheap, s, 1);
break;
- case RefFinalize:
- if(pfinq < efinq) {
- pfinq->p = p;
- pfinq->nret = 0;
- pfinq->fn = getfinalizer(p, 1, &pfinq->nret);
- ref &= ~RefHasFinalizer;
- if(pfinq->fn == nil)
- throw("finalizer inconsistency");
- pfinq++;
- }
+ case RefNone|RefHasFinalizer:
+ f = getfinalizer(p, 1);
+ if(f == nil)
+ throw("finalizer inconsistency");
+ f->arg = p;
+ f->next = finq;
+ finq = f;
+ ref &= ~RefHasFinalizer;
// fall through
case RefSome:
+ case RefSome|RefHasFinalizer:
s->gcref0 = RefNone | (ref&RefFlags);
break;
}
ref = *gcrefp;
if(ref < RefNone) // RefFree or RefStack
continue;
- switch(ref & ~RefFlags) {
+ switch(ref & ~(RefFlags^RefHasFinalizer)) {
case RefNone:
// Free small object.
if(ref & RefProfiled)
mstats.by_size[s->sizeclass].nfree++;
MCache_Free(c, p, s->sizeclass, size);
break;
- case RefFinalize:
- if(pfinq < efinq) {
- pfinq->p = p;
- pfinq->nret = 0;
- pfinq->fn = getfinalizer(p, 1, &pfinq->nret);
- ref &= ~RefHasFinalizer;
- if(pfinq->fn == nil)
- throw("finalizer inconsistency");
- pfinq++;
- }
+ case RefNone|RefHasFinalizer:
+ f = getfinalizer(p, 1);
+ if(f == nil)
+ throw("finalizer inconsistency");
+ f->arg = p;
+ f->next = finq;
+ finq = f;
+ ref &= ~RefHasFinalizer;
// fall through
case RefSome:
+ case RefSome|RefHasFinalizer:
*gcrefp = RefNone | (ref&RefFlags);
break;
}
{
MSpan *s;
- // Sweep all the spans marking blocks to be finalized.
for(s = mheap.allspans; s != nil; s = s->allnext)
if(s->state == MSpanInUse)
- sweepspan0(s);
-
- // Sweep again queueing finalizers and freeing the others.
- for(s = mheap.allspans; s != nil; s = s->allnext)
- if(s->state == MSpanInUse)
- sweepspan1(s);
+ sweepspan(s);
}
// Semaphore, not Lock, so that the goroutine
{
int64 t0, t1;
byte *p;
- Finq *fp;
+ Finalizer *fp;
// The gc is turned off (via enablegc) until
// the bootstrap has completed.
}
m->gcing = 0;
- // kick off goroutines to run queued finalizers
m->locks++; // disable gc during the mallocs in newproc
- for(fp=finq; fp<pfinq; fp++) {
- newproc1((byte*)fp->fn, (byte*)&fp->p, sizeof(fp->p), fp->nret);
- fp->fn = nil;
- fp->p = nil;
+ fp = finq;
+ 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);
}
- pfinq = finq;
m->locks--;
t1 = nanotime();
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)
+{
+ Finalizer *f, *next;
+ byte *frame;
+
+ 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
+ }
}