1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "functions.h"

     5

#include "pool.h"

     6

     7

/**

     8

 * Clean a pool in a safe way (does free all blocks)

     9

 */

    10

void CleanPool(MemoryPool *pool)

    11

{

    12

	uint i;

    13

    14

	DEBUG(misc, 4)("[Pool] (%s) Cleaning pool..", pool->name);

    15

    16

	/* Free all blocks */

    17

	for (i = 0; i < pool->current_blocks; i++)

    18

		free(pool->blocks[i]);

    19

    20

	/* Free the block itself */

    21

	free(pool->blocks);

    22

    23

	/* Clear up some critical data */

    24

	pool->total_items = 0;

    25

	pool->current_blocks = 0;

    26

	pool->blocks = NULL;

    27

}

    28

    29

/**

    30

 * This function tries to increase the size of array by adding

    31

 *  1 block too it

    32

 *

    33

 * @return Returns false if the pool could not be increased

    34

 */

    35

bool AddBlockToPool(MemoryPool *pool)

    36

{

    37

	/* Is the pool at his max? */

    38

	if (pool->max_blocks == pool->current_blocks)

    39

		return false;

    40

    41

	pool->total_items = (pool->current_blocks + 1) * (1 << pool->block_size_bits);

    42

    43

	DEBUG(misc, 4)("[Pool] (%s) Increasing size of pool to %d items (%d bytes)", pool->name, pool->total_items, pool->total_items * pool->item_size);

    44

    45

	/* Increase the poolsize */

    46

	pool->blocks = realloc(pool->blocks, sizeof(pool->blocks[0]) * (pool->current_blocks + 1));

    47

	if (pool->blocks == NULL)

    48

		error("Pool: (%s) could not allocate memory for blocks", pool->name);

    49

    50

	/* Allocate memory to the new block item */

    51

	pool->blocks[pool->current_blocks] = malloc(pool->item_size * (1 << pool->block_size_bits));

    52

	if (pool->blocks[pool->current_blocks] == NULL)

    53

		error("Pool: (%s) could not allocate memory for blocks", pool->name);

    54

    55

	/* Clean the content of the new block */

    56

	memset(pool->blocks[pool->current_blocks], 0, pool->item_size * (1 << pool->block_size_bits));

    57

    58

	/* Call a custom function if defined (e.g. to fill indexes) */

    59

	if (pool->new_block_proc != NULL)

    60

		pool->new_block_proc(pool->current_blocks * (1 << pool->block_size_bits));

    61

    62

	/* We have a new block */

    63

	pool->current_blocks++;

    64

    65

	return true;

    66

}

    67

    68

/**

    69

 * Adds blocks to the pool if needed (and possible) till index fits inside the pool

    70

 *

    71

 * @return Returns false if adding failed

    72

 */

    73

bool AddBlockIfNeeded(MemoryPool *pool, uint index)

    74

{

    75

	while (index >= pool->total_items) {

    76

		if (!AddBlockToPool(pool))

    77

			return false;

    78

	}

    79

    80

	return true;

    81

}