1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2010 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.
#include "runtime.h"
#include "malloc.h"
// Finalizer hash table. Direct hash, linear scan, at most 3/4 full.
// Table size is power of 3 so that hash can be key % max.
// Key[i] == (void*)-1 denotes free but formerly occupied entry
// (doesn't stop the linear scan).
// Key and val are separate tables because the garbage collector
// must be instructed to ignore the pointers in key but follow the
// pointers in val.
typedef struct Fintab Fintab;
struct Fintab
{
void **key;
void **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 *v)
{
int32 i, j;
i = (uintptr)k % (uintptr)t->max;
for(j=0; j<t->max; j++) {
if(t->key[i] == nil) {
t->nkey++;
goto ret;
}
if(t->key[i] == (void*)-1) {
t->ndead--;
goto ret;
}
if(++i == t->max)
i = 0;
}
// cannot happen - table is known to be non-full
throw("finalizer table inconsistent");
ret:
t->key[i] = k;
t->val[i] = v;
}
static void*
lookfintab(Fintab *t, void *k, bool del)
{
int32 i, j;
void *v;
if(t->max == 0)
return nil;
i = (uintptr)k % (uintptr)t->max;
for(j=0; j<t->max; j++) {
if(t->key[i] == nil)
return nil;
if(t->key[i] == k) {
v = t->val[i];
if(del) {
t->key[i] = (void*)-1;
t->val[i] = nil;
t->ndead++;
}
return v;
}
if(++i == t->max)
i = 0;
}
// cannot happen - table is known to be non-full
throw("finalizer table inconsistent");
return nil;
}
static Fintab fintab;
// add finalizer; caller is responsible for making sure not already in table
void
addfinalizer(void *p, void *f)
{
Fintab newtab;
int32 i;
if(fintab.nkey >= fintab.max/2+fintab.max/4) {
// keep table at most 3/4 full:
// allocate new table and rehash.
runtime_memclr((byte*)&newtab, sizeof newtab);
newtab.max = fintab.max;
if(newtab.max == 0)
newtab.max = 3*3*3;
else if(fintab.ndead < fintab.nkey/2) {
// grow table if not many dead values.
// otherwise just rehash into table of same size.
newtab.max *= 3;
}
newtab.key = mallocgc(newtab.max*sizeof newtab.key[0], RefNoPointers, 0);
newtab.val = mallocgc(newtab.max*sizeof newtab.val[0], 0, 0);
for(i=0; i<fintab.max; i++) {
void *k;
k = fintab.key[i];
if(k != nil && k != (void*)-1)
addfintab(&newtab, k, fintab.val[i]);
}
free(fintab.key);
free(fintab.val);
fintab = newtab;
}
addfintab(&fintab, p, f);
}
void*
getfinalizer(void *p, bool del)
{
return lookfintab(&fintab, p, del);
}
|
