/* 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, 2011 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 */