|
@@ -22,13 +22,13 @@ struct OldMemoryPoolBase {
|
|
|
|
|
|
protected:
|
|
|
OldMemoryPoolBase(const char *name, uint max_blocks, uint block_size_bits, uint item_size,
|
|
|
OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :
|
|
|
name(name), max_blocks(max_blocks), block_size_bits(block_size_bits),
|
|
|
new_block_proc(new_block_proc), clean_block_proc(clean_block_proc), current_blocks(0),
|
|
|
total_items(0), item_size(item_size), first_free_index(0), blocks(NULL) {}
|
|
|
total_items(0), cleaning_pool(false), item_size(item_size), first_free_index(0), blocks(NULL) {}
|
|
|
|
|
|
const char* 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
|
|
|
|
|
@@ -37,12 +37,13 @@ protected:
|
|
|
/// Pointer to a function that is called to clean a block
|
|
|
OldMemoryPoolCleanBlock *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
|
|
|
|
|
|
bool cleaning_pool; ///< Are we currently cleaning the pool?
|
|
|
public:
|
|
|
const uint item_size; ///< How many bytes one block is
|
|
|
uint first_free_index; ///< The index of the first free pool item in this pool
|
|
|
byte **blocks; ///< An array of blocks (one block hold all the items)
|
|
|
|
|
|
/**
|
|
@@ -81,12 +82,21 @@ public:
|
|
|
* @return the name
|
|
|
*/
|
|
|
inline const char *GetName() const
|
|
|
{
|
|
|
return this->name;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Is the pool in the cleaning phase?
|
|
|
* @return true if it is
|
|
|
*/
|
|
|
inline bool CleaningPool() const
|
|
|
{
|
|
|
return this->cleaning_pool;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
|
struct OldMemoryPool : public OldMemoryPoolBase {
|
|
|
OldMemoryPool(const char *name, uint max_blocks, uint block_size_bits, uint item_size,
|
|
|
OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :
|
|
@@ -118,24 +128,21 @@ static void PoolNewBlock(uint start_item
|
|
|
t->index = start_item++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Generic function to free a new block in a pool.
|
|
|
* This function uses QuickFree that is intended to only free memory that would be lost if the pool is freed.
|
|
|
* @param start_item the first item that needs to be cleaned
|
|
|
* @param end_item the last item that needs to be cleaned
|
|
|
*/
|
|
|
template <typename T, OldMemoryPool<T> *Tpool>
|
|
|
static void PoolCleanBlock(uint start_item, uint end_item)
|
|
|
{
|
|
|
for (uint i = start_item; i <= end_item; i++) {
|
|
|
T *t = Tpool->Get(i);
|
|
|
if (t->IsValid()) {
|
|
|
t->QuickFree();
|
|
|
}
|
|
|
delete t;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Generalization for all pool items that are saved in the savegame.
|
|
@@ -154,21 +161,12 @@ struct PoolItem {
|
|
|
virtual ~PoolItem()
|
|
|
{
|
|
|
if (this->index < Tpool->first_free_index) Tpool->first_free_index = this->index;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Called on each object when the pool is being destroyed, so one
|
|
|
* can free allocated memory without the need for freeing for
|
|
|
* example orders.
|
|
|
*/
|
|
|
virtual void QuickFree()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* An overriden version of new that allocates memory on the pool.
|
|
|
* @param size the size of the variable (unused)
|
|
|
* @return the memory that is 'allocated'
|
|
|
*/
|
|
|
void *operator new(size_t size)
|
|
|
{
|
|
@@ -238,23 +236,23 @@ struct PoolItem {
|
|
|
|
|
|
protected:
|
|
|
/**
|
|
|
* Allocate a pool item; possibly allocate a new block in the pool.
|
|
|
* @return the allocated pool item (or NULL when the pool is full).
|
|
|
*/
|
|
|
static T *AllocateRaw()
|
|
|
static inline T *AllocateRaw()
|
|
|
{
|
|
|
return AllocateRaw(Tpool->first_free_index);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Allocate a pool item; possibly allocate a new block in the pool.
|
|
|
* @param first the first pool item to start searching
|
|
|
* @return the allocated pool item (or NULL when the pool is full).
|
|
|
*/
|
|
|
static T *AllocateRaw(uint &first)
|
|
|
static inline T *AllocateRaw(uint &first)
|
|
|
{
|
|
|
uint last_minus_one = Tpool->GetSize() - 1;
|
|
|
|
|
|
for (T *t = Tpool->Get(first); t != NULL; t = (t->index < last_minus_one) ? Tpool->Get(t->index + 1U) : NULL) {
|
|
|
if (!t->IsValid()) {
|
|
|
first = t->index;
|
|
@@ -268,12 +266,21 @@ protected:
|
|
|
|
|
|
/* Check if we can add a block to the pool */
|
|
|
if (Tpool->AddBlockToPool()) return AllocateRaw(first);
|
|
|
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Are we cleaning this pool?
|
|
|
* @return true if we are
|
|
|
*/
|
|
|
static inline bool CleaningPool()
|
|
|
{
|
|
|
return Tpool->CleaningPool();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
#define OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \
|
|
|
enum { \
|
|
|
name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \
|