summaryrefslogtreecommitdiff
path: root/Build/source/libs/pplib/pplib-src/src/util/utilmemheap.h
blob: 8776419c2843bdc259eea96ae96da174d69c9cb5 (plain)
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

#ifndef UTIL_MEM_HEAP_H
#define UTIL_MEM_HEAP_H

#include "utilmemallh.h"

typedef struct pyre8 pyre8;
typedef struct pyre16 pyre16;
typedef struct pyre32 pyre32;
typedef struct pyre64 pyre64;

struct pyre8 {
  pyre8 *prev;
  uint8_t *data;
  uint8_t left;
  uint8_t chunks;
#ifdef BIT32
  uint8_t dummy[2]; // 10->12
#else
  uint8_t dummy[6]; // 18->24
#endif
};

struct pyre16 {
  pyre16 *prev;
  uint8_t *data;
  uint16_t left;
  uint16_t chunks;
#ifdef BIT32
  //uint8_t dummy[0]; // 12->12
#else
  uint8_t dummy[4]; // 20->24
#endif
};

struct pyre32 {
  pyre32 *prev;
  uint8_t *data;
  uint32_t left;
  uint32_t chunks;
#ifdef BIT32
  //uint8_t dummy[0]; // 16->16
#else
  //uint8_t dummy[0]; // 24->24
#endif
};

struct pyre64 {
  pyre64 *prev;
  uint8_t *data;
  uint64_t left;
  uint64_t chunks;
#ifdef BIT32
  //uint8_t dummy[0]; // 24->24
#else
  //uint8_t dummy[0]; // 32->32
#endif
};

/* heaps */

typedef struct heap8 heap8;
typedef struct heap16 heap16;
typedef struct heap32 heap32;
typedef struct heap64 heap64;

struct heap8 {
  pyre8 *head;
  uint8_t space;
  uint8_t large;
  uint8_t flags;
};

struct heap16 {
  pyre16 *head;
  uint16_t space;
  uint16_t large;
  uint8_t flags;
};

struct heap32 {
  pyre32 *head;
  uint32_t space;
  uint32_t large;
  uint8_t flags;
};

struct heap64 {
  pyre64 *head;
  uint64_t space;
  uint64_t large;
  uint8_t flags;
};

#define HEAP_ZERO (1 << 0)
#define HEAP_DEFAULTS 0

#define HEAP8_INIT(space, large, flags) { NULL, aligned_space8(space), large, flags }
#define HEAP16_INIT(space, large, flags) { NULL, aligned_space16(space), large, flags }
#define HEAP32_INIT(space, large, flags) { NULL, aligned_space32(space), large, flags }
#define HEAP64_INIT(space, large, flags) { NULL, aligned_space64(space), large, flags }

UTILAPI heap8 * heap8_init (heap8 *heap, uint8_t space, uint8_t large, uint8_t flags);
UTILAPI heap16 * heap16_init (heap16 *heap, uint16_t space, uint16_t large, uint8_t flags);
UTILAPI heap32 * heap32_init (heap32 *heap, uint32_t space, uint32_t large, uint8_t flags);
UTILAPI heap64 * heap64_init (heap64 *heap, uint64_t space, uint64_t large, uint8_t flags);

UTILAPI void heap8_head (heap8 *heap);
UTILAPI void heap16_head (heap16 *heap);
UTILAPI void heap32_head (heap32 *heap);
UTILAPI void heap64_head (heap64 *heap);

#define heap8_ensure_head(heap) ((void)((heap)->head != NULL || (heap8_head(heap), 0)))
#define heap16_ensure_head(heap) ((void)((heap)->head != NULL || (heap16_head(heap), 0)))
#define heap32_ensure_head(heap) ((void)((heap)->head != NULL || (heap32_head(heap), 0)))
#define heap64_ensure_head(heap) ((void)((heap)->head != NULL || (heap64_head(heap), 0)))

UTILAPI void heap8_free (heap8 *heap);
UTILAPI void heap16_free (heap16 *heap);
UTILAPI void heap32_free (heap32 *heap);
UTILAPI void heap64_free (heap64 *heap);

UTILAPI void heap8_clear (heap8 *heap);
UTILAPI void heap16_clear (heap16 *heap);
UTILAPI void heap32_clear (heap32 *heap);
UTILAPI void heap64_clear (heap64 *heap);

UTILAPI void * _heap8_take (heap8 *heap, size_t size);
UTILAPI void * _heap16_take (heap16 *heap, size_t size);
UTILAPI void * _heap32_take (heap32 *heap, size_t size);
UTILAPI void * _heap64_take (heap64 *heap, size_t size);

UTILAPI void * _heap8_take0 (heap8 *heap, size_t size);
UTILAPI void * _heap16_take0 (heap16 *heap, size_t size);
UTILAPI void * _heap32_take0 (heap32 *heap, size_t size);
UTILAPI void * _heap64_take0 (heap64 *heap, size_t size);

#define heap8_take(heap, size) (heap8_ensure_head(heap), _heap8_take(heap, size))
#define heap16_take(heap, size) (heap16_ensure_head(heap), _heap16_take(heap, size))
#define heap32_take(heap, size) (heap32_ensure_head(heap), _heap32_take(heap, size))
#define heap64_take(heap, size) (heap64_ensure_head(heap), _heap64_take(heap, size))

#define heap8_take0(heap, size) (heap8_ensure_head(heap), _heap8_take0(heap, size))
#define heap16_take0(heap, size) (heap16_ensure_head(heap), _heap16_take0(heap, size))
#define heap32_take0(heap, size) (heap32_ensure_head(heap), _heap32_take0(heap, size))
#define heap64_take0(heap, size) (heap64_ensure_head(heap), _heap64_take0(heap, size))

UTILAPI void heap8_pop (heap8 *heap, void *taken, size_t size);
UTILAPI void heap16_pop (heap16 *heap, void *taken, size_t size);
UTILAPI void heap32_pop (heap32 *heap, void *taken, size_t size);
UTILAPI void heap64_pop (heap64 *heap, void *taken, size_t size);

UTILAPI void * _heap8_some (heap8 *heap, size_t size, size_t *pspace);
UTILAPI void * _heap16_some (heap16 *heap, size_t size, size_t *pspace);
UTILAPI void * _heap32_some (heap32 *heap, size_t size, size_t *pspace);
UTILAPI void * _heap64_some (heap64 *heap, size_t size, size_t *pspace);

#define heap8_some(heap, size, pspace) (heap8_ensure_head(heap), _heap8_some(heap, size, pspace))
#define heap16_some(heap, size, pspace) (heap16_ensure_head(heap), _heap16_some(heap, size, pspace))
#define heap32_some(heap, size, pspace) (heap32_ensure_head(heap), _heap32_some(heap, size, pspace))
#define heap64_some(heap, size, pspace) (heap64_ensure_head(heap), _heap64_some(heap, size, pspace))

UTILAPI void * heap8_more (heap8 *heap, void *taken, size_t written, size_t size, size_t *pspace);
UTILAPI void * heap16_more (heap16 *heap, void *taken, size_t written, size_t size, size_t *pspace);
UTILAPI void * heap32_more (heap32 *heap, void *taken, size_t written, size_t size, size_t *pspace);
UTILAPI void * heap64_more (heap64 *heap, void *taken, size_t written, size_t size, size_t *pspace);

UTILAPI void heap8_done (heap8 *heap, void *taken, size_t written);
UTILAPI void heap16_done (heap16 *heap, void *taken, size_t written);
UTILAPI void heap32_done (heap32 *heap, void *taken, size_t written);
UTILAPI void heap64_done (heap64 *heap, void *taken, size_t written);

UTILAPI void heap8_giveup (heap8 *heap, void *taken);
UTILAPI void heap16_giveup (heap16 *heap, void *taken);
UTILAPI void heap32_giveup (heap32 *heap, void *taken);
UTILAPI void heap64_giveup (heap64 *heap, void *taken);

UTILAPI int heap8_empty (heap8 *heap);
UTILAPI int heap16_empty (heap16 *heap);
UTILAPI int heap32_empty (heap32 *heap);
UTILAPI int heap64_empty (heap64 *heap);

UTILAPI void heap8_stats (heap8 *heap, mem_info *info, int append);
UTILAPI void heap16_stats (heap16 *heap, mem_info *info, int append);
UTILAPI void heap32_stats (heap32 *heap, mem_info *info, int append);
UTILAPI void heap64_stats (heap64 *heap, mem_info *info, int append);

#endif