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
|
internal void *
arena_alloc(Arena *arena, u64 size, b32 zero)
{
Assert(arena);
Arena *block = arena->current;
u64 aligned = Align(block->current_position, arena_align);
if((aligned > block->capacity) || (size > block->capacity - aligned)) {
Arena *next = ArenaCreate(Max(block->capacity, size));
AssertLog(next, "failed to create a new arena block");
next->block_position = block->block_position + block->capacity;
next->previous = block;
arena->current = next;
block = next;
aligned = 0;
}
void *out = block->base_position + aligned;
block->last_alloc_position = aligned;
block->current_position = aligned + size;
if(zero) {
MemSetZero(out, size);
}
return out;
}
internal u64
arena_position(Arena *arena)
{
Arena *block = arena->current;
return block->block_position + block->current_position;
}
internal void
arena_pop_to(Arena *arena, u64 pos)
{
Arena *block = arena->current;
while(block->previous && (block->block_position >= pos)) {
Arena *previous = block->previous;
ArenaDestroy(block);
block = previous;
}
arena->current = block;
u64 local_position = pos - block->block_position;
block->current_position = Min(block->current_position, local_position);
block->last_alloc_position = Min(block->last_alloc_position, block->current_position);
}
internal void
arena_pop(Arena *arena, u64 size)
{
u64 pos = arena_position(arena);
arena_pop_to(arena, pos - Min(size, pos));
}
internal void
arena_clear(Arena *arena)
{
arena_pop_to(arena, 0);
}
internal void *
arena_resize_block(Arena *arena, void *block, u64 new_size, u64 old_size, b32 zero)
{
if((block == NULL) || (old_size == 0)) {
return arena_alloc(arena, new_size, zero);
}
u8 *old_mem = (u8 *)block;
b32 owned = false;
for(Arena *it = arena->current; it; it = it->previous) {
if((old_mem >= it->base_position) && (old_mem < it->base_position + it->current_position)) {
owned = true;
break;
}
}
AssertLog(owned, "Failed to resize block because it was not allocated in this arena");
Arena *current = arena->current;
u8 *result = old_mem;
b32 is_last = (old_mem == current->base_position + current->last_alloc_position);
if(is_last && (new_size <= current->capacity - current->last_alloc_position)) {
current->current_position = current->last_alloc_position + new_size;
} else if(new_size > old_size) {
result = (u8 *)arena_alloc(arena, new_size, 0);
MemCpy(result, old_mem, old_size);
}
if(zero && (new_size > old_size)) {
MemSetZero(result + old_size, new_size - old_size);
}
return result;
}
internal ScratchArena
scratch_start(Arena *arena)
{
ScratchArena scratch;
scratch.arena = arena;
scratch.start_block = arena->current;
scratch.start_position = arena_position(arena);
scratch.start_last_alloc_position = arena->current->last_alloc_position;
return scratch;
}
internal void
scratch_end(ScratchArena *scratch)
{
arena_pop_to(scratch->arena, scratch->start_position);
if(scratch->arena->current == scratch->start_block) {
scratch->arena->current->last_alloc_position = scratch->start_last_alloc_position;
}
}
|