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

	/**

   264

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

   265

	 * @param first the first pool item to start searching

   266

	 * @pre first <= Tpool->GetSize()

   267

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

   268

	 */

   269

	static inline T *AllocateSafeRaw(uint &first)

   270

	{

   271

		uint last_minus_one = Tpool->GetSize() - 1;

   272

   273

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

   274

			if (!t->IsValid()) {

   275

				first = t->index;

   276

				Tid index = t->index;

   277

   278

				memset(t, 0, Tpool->item_size);

   279

				t->index = index;

   280

				return t;

   281

			}

   282

		}

   283

   284

		/* Check if we can add a block to the pool */

   285

		if (Tpool->AddBlockToPool()) return AllocateRaw(first);

   286

   287

		return NULL;

   288

	}

   289

   290

protected:

   291

	/**

   292

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

   293

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

   294

	 */

   295

	static inline T *AllocateRaw()

   296

	{

   297

		return AllocateSafeRaw(Tpool->first_free_index);

   298

	}

   299

   300

	/**

   301

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

   302

	 * @param first the first pool item to start searching

   303

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

   304

	 */

   305

	static inline T *AllocateRaw(uint &first)

   306

	{

   307

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

   308

   309

		return AllocateSafeRaw(first);

   310

	}

   311

   312

	/**

   313

	 * Are we cleaning this pool?

   314

	 * @return true if we are

   315

	 */

   316

	static inline bool CleaningPool()

   317

	{

   318

		return Tpool->CleaningPool();

   319

	}

   342

};

   343

   344

   345

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

   346

	enum { \

   347

		name##_POOL_BLOCK_SIZE_BITS = block_size_bits, \

   348

		name##_POOL_MAX_BLOCKS      = max_blocks \

   349

	};

   350

   351

   352

#define OLD_POOL_ACCESSORS(name, type) \

   353

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

   354

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

   355

   356

   357

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

   358

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   359

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

   360

	OLD_POOL_ACCESSORS(name, type)

   361

   362

   363

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

   364

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

   365

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

   366

		new_block_proc, clean_block_proc);

   367

   368

#define DEFINE_OLD_POOL_GENERIC(name, type) \

   369

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

   370

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

   371

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

   372

   373

   374

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

   375

	OLD_POOL_ENUM(name, type, block_size_bits, max_blocks) \

   376

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

   377

	OLD_POOL_ACCESSORS(name, type)

   378

   379

#endif /* OLDPOOL_H */