summaryrefslogtreecommitdiffstats
path: root/source/base/base_arena.cpp
blob: d3999e681b5f902a8d3f4a69d8b33c5f13dd8e5e (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
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;
 }
}