/* glpdmp.c (dynamic memory pool) */

 /***********************************************************************

 *  This code is part of GLPK (GNU Linear Programming Kit).

 *

 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,

 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.

 *  E-mail: <mao@gnu.org>.

 *

 *  GLPK 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 3 of the License, or

 *  (at your option) any later version.

 *

 *  GLPK 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 GLPK. If not, see <http://www.gnu.org/licenses/>.

 ***********************************************************************/

 #include "glpdmp.h"

 #if 1 /* 29/VIII-2008 */

 /* some processors need data to be properly aligned; the macro

    align_datasize enlarges the specified size of a data item to provide

    a proper alignment of immediately following data */

 #define align_datasize(size) ((((size) + 7) / 8) * 8)

 /* 8 bytes is sufficient in both 32- and 64-bit environments */

 #endif

 #ifdef GLP_DEBUG

 struct info

 {     DMP *pool;

       int size;

 };

 #endif

 /***********************************************************************

 *  NAME

 *

 *  dmp_create_pool - create dynamic memory pool

 *

 *  SYNOPSIS

 *

 *  #include "glpdmp.h"

 *  DMP *dmp_create_pool(void);

 *

 *  DESCRIPTION

 *

 *  The routine dmp_create_pool creates a dynamic memory pool.

 *

 *  RETURNS

 *

 *  The routine returns a pointer to the memory pool created. */

 DMP *dmp_create_pool(void)

 {     DMP *pool;

       int k;

 #ifdef GLP_DEBUG

       xprintf("dmp_create_pool: warning: debug mode enabled\n");

 #endif

       pool = xmalloc(sizeof(DMP));

 #if 0

       pool->size = 0;

 #endif

       for (k = 0; k <= 31; k++) pool->avail[k] = NULL;

       pool->block = NULL;

       pool->used = DMP_BLK_SIZE;

       pool->count.lo = pool->count.hi = 0;

       return pool;

 }

 /***********************************************************************

 *  NAME

 *

 *  dmp_get_atom - get free atom from dynamic memory pool

 *

 *  SYNOPSIS

 *

 *  #include "glpdmp.h"

 *  void *dmp_get_atom(DMP *pool, int size);

 *

 *  DESCRIPTION

 *

 *  The routine dmp_get_atom obtains a free atom (memory block) from the

 *  specified memory pool.

 *

 *  The parameter size is the atom size, in bytes, 1 <= size <= 256.

 *

 *  Note that the free atom contains arbitrary data, not binary zeros.

 *

 *  RETURNS

 *

 *  The routine returns a pointer to the free atom obtained. */

 void *dmp_get_atom(DMP *pool, int size)

 {     void *atom;

       int k;

 #ifdef GLP_DEBUG

       int orig_size = size;

 #endif

       if (!(1 <= size && size <= 256))

          xerror("dmp_get_atom: size = %d; invalid atom size\n", size);

 #if 0

       if (!(pool->size == 0 || pool->size == size))

          xerror("dmp_get_atom: size = %d; wrong atom size\n", size);

 #endif

       /* adjust the size to provide the proper data alignment */

       size = align_datasize(size);

 #ifdef GLP_DEBUG

       size += align_datasize(sizeof(struct info));

 #endif

       /* adjust the size to make it multiple of 8 bytes, if needed */

       size = ((size + 7) / 8) * 8;

       /* determine the corresponding list of free cells */

       k = size / 8 - 1;

       xassert(0 <= k && k <= 31);

       /* obtain a free atom */

       if (pool->avail[k] == NULL)

       {  /* the list of free cells is empty */

          if (pool->used + size > DMP_BLK_SIZE)

          {  /* allocate a new memory block */

             void *block = xmalloc(DMP_BLK_SIZE);

             *(void **)block = pool->block;

             pool->block = block;

             pool->used = align_datasize(sizeof(void *));

          }

          /* place the atom in the current memory block */

          atom = (char *)pool->block + pool->used;

          pool->used += size;

       }

       else

       {  /* obtain the atom from the list of free cells */

          atom = pool->avail[k];

          pool->avail[k] = *(void **)atom;

       }

       memset(atom, '?', size);

       /* increase the number of atoms which are currently in use */

       pool->count.lo++;

       if (pool->count.lo == 0) pool->count.hi++;

 #ifdef GLP_DEBUG

       ((struct info *)atom)->pool = pool;

       ((struct info *)atom)->size = orig_size;

       atom = (char *)atom + align_datasize(sizeof(struct info));

 #endif

       return atom;

 }

 /***********************************************************************

 *  NAME

 *

 *  dmp_free_atom - return atom to dynamic memory pool

 *

 *  SYNOPSIS

 *

 *  #include "glpdmp.h"

 *  void dmp_free_atom(DMP *pool, void *atom, int size);

 *

 *  DESCRIPTION

 *

 *  The routine dmp_free_atom returns the specified atom (memory block)

 *  to the specified memory pool, making it free.

 *

 *  The parameter size is the atom size, in bytes, 1 <= size <= 256.

 *

 *  Note that the atom can be returned only to the pool, from which it

 *  was obtained, and its size must be exactly the same as on obtaining

 *  it from the pool. */

 void dmp_free_atom(DMP *pool, void *atom, int size)

 {     int k;

       if (!(1 <= size && size <= 256))

          xerror("dmp_free_atom: size = %d; invalid atom size\n", size);

 #if 0

       if (!(pool->size == 0 || pool->size == size))

          xerror("dmp_free_atom: size = %d; wrong atom size\n", size);

 #endif

       if (pool->count.lo == 0 && pool->count.hi == 0)

          xerror("dmp_free_atom: pool allocation error\n");

 #ifdef GLP_DEBUG

       atom = (char *)atom - align_datasize(sizeof(struct info));

       xassert(((struct info *)atom)->pool == pool);

       xassert(((struct info *)atom)->size == size);

 #endif

       /* adjust the size to provide the proper data alignment */

       size = align_datasize(size);

 #ifdef GLP_DEBUG

       size += align_datasize(sizeof(struct info));

 #endif

       /* adjust the size to make it multiple of 8 bytes, if needed */

       size = ((size + 7) / 8) * 8;

       /* determine the corresponding list of free cells */

       k = size / 8 - 1;

       xassert(0 <= k && k <= 31);

       /* return the atom to the list of free cells */

       *(void **)atom = pool->avail[k];

       pool->avail[k] = atom;

       /* decrease the number of atoms which are currently in use */

       pool->count.lo--;

       if (pool->count.lo == 0xFFFFFFFF) pool->count.hi--;

       return;

 }

 /***********************************************************************

 *  NAME

 *

 *  dmp_in_use - determine how many atoms are still in use

 *

 *  SYNOPSIS

 *

 *  #include "glpdmp.h"

 *  glp_long dmp_in_use(DMP *pool);

 *

 *  DESCRIPTION

 *

 *  The routine dmp_in_use determines how many atoms allocated from the

 *  specified memory pool with the routine dmp_get_atom are still in use,

 *  i.e. not returned to the pool with the routine dmp_free_atom.

 *

 *  RETURNS

 *

 *  The routine returns the number of atoms which are still in use. */

 glp_long dmp_in_use(DMP *pool)

 {     return

          pool->count;

 }

 /***********************************************************************

 *  NAME

 *

 *  dmp_delete_pool - delete dynamic memory pool

 *

 *  SYNOPSIS

 *

 *  #include "glpdmp.h"

 *  void dmp_delete_pool(DMP *pool);

 *

 *  DESCRIPTION

 *

 *  The routine dmp_delete_pool deletes the specified dynamic memory

 *  pool and frees all the memory allocated to this object. */

 void dmp_delete_pool(DMP *pool)

 {     while (pool->block != NULL)

       {  void *block = pool->block;

          pool->block = *(void **)block;

          xfree(block);

       }

       xfree(pool);

       return;

 }

 /* eof */