1

/* $Id$ */

     2

     3

/** @file oldpool.h */

     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

/**

   160

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

   161

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

   162

 */

   163

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

   164

struct PoolItem {

   165

	/**

   166

	 * The pool-wide index of this object.

   167

	 */

   168

	Tid index;

   169

   170

	/**

   171

	 * We like to have the correct class destructed.

   172

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

   173

	 *          so it is not present in the TPool!

   174

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

   175

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

   176

	 */

   177

	virtual ~PoolItem()

   178

	{

   179

   180

	}

   181

   182

	/**

   183

	 * Constructor of given class.

   184

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

   185

	 *          so it may not be present in TPool!

   186

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

   187

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

   188

	 */

   189

	PoolItem()

   190

	{

   191

   192

	}

   193

   194

	/**

   195

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

   196

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

   197

	 * @return the memory that is 'allocated'

   198

	 */

   199

	void *operator new(size_t size)

   200

	{

   201

		return AllocateRaw();

   202

	}

   203

   204

	/**

   205

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

   206

	 * @param p the memory to 'free'

   207

	 * @note we only update Tpool->first_free_index

   208

	 */

   209

	void operator delete(void *p)

   210

	{

   211

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

   212

	}

   213

   214

	/**

   215

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

   216

	 * the correct index when one is loading the savegame.

   217

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

   218

	 * @param index the index of the object

   219

	 * @return the memory that is 'allocated'

   220

	 */

   221

	void *operator new(size_t size, int index)

   222

	{

   223

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

   224

   225

		return Tpool->Get(index);

   226

	}

   227

   228

	/**

   229

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

   230

	 * @param p     the memory to 'free'

   231

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

   232

	 * @note we only update Tpool->first_free_index

   233

	 */

   234

	void operator delete(void *p, int index)

   235

	{

   236

		Tpool->UpdateFirstFreeIndex(index);

   237

	}

   238

   239

	/**

   240

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

   241

	 * instead of a newly allocated piece of memory.

   242

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

   243

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

   244

	 * @return the memory that is 'allocated'

   245

	 */

   246

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

   247

	{

   248

		return pn;

   249

	}

   250

   251

	/**

   252

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

   253

	 * @param p  the memory to 'free'

   254

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

   255

	 * @note we only update Tpool->first_free_index

   256

	 */

   257

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

   258

	{

   259

		Tpool->UpdateFirstFreeIndex(pn->index);

   260

	}

   261

   262

private:

   263

	static T *AllocateSafeRaw(uint &first);

   264

   265

protected:

   266

	/**

   267

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

   268

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

   269

	 */

   270

	static inline T *AllocateRaw()

   271

	{

   272

		return AllocateSafeRaw(Tpool->first_free_index);

   273

	}

   274

   275

	/**

   276

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

   277

	 * @param first the first pool item to start searching

   278

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

   279

	 */

   280

	static inline T *AllocateRaw(uint &first)

   281

	{

   282

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

   283

   284

		return AllocateSafeRaw(first);

   285

	}

   286

   287

	/**

   288

	 * Are we cleaning this pool?

   289

	 * @return true if we are

   290

	 */

   291

	static inline bool CleaningPool()

   292

	{

   293

		return Tpool->CleaningPool();

   294

	}

   295

   296

public:

   297

	static bool CanAllocateItem();

   298

};

   299

   300

   301

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

   302

	enum { \

   303

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   304

		name##_POOL_MAX_BLOCKS      = max_blocks \

   305

	};

   306

   307

   308

#define OLD_POOL_ACCESSORS(name, type) \

   309

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

   310

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

   311

   312

   313

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

   314

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   315

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

   316

	OLD_POOL_ACCESSORS(name, type)

   317

   318

   319

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

   320

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

   321

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

   322

		new_block_proc, clean_block_proc);

   323

   324

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   325

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

   326

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

   327

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

   328

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

   329

   330

   331

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

   332

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   333

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

   334

	OLD_POOL_ACCESSORS(name, type)

   335

   336

#endif /* OLDPOOL_H */