aboutsummaryrefslogtreecommitdiffstats
path: root/source/base/base_arena.cpp
blob: d09a33fb9399a4b8a7424a92a3ce03e7453543f4 (plain) (blame)
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
128
129
130
131
132
133
134
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;

	arena->alloc_count += 1;
	arena->alloc_bytes += size;
	u64 position = block->block_position + block->current_position;
	if(position > arena->peak_position) arena->peak_position = position;
	
	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;
#if 0
		ArenaDestroy(block);
#endif
		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;
	}
}