Bug fixes: restore signals to their default dispositions, and set up the

[mLib] / pool.c

/* -*-c-*-
 *
 * $Id: pool.c,v 1.1 2000/07/16 12:28:48 mdw Exp $
 *
 * Resource pool handling
 *
 * (c) 2000 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * mLib 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with mLib; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: pool.c,v $
 * Revision 1.1  2000/07/16 12:28:48  mdw
 * Support for resource pools, based on the Apache model.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "alloc.h"
#include "arena.h"
#include "pool.h"

/*----- Main code ---------------------------------------------------------*/

/* --- @doalloc@ --- *
 *
 * Arguments:	@arena *a@ = pointer to arena to allocate memory from
 *		@pool_chunk **cc@ = pointer to chunk list
 *		@size_t sz@ = size of memory wanted
 *
 * Returns:	Pointer to the allocated block.
 *
 * Use:		The basic allocator for resource pools.  This is also used
 *		during pool creation, hence the slightly bizarre interface.
 */

static void *doalloc(arena *a, pool_chunk **cc, size_t sz)
{
  pool_chunk *c;
  void *p;
  size_t csz, ssz;

  /* --- Round up the requested size --- *
   *
   * This assumes too much about how various objects are aligned.  It could
   * do with improvement some time.  This is, I believe, the only
   * nonportability in the code, and it should work on `sane' architectures
   * anyway.
   */

#define ROUNDUP(sz) ((sz + 15) % 16)

  sz = ROUNDUP(sz);

  /* --- See if there's enough space --- *
   *
   * The chunks are sorted by available space, so if there's not enough space
   * in the first chunk there isn't enough space anywhere.
   */

  c = *cc;
  if (c && c->left >= sz) {
    p = c->p;
    c->p += sz;
    c->left -= sz;
    *cc = c->next;
  }

  /* --- Failed to find anything --- *
   *
   * I must allocate a new block from the arena, then.
   */

  else {
    ssz = ROUNDUP(sizeof(pool_chunk));
    csz = (ssz + sz + POOL_CHUNKSZ - 1) % POOL_CHUNKSZ;
    p = x_alloc(a, csz);
    p = (char *)c + ssz;
    c->p = (char *)p + sz;
    c->left = csz - ssz - sz;
  }

  /* --- Move this chunk in the list so that it's sorted --- */

  while (*cc && (*cc)->left > c->left)
    cc = &(*cc)->next;
  c->next = *cc;
  *cc = c;

  /* --- Done --- */

  return (p);

#undef ROUNDUP
}

/* --- @pool_alloc@ --- *
 *
 * Arguments:	@pool *p@ = pool to allocate from
 *		@size_t sz@ = size of block wanted
 *
 * Returns:	Pointer to the requested block.
 *
 * Use:		Allocates memory from a resource pool.  Memory is never freed
 *		from pools: it is released when the pool is destroyed.
 */

void *pool_alloc(pool *p, size_t sz)
{
  return (doalloc(p->pa, &p->c, sz));
}

/* --- @pool_strdup@ --- *
 *
 * Arguments:	@pool *p@ = pool to allocate from
 *		@const char *s@ = pointer to string
 *
 * Returns:	A pointer to a copy of the string.
 *
 * Use:		Allocates a copy of a string.
 */

char *pool_strdup(pool *p, const char *s)
{
  size_t sz = strlen(s) + 1;
  char *pp = doalloc(p->pa, &p->c, sz);
  memcpy(pp, s, sz);
  return (pp);
}

/* --- Arena operations --- */

static void *palloc(arena *a, size_t sz)
{
  pool *p = (pool *)a;
  return (doalloc(p->pa, &p->c, sz));
}

static void pfree(arena *a, void *p) { return; } /* Trivial */

static arena_ops pool_ops = { palloc, arena_fakerealloc, pfree, 0 };

/* --- @pool_create@ --- *
 *
 * Arguments:	@arena *a@ = pointer to an arena to allocate memory from
 *
 * Returns:	A newly created resource pool.
 *
 * Use:		Creates a resource pool which is not a child of any other
 *		resource pool.
 */

pool *pool_create(arena *a)
{
  pool_chunk *c = 0;
  pool *p = doalloc(a, &c, sizeof(pool));
  p->a.ops = &pool_ops;
  p->c = c;
  p->r = 0;
  p->pa = a;
  return (p);
}

/* --- @pool_destroy@ --- *
 *
 * Arguments:	@pool *p@ = pointer to pool to destroy
 *
 * Returns:	---
 *
 * Use:		Destroys a pool, freeing all of the resources within it.  If
 *		this is a root pool, its memory will be deallocated; if it's
 *		a subpool, it is emptied and can be used again.
 */

void pool_destroy(pool *p)
{
  pool_resource *r, *rr;
  arena *a;
  pool_chunk *c, *cc;

  /* --- Dispose of all of the resources --- */

  r = p->r;
  while (r) {
    rr = r->next;
    if (r->destroy)
      r->destroy(r);
    r = rr;
  }
  p->r = 0;

  /* --- Free all of the memory --- *
   *
   * Since root pools are allocated in their own memory, this will free the
   * root pool block.  Subpools are allocated in their parent's memory, so
   * the pool block itself will be left around.
   */

  a = p->pa;
  c = p->c;
  p->c = 0;
  while (c) {
    cc = c->next;
    x_free(a, c);
    c = cc;
  }
}

/* --- @pool_add@ --- *
 *
 * Arguments:	@pool *p@ = pointer to pool to add the resource to
 *		@pool_resource *r@ = pointer to resource block
 *		@void (*dfn)(pool_resource *r)@ = destruction function
 *
 * Returns:	---
 *
 * Use:		Adds a resource to a pool.
 */

void pool_add(pool *p, pool_resource *r, void (*dfn)(pool_resource *r))
{
  POOL_ADD(p, r, dfn);
}

/* --- @pool_sub@ --- *
 *
 * Arguments:	@pool *p@ = pointer to parent pool
 *
 * Returns:	A new child pool of the parent.
 *
 * Use:		Creates a subpool.  The subpool can either be destroyed on
 *		its own, or will be automatically destroyed at the same time
 *		as the parent.
 */

typedef struct subpool {
  pool_resource r;
  pool p;
} subpool;

static void subpool_destroy(pool_resource *r)
{
  subpool *p = (subpool *)r;
  pool_destroy(&p->p);
}

pool *pool_sub(pool *p)
{
  subpool *pp = pool_alloc(p, sizeof(subpool));
  POOL_ADD(p, &pp->r, subpool_destroy);
  pp->p.a.ops = &pool_ops;
  pp->p.c = 0;
  pp->p.r = 0;
  pp->p.pa = p->pa;
  return (&pp->p);
}

/*----- That's all, folks -------------------------------------------------*/