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 OldMemoryPoolBase::CleanPool()

    16

{

    17

	uint i;

    18

    19

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

    20

    22

	/* Free all blocks */

    23

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

    24

		if (this->clean_block_proc != NULL) {

    25

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

    26

		}

    27

		free(this->blocks[i]);

    28

	}

    30

    31

	/* Free the block itself */

    32

	free(this->blocks);

    33

    34

	/* Clear up some critical data */

    35

	this->total_items = 0;

    36

	this->current_blocks = 0;

    37

	this->blocks = NULL;

    38

	this->first_free_index = 0;

    39

}

    40

    41

/**

    42

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

    43

 *  1 block too it

    44

 *

    45

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

    46

 */

    47

bool OldMemoryPoolBase::AddBlockToPool()

    48

{

    49

	/* Is the pool at his max? */

    50

	if (this->max_blocks == this->current_blocks) return false;

    51

    52

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

    53

    54

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

    55

    56

	/* Increase the poolsize */

    57

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

    58

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

    59

    60

	/* Allocate memory to the new block item */

    61

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

    62

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

    63

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

    64

    65

	/* Clean the content of the new block */

    66

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

    67

    68

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

    69

	if (this->new_block_proc != NULL) this->new_block_proc(this->current_blocks * (1 << this->block_size_bits));

    70

    71

	/* We have a new block */

    72

	this->current_blocks++;

    73

    74

	return true;

    75

}

    76

    77

/**

    78

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

    79

 *

    80

 * @return Returns false if adding failed

    81

 */

    82

bool OldMemoryPoolBase::AddBlockIfNeeded(uint index)

    83

{

    84

	while (index >= this->total_items) {

    85

		if (!this->AddBlockToPool()) return false;

    86

	}

    87

    88

	return true;

    89

}