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
|
#include <u.h>
#include <libc.h>
#include <bin.h>
enum
{
StructAlign = sizeof(union {vlong vl; double d; ulong p; void *v;
struct{vlong v;}vs; struct{double d;}ds; struct{ulong p;}ss; struct{void *v;}xs;})
};
enum
{
BinSize = 8*1024
};
struct Bin
{
Bin *next;
ulong total; /* total bytes allocated in can->next */
ulong pos;
ulong end;
ulong v; /* last value allocated */
uchar body[BinSize];
};
/*
* allocator which allows an entire set to be freed at one time
*/
static Bin*
mkbin(Bin *bin, ulong size)
{
Bin *b;
size = ((size << 1) + (BinSize - 1)) & ~(BinSize - 1);
b = malloc(sizeof(Bin) + size - BinSize);
if(b == nil)
return nil;
b->next = bin;
b->total = 0;
if(bin != nil)
b->total = bin->total + bin->pos - (ulong)bin->body;
b->pos = (ulong)b->body;
b->end = b->pos + size;
return b;
}
void*
binalloc(Bin **bin, ulong size, int zero)
{
Bin *b;
ulong p;
if(size == 0)
size = 1;
b = *bin;
if(b == nil){
b = mkbin(nil, size);
if(b == nil)
return nil;
*bin = b;
}
p = b->pos;
p = (p + (StructAlign - 1)) & ~(StructAlign - 1);
if(p + size > b->end){
b = mkbin(b, size);
if(b == nil)
return nil;
*bin = b;
p = b->pos;
}
b->pos = p + size;
b->v = p;
if(zero)
memset((void*)p, 0, size);
return (void*)p;
}
void*
bingrow(Bin **bin, void *op, ulong osize, ulong size, int zero)
{
Bin *b;
void *np;
ulong p;
p = (ulong)op;
b = *bin;
if(b != nil && p == b->v && p + size <= b->end){
b->pos = p + size;
if(zero)
memset((char*)p + osize, 0, size - osize);
return op;
}
np = binalloc(bin, size, zero);
if(np == nil)
return nil;
memmove(np, op, osize);
return np;
}
void
binfree(Bin **bin)
{
Bin *last;
while(*bin != nil){
last = *bin;
*bin = (*bin)->next;
last->pos = (ulong)last->body;
free(last);
}
}
|