1

/* $Id$ */

     2

     3

/** @file oldpool.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "oldpool.h"

    10

#include "helpers.hpp"

    11

    12

/**

    13

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

    14

 */

    15

void CleanPool(OldMemoryPool *pool)

    16

{

    17

	uint i;

    18

    19

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

    20

    21

	/* Free all blocks */

    22

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

    23

		if (pool->clean_block_proc != NULL) {

    24

			pool->clean_block_proc(i * (1 << pool->block_size_bits), (i + 1) * (1 << pool->block_size_bits) - 1);

    25

		}

    26

		free(pool->blocks[i]);

    27

	}

    28

    29

	/* Free the block itself */

    30

	free(pool->blocks);

    31

    32

	/* Clear up some critical data */

    33

	pool->total_items = 0;

    34

	pool->current_blocks = 0;

    35

	pool->blocks = NULL;

    36

}

    37

    38

/**

    39

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

    40

 *  1 block too it

    41

 *

    42

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

    43

 */

    44

bool AddBlockToPool(OldMemoryPool *pool)

    45

{

    46

	/* Is the pool at his max? */

    47

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

    48

		return false;

    49

    50

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

    51

    52

	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);

    53

    54

	/* Increase the poolsize */

    55

	pool->blocks = ReallocT(pool->blocks, pool->current_blocks + 1);

    56

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

    57

    58

	/* Allocate memory to the new block item */

    59

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

    60

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

    61

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

    62

    63

	/* Clean the content of the new block */

    64

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

    65

    66

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

    67

	if (pool->new_block_proc != NULL)

    68

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

    69

    70

	/* We have a new block */

    71

	pool->current_blocks++;

    72

    73

	return true;

    74

}

    75

    76

/**

    77

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

    78

 *

    79

 * @return Returns false if adding failed

    80

 */

    81

bool AddBlockIfNeeded(OldMemoryPool *pool, uint index)

    82

{

    83

	while (index >= pool->total_items) {

    84

		if (!AddBlockToPool(pool))

    85

			return false;

    86

	}

    87

    88

	return true;

    89

}