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
|
/* $Id$ */
#ifndef POOL_H
#define POOL_H
typedef struct MemoryPool MemoryPool;
/* The function that is called after a new block is added
start_item is the first item of the new made block */
typedef void MemoryPoolNewBlock(uint start_item);
/* The function that is called before a block is cleaned up */
typedef void MemoryPoolCleanBlock(uint start_item, uint end_item);
/**
* Stuff for dynamic vehicles. Use the wrappers to access the MemoryPool
* please try to avoid manual calls!
*/
struct MemoryPool {
const char* const name; ///< Name of the pool (just for debugging)
const uint max_blocks; ///< The max amount of blocks this pool can have
const uint block_size_bits; ///< The size of each block in bits
const uint item_size; ///< How many bytes one block is
/// Pointer to a function that is called after a new block is added
MemoryPoolNewBlock *new_block_proc;
/// Pointer to a function that is called to clean a block
MemoryPoolCleanBlock *clean_block_proc;
uint current_blocks; ///< How many blocks we have in our pool
uint total_items; ///< How many items we now have in this pool
byte **blocks; ///< An array of blocks (one block hold all the items)
};
/**
* Those are the wrappers:
* CleanPool cleans the pool up, but you can use AddBlockToPool directly again
* (no need to call CreatePool!)
* AddBlockToPool adds 1 more block to the pool. Returns false if there is no
* more room
*/
void CleanPool(MemoryPool *array);
bool AddBlockToPool(MemoryPool *array);
/**
* Adds blocks to the pool if needed (and possible) till index fits inside the pool
*
* @return Returns false if adding failed
*/
bool AddBlockIfNeeded(MemoryPool *array, uint index);
#define POOL_ENUM(name, type, block_size_bits, max_blocks) \
enum { \
name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \
name##_POOL_MAX_BLOCKS = max_blocks \
};
#define POOL_ACCESSORS(name, type) \
static inline type* Get##name(uint index) \
{ \
assert(index < _##name##_pool.total_items); \
return (type*)( \
_##name##_pool.blocks[index >> name##_POOL_BLOCK_SIZE_BITS] + \
(index & ((1 << name##_POOL_BLOCK_SIZE_BITS) - 1)) * sizeof(type) \
); \
} \
\
static inline uint Get##name##PoolSize(void) \
{ \
return _##name##_pool.total_items; \
}
#define DECLARE_POOL(name, type, block_size_bits, max_blocks) \
POOL_ENUM(name, type, block_size_bits, max_blocks) \
extern MemoryPool _##name##_pool; \
POOL_ACCESSORS(name, type)
#define DEFINE_POOL(name, type, new_block_proc, clean_block_proc) \
MemoryPool _##name##_pool = { \
#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \
new_block_proc, clean_block_proc, \
0, 0, NULL \
};
#define STATIC_POOL(name, type, block_size_bits, max_blocks, new_block_proc, clean_block_proc) \
POOL_ENUM(name, type, block_size_bits, max_blocks) \
static DEFINE_POOL(name, type, new_block_proc, clean_block_proc) \
POOL_ACCESSORS(name, type)
#endif /* POOL_H */
|
