1

/* $Id$ */

     2

     3

/** @file oldpool.h Base for the old pool. */

     4

     5

#ifndef OLDPOOL_H

     6

#define OLDPOOL_H

     7

     8

#include "core/math_func.hpp"

     9

    10

/* The function that is called after a new block is added

    11

     start_item is the first item of the new made block */

    12

typedef void OldMemoryPoolNewBlock(uint start_item);

    13

/* The function that is called before a block is cleaned up */

    14

typedef void OldMemoryPoolCleanBlock(uint start_item, uint end_item);

    15

    16

/**

    17

 * Stuff for dynamic vehicles. Use the wrappers to access the OldMemoryPool

    18

 *  please try to avoid manual calls!

    19

 */

    20

struct OldMemoryPoolBase {

    21

	void CleanPool();

    22

	bool AddBlockToPool();

    23

	bool AddBlockIfNeeded(uint index);

    24

    25

protected:

    26

	OldMemoryPoolBase(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

    27

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

    28

		name(name), max_blocks(max_blocks), block_size_bits(block_size_bits),

    29

		new_block_proc(new_block_proc), clean_block_proc(clean_block_proc), current_blocks(0),

    30

		total_items(0), cleaning_pool(false), item_size(item_size), first_free_index(0), blocks(NULL) {}

    31

    32

	const char* name;     ///< Name of the pool (just for debugging)

    33

    34

	const uint max_blocks;      ///< The max amount of blocks this pool can have

    35

	const uint block_size_bits; ///< The size of each block in bits

    36

    37

	/// Pointer to a function that is called after a new block is added

    38

	OldMemoryPoolNewBlock *new_block_proc;

    39

	/// Pointer to a function that is called to clean a block

    40

	OldMemoryPoolCleanBlock *clean_block_proc;

    41

    42

	uint current_blocks;        ///< How many blocks we have in our pool

    43

	uint total_items;           ///< How many items we now have in this pool

    44

    45

	bool cleaning_pool;         ///< Are we currently cleaning the pool?

    46

public:

    47

	const uint item_size;       ///< How many bytes one block is

    48

	uint first_free_index;      ///< The index of the first free pool item in this pool

    49

	byte **blocks;              ///< An array of blocks (one block hold all the items)

    50

    51

	/**

    52

	 * Check if the index of pool item being deleted is lower than cached first_free_index

    53

	 * @param index index of pool item

    54

	 * @note usage of min() will result in better code on some architectures

    55

	 */

    56

	inline void UpdateFirstFreeIndex(uint index)

    57

	{

    58

		first_free_index = min(first_free_index, index);

    59

	}

    60

    61

	/**

    62

	 * Get the size of this pool, i.e. the total number of items you

    63

	 * can put into it at the current moment; the pool might still

    64

	 * be able to increase the size of the pool.

    65

	 * @return the size of the pool

    66

	 */

    67

	inline uint GetSize() const

    68

	{

    69

		return this->total_items;

    70

	}

    71

    72

	/**

    73

	 * Can this pool allocate more blocks, i.e. is the maximum amount

    74

	 * of allocated blocks not yet reached?

    75

	 * @return the if and only if the amount of allocable blocks is

    76

	 *         less than the amount of allocated blocks.

    77

	 */

    78

	inline bool CanAllocateMoreBlocks() const

    79

	{

    80

		return this->current_blocks < this->max_blocks;

    81

	}

    82

    83

	/**

    84

	 * Get the maximum number of allocable blocks.

    85

	 * @return the numebr of blocks

    86

	 */

    87

	inline uint GetBlockCount() const

    88

	{

    89

		return this->current_blocks;

    90

	}

    91

    92

	/**

    93

	 * Get the name of this pool.

    94

	 * @return the name

    95

	 */

    96

	inline const char *GetName() const

    97

	{

    98

		return this->name;

    99

	}

   100

   101

	/**

   102

	 * Is the pool in the cleaning phase?

   103

	 * @return true if it is

   104

	 */

   105

	inline bool CleaningPool() const

   106

	{

   107

		return this->cleaning_pool;

   108

	}

   109

};

   110

   111

template <typename T>

   112

struct OldMemoryPool : public OldMemoryPoolBase {

   113

	OldMemoryPool(const char *name, uint max_blocks, uint block_size_bits, uint item_size,

   114

				OldMemoryPoolNewBlock *new_block_proc, OldMemoryPoolCleanBlock *clean_block_proc) :

   115

		OldMemoryPoolBase(name, max_blocks, block_size_bits, item_size, new_block_proc, clean_block_proc) {}

   116

   117

	/**

   118

	 * Get the pool entry at the given index.

   119

	 * @param index the index into the pool

   120

	 * @pre index < this->GetSize()

   121

	 * @return the pool entry.

   122

	 */

   123

	inline T *Get(uint index) const

   124

	{

   125

		assert(index < this->GetSize());

   126

		return (T*)(this->blocks[index >> this->block_size_bits] +

   127

				(index & ((1 << this->block_size_bits) - 1)) * this->item_size);

   128

	}

   129

};

   130

   131

/**

   132

 * Generic function to initialize a new block in a pool.

   133

 * @param start_item the first item that needs to be initialized

   134

 */

   135

template <typename T, OldMemoryPool<T> *Tpool>

   136

static void PoolNewBlock(uint start_item)

   137

{

   138

	for (T *t = Tpool->Get(start_item); t != NULL; t = (t->index + 1U < Tpool->GetSize()) ? Tpool->Get(t->index + 1U) : NULL) {

   139

		t = new (t) T();

   140

		t->index = start_item++;

   141

	}

   142

}

   143

   144

/**

   145

 * Generic function to free a new block in a pool.

   146

 * @param start_item the first item that needs to be cleaned

   147

 * @param end_item   the last item that needs to be cleaned

   148

 */

   149

template <typename T, OldMemoryPool<T> *Tpool>

   150

static void PoolCleanBlock(uint start_item, uint end_item)

   151

{

   152

	for (uint i = start_item; i <= end_item; i++) {

   153

		T *t = Tpool->Get(i);

   154

		delete t;

   155

	}

   156

}

   157

   158

/**

   159

 * Template providing a predicate to allow STL containers of

   160

 * pointers to pool items to be sorted by index.

   161

 */

   162

template <typename T>

   163

struct PoolItemIndexLess {

   164

	/**

   165

	 * The actual comparator.

   166

	 * @param lhs the left hand side of the comparison.

   167

	 * @param rhs the right hand side of the comparison.

   168

	 * @return true if lhs' index is less than rhs' index.

   169

	 */

   170

	bool operator()(const T *lhs, const T *rhs) const

   171

	{

   172

		return lhs->index < rhs->index;

   173

	}

   174

};

   175

   176

/**

   177

 * Generalization for all pool items that are saved in the savegame.

   178

 * It specifies all the mechanics to access the pool easily.

   179

 */

   180

template <typename T, typename Tid, OldMemoryPool<T> *Tpool>

   181

struct PoolItem {

   182

	/**

   183

	 * The pool-wide index of this object.

   184

	 */

   185

	Tid index;

   186

   187

	/**

   188

	 * We like to have the correct class destructed.

   189

	 * @warning It is called even for object allocated on stack,

   190

	 *          so it is not present in the TPool!

   191

	 *          Then, index is undefined, not associated with TPool in any way.

   192

	 * @note    The idea is to free up allocated memory etc.

   193

	 */

   194

	virtual ~PoolItem()

   195

	{

   196

   197

	}

   198

   199

	/**

   200

	 * Constructor of given class.

   201

	 * @warning It is called even for object allocated on stack,

   202

	 *          so it may not be present in TPool!

   203

	 *          Then, index is undefined, not associated with TPool in any way.

   204

	 * @note    The idea is to initialize variables (except index)

   205

	 */

   206

	PoolItem()

   207

	{

   208

   209

	}

   210

   211

	/**

   212

	 * An overriden version of new that allocates memory on the pool.

   213

	 * @param size the size of the variable (unused)

   214

	 * @return the memory that is 'allocated'

   215

	 */

   216

	void *operator new(size_t size)

   217

	{

   218

		return AllocateRaw();

   219

	}

   220

   221

	/**

   222

	 * 'Free' the memory allocated by the overriden new.

   223

	 * @param p the memory to 'free'

   224

	 * @note we only update Tpool->first_free_index

   225

	 */

   226

	void operator delete(void *p)

   227

	{

   228

		Tpool->UpdateFirstFreeIndex(((T*)p)->index);

   229

	}

   230

   231

	/**

   232

	 * An overriden version of new, so you can directly allocate a new object with

   233

	 * the correct index when one is loading the savegame.

   234

	 * @param size  the size of the variable (unused)

   235

	 * @param index the index of the object

   236

	 * @return the memory that is 'allocated'

   237

	 */

   238

	void *operator new(size_t size, int index)

   239

	{

   240

		if (!Tpool->AddBlockIfNeeded(index)) error("%s: failed loading savegame: too many %s", Tpool->GetName(), Tpool->GetName());

   241

   242

		return Tpool->Get(index);

   243

	}

   244

   245

	/**

   246

	 * 'Free' the memory allocated by the overriden new.

   247

	 * @param p     the memory to 'free'

   248

	 * @param index the original parameter given to create the memory

   249

	 * @note we only update Tpool->first_free_index

   250

	 */

   251

	void operator delete(void *p, int index)

   252

	{

   253

		Tpool->UpdateFirstFreeIndex(index);

   254

	}

   255

   256

	/**

   257

	 * An overriden version of new, so you can use the vehicle instance

   258

	 * instead of a newly allocated piece of memory.

   259

	 * @param size the size of the variable (unused)

   260

	 * @param pn   the already existing object to use as 'storage' backend

   261

	 * @return the memory that is 'allocated'

   262

	 */

   263

	void *operator new(size_t size, T *pn)

   264

	{

   265

		return pn;

   266

	}

   267

   268

	/**

   269

	 * 'Free' the memory allocated by the overriden new.

   270

	 * @param p  the memory to 'free'

   271

	 * @param pn the pointer that was given to 'new' on creation.

   272

	 * @note we only update Tpool->first_free_index

   273

	 */

   274

	void operator delete(void *p, T *pn)

   275

	{

   276

		Tpool->UpdateFirstFreeIndex(pn->index);

   277

	}

   278

   279

private:

   280

	static T *AllocateSafeRaw(uint &first);

   281

   282

protected:

   283

	/**

   284

	 * Allocate a pool item; possibly allocate a new block in the pool.

   285

	 * @return the allocated pool item (or NULL when the pool is full).

   286

	 */

   287

	static inline T *AllocateRaw()

   288

	{

   289

		return AllocateSafeRaw(Tpool->first_free_index);

   290

	}

   291

   292

	/**

   293

	 * Allocate a pool item; possibly allocate a new block in the pool.

   294

	 * @param first the first pool item to start searching

   295

	 * @return the allocated pool item (or NULL when the pool is full).

   296

	 */

   297

	static inline T *AllocateRaw(uint &first)

   298

	{

   299

		if (first >= Tpool->GetSize() && !Tpool->AddBlockToPool()) return NULL;

   300

   301

		return AllocateSafeRaw(first);

   302

	}

   303

   304

	/**

   305

	 * Are we cleaning this pool?

   306

	 * @return true if we are

   307

	 */

   308

	static inline bool CleaningPool()

   309

	{

   310

		return Tpool->CleaningPool();

   311

	}

   312

   313

public:

   314

	static bool CanAllocateItem(uint count = 1);

   315

};

   316

   317

   318

#define OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   319

	enum { \

   320

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   321

		name##_POOL_MAX_BLOCKS      = max_blocks \

   322

	};

   323

   324

   325

#define OLD_POOL_ACCESSORS(name, type) \

   326

	static inline type* Get##name(uint index) { return _##name##_pool.Get(index);  } \

   327

	static inline uint Get##name##PoolSize()  { return _##name##_pool.GetSize(); }

   328

   329

   330

#define DECLARE_OLD_POOL(name, type, block_size_bits, max_blocks) \

   331

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   332

	extern OldMemoryPool<type> _##name##_pool; \

   333

	OLD_POOL_ACCESSORS(name, type)

   334

   335

   336

#define DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \

   337

	OldMemoryPool<type> _##name##_pool( \

   338

		#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \

   339

		new_block_proc, clean_block_proc);

   340

   341

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   342

	OldMemoryPool<type> _##name##_pool( \

   343

		#name, name##_POOL_MAX_BLOCKS, name##_POOL_BLOCK_SIZE_BITS, sizeof(type), \

   344

		PoolNewBlock<type, &_##name##_pool>, PoolCleanBlock<type, &_##name##_pool>); \

   345

		template type *PoolItem<type, type##ID, &_##name##_pool>::AllocateSafeRaw(uint &first);

   346

   347

   348

#define STATIC_OLD_POOL(name, type, block_size_bits, max_blocks, new_block_proc, clean_block_proc) \

   349

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   350

	static DEFINE_OLD_POOL(name, type, new_block_proc, clean_block_proc) \

   351

	OLD_POOL_ACCESSORS(name, type)

   352

   353

#endif /* OLDPOOL_H */