include/mempool.h

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#ifndef MEMPOOL_H
#define MEMPOOL_H

#define MEMPOOL_TRACKING

/*#define MEMPOOL_OBJECT_TRACKING*/

struct mempool_chunk
{
    /* This struct must always be padded for longword alignment of the data coming behind it.
     * Not a problem as long as we only keep a single pointer here, but be careful
     * if adding more data. */

    struct mempool_chunk *next;

#ifdef MEMPOOL_OBJECT_TRACKING

    struct mempool_chunk *obj_prev;

    struct mempool_chunk *obj_next;

    uint32 flags;

    uint32 pool_id;

    uint32 id;
#endif
};

/* Optional initialisator to be called when expanding */
typedef void (*chunk_initialisator) (void *ptr);
/* Optional deinitialisator to be called when freeing */
typedef void (*chunk_deinitialisator) (void *ptr);
/* Optional constructor to be called when getting chunks */
typedef void (*chunk_constructor) (void *ptr);
/* Optional destructor to be called when returning chunks */
typedef void (*chunk_destructor) (void *ptr);

/* Definitions used for array handling */
#define MEMPOOL_NROF_FREELISTS 8
/* = 256 if NROF_FREELISTS == 8 */
#define MEMPOOL_MAX_ARRAYSIZE (1 << MEMPOOL_NROF_FREELISTS)

struct mempool
{
    const char *chunk_description;

    uint32 expand_size;

    uint32 chunksize;

    uint32 flags;

    chunk_initialisator initialisator;

    chunk_deinitialisator deinitialisator;

    chunk_constructor constructor;

    chunk_destructor destructor;

    struct mempool_chunk *freelist[MEMPOOL_NROF_FREELISTS];

    uint32 nrof_free[MEMPOOL_NROF_FREELISTS];

    uint32 nrof_allocated[MEMPOOL_NROF_FREELISTS];
#ifdef MEMPOOL_TRACKING

    struct puddle_info *first_puddle_info;
#endif
};

#ifdef MEMPOOL_TRACKING

struct puddle_info
{
    struct puddle_info *next;

    struct mempool_chunk *first_chunk;

    struct mempool_chunk *first_free;

    struct mempool_chunk *last_free;

    uint32 nrof_free;
};

extern struct mempool *pool_puddle;
#endif

#define MAX_NROF_MEMPOOLS 32

#define MEM_POOLDATA(ptr) (((struct mempool_chunk *)(ptr)) - 1)

#define MEM_USERDATA(ptr) ((void *)(((struct mempool_chunk *)(ptr)) + 1))

#define CHUNK_FREE(ptr) (MEM_POOLDATA(ptr)->next != NULL)

#define MEMPOOL_ALLOW_FREEING 1

#define MEMPOOL_BYPASS_POOLS  2

extern struct mempool *mempools[];
extern struct mempool_chunk end_marker;
extern struct mempool *pool_object, *pool_objectlink, *pool_player, *pool_bans, *pool_parties;
extern int nrof_mempools;

#define get_poolchunk(_pool_) get_poolchunk_array_real((_pool_), 0)
#define get_poolarray(_pool_, _arraysize_) get_poolchunk_array_real((_pool_), nearest_pow_two_exp(_arraysize_))

#define return_poolchunk(_data_, _pool_) return_poolchunk_array_real((_data_), 0, (_pool_))
#define return_poolarray(_data_, _arraysize_, _pool_) return_poolchunk_array_real((_data_), nearest_pow_two_exp(_arraysize_), (_pool_))

#endif