Logo Search packages:      
Sourcecode: zmailer version File versions  Download package

listmalloc.c

/*
 * ZMailer router LISPic memory allocator routines by Matti Aarnio
 * <mea@nic.funet.fi>  Copyright 1996, 1998, 1999
 *
 * LISPish memory object allocation routines.  We keep  conscells  in
 * bucket arrays for ease of finding them for the Deutch-Schorr-Waite
 * garbage collector (and to minimize malloc overheads..)
 */

#include "hostenv.h"
#include "listutils.h"

#ifdef CELLDEBUG
#define DEBUG
#endif

#ifndef __GNUC__x
#define __inline__ /* nothing for non-GCC */
#endif

int D_conscell = 0;

/*
 * We allocate conscells in set of blocks, where we do garbage collections
 * at every N requests, or other trigger criteria..
 * Strings are allocated with malloc(), and explicitely freed at garbage
 * collection of unused cells.
 * Free cells are collected into a chain of free cells (via next ptr),
 * from which they are picked into use.
 */
typedef struct consblock {
    struct consblock *nextblock;
    int cellcount;
    conscell cells[1];        /* Array of ``cellcount'' cells */
} consblock;

#ifndef NO_CONSVARS
/*
 * Variable pointers -- arrays of pointers to conscells
 */
typedef struct consvarptrs {
    struct consvarptrs *nextvars;
    int count;                /* large (?) sets of vars */
    int first;                /* this block has vars of indices
                           ``first .. first+count-1'' */
    conscell **vars[1];       /* Address of an variable */
} consvarptrs;
#endif


#define NSTATICVARS 16 /* SHOULD be enough for ZMailer...  */
static conscell **staticvec[NSTATICVARS] = { NULL };
static int staticidx = 0;


static void (*functionvec[NSTATICVARS])__((void (*gcmarkupfunc)(conscell *))) = { NULL };

static int functionidx = 0;

/* Put an entry in staticvec, pointing at the variable
   whose address is given */

void staticprot (varaddress)
conscell **varaddress;
{
      staticvec[staticidx++] = varaddress;
      if (staticidx >= NSTATICVARS)
        abort (); /* TOO MANY!  Should need only very few.. */
}

void functionprot (funcaddress)
     void (*funcaddress)__((void(*mrkupfunc)(conscell *)));
{
      functionvec[functionidx++] = funcaddress;
      if (functionidx >= NSTATICVARS)
        abort();  /* TOO MANY!  Should need only very few.. */
}


/*
 * Some book-keeping variables, and one of GC-trigger counters
 */
int consblock_cellcount = 8000;     /* Optimizable for different systems.
                           Alphas have 8kB pages, and most others
                           have 4kB pages.. */
int newcell_gc_interval = 8000;     /* Number of newcell() calls before GC */
int newcell_gc_callcount = 0; /* ... trigger-count of those calls ... */
int newcell_callcount = 0;    /* ... cumulative count of those calls ... */

long newcell_gc_freecount = 0;
long newcell_gc_freestrcount = 0;
long newcell_gc_dupnstrcount = 0;
long newcell_gc_strusecnt = 0;


consblock *consblock_root = NULL;
consblock *consblock_tail = NULL;
conscell *conscell_freechain = NULL;      /* pick first .. */
int consblock_count = 0;      /* How many allocated ? */

struct gcpro *gcprolist = NULL;     /* Dynamically growing list of protected
                           items.. */
#ifndef NO_CONSVARS
int consvars_cellcount = 4000;
consvarptrs *consvars_root = NULL;
consvarptrs *consvars_tail = NULL;
long consvars_cursor = 0;     /* How many variables are in use ?
                           Actually NOT direct pointer, and
                           the user might have to traverse
                           the chains a bit at first.. */
consvarptrs *consvars_markptr = NULL;     /* For speedier insert */
int consvars_count = 0;       /* Allocation count */
#endif

static consblock *new_consblock __((void));
static consblock *new_consblock()
{
    consblock *new;
    int i;
    int newsize = (sizeof(consblock) +
               sizeof(conscell) * (consblock_cellcount - 1));

    if (D_conscell)
      fprintf(stderr,"new_consblock(%d cells)\n", consblock_cellcount);

    new = (consblock *) calloc(1,newsize); /* clearing malloc */
    if (!new)
      return NULL;

    new->cellcount = consblock_cellcount;
    new->nextblock = NULL;
    if (consblock_root == NULL)
      consblock_root = new;
    else
      consblock_tail->nextblock = new;
    consblock_tail = new;

    /* chain them together, and prepend to the free chain via ``next'' */
    new->cells[0].next = conscell_freechain;
    new->cells[0].flags = DSW_FREEMARK;
    for (i = 1; i < consblock_cellcount; ++i) {
      new->cells[i].next = &new->cells[i - 1];
      new->cells[i].flags = DSW_FREEMARK;
    }
    conscell_freechain = &new->cells[consblock_cellcount - 1];

    ++consblock_count;
    return new;
}

#ifndef NO_CONSVARS
static consvarptrs *new_consvars __((int));
static consvarptrs *new_consvars(first)
int first;
{
    consvarptrs *new;
    int newsize = (sizeof(consvarptrs) +
               sizeof(conscell *) * (consvars_cellcount - 1));

    if (D_conscell)
      fprintf(stderr,"new_consvars(first=%d; %d varcells)\n", first, consvars_cellcount);

    new = (consvarptrs *) malloc(newsize);
    if (!new)
      return NULL;

    new->first = first;
    new->count = consvars_cellcount;
    new->nextvars = NULL;
    if (consvars_root == NULL) {
      consvars_root = new;
      consvars_markptr = new;
    } else
      consvars_tail->nextvars = new;
    consvars_tail = new;
    ++consvars_count;
    return new;
}

void *consvar_mark()
{
    if (D_conscell)
      fprintf(stderr,"consvar_marker() returns %p\n", (void*)consvars_cursor);
    return (void *)consvars_cursor;
}

void consvar_release(marker)
void *marker;
{
    long newmark = (long) marker;

    if (newmark > consvars_cursor) {
      abort();    /* XX: Something seriously wrong, release INCREASED
                   the count of variables! */
    }
    consvars_cursor = newmark;
    --newmark;       /* change into index -- from counter (sort of) */

    if (consvars_markptr == NULL)
      return;        /* no cells ? */

    if ((consvars_markptr->first <= newmark) &&
      (newmark < (consvars_markptr->first + consvars_markptr->count)))
      return;        /* The markptr is ok */

    /* Lookup for the block marker */
    consvars_markptr = consvars_root;
    while (consvars_markptr && newmark < consvars_markptr->first) {
      consvars_markptr = consvars_markptr->nextvars;
    }
}


/* ConsCell variable pointer registry */
int consvar_register(varptr)
     conscell **varptr;
{
    int marklast, idx;

    if (D_conscell)
      fprintf(stderr,"consvar_register(varptr=%p)\n", varptr);

    if (consvars_root == NULL) {
      if (new_consvars(0) == NULL)
          return -1;
      consvars_cursor = 0;
    }
    marklast = (consvars_markptr->first +
            consvars_markptr->count);
    ++consvars_cursor;
    if (marklast <= consvars_cursor) {
      if (consvars_markptr->nextvars == NULL)
          consvars_markptr = new_consvars(marklast    /* the previous last is
                                             the next first.. */ );
      else
          consvars_markptr = consvars_markptr->nextvars;
      if (consvars_markptr == NULL)
          return -1;
    }
    idx = (consvars_cursor - 1) - consvars_markptr->first;
    consvars_markptr->vars[idx] = varptr;
    return 0;                 /* Stored ok.. */
}
#endif

/*
 *  Deutch-Schorr-Waite garbage collection routine of the conscells..
 *
 */
static void cons_DSW __((conscell *source));

int deepest_dsw = 0;

static void _cons_DSW(source, depth)
volatile conscell *source;
int depth;
{
      /* Use stack to descend CAR, scan thru CDR.
         The trick is that there should not be deep
         layers in the CAR branch (a sign of error
         in fact if there are!), but CDR can be long. */

      conscell *current = (conscell*)source;
      volatile int cdrcnt = 0; /* These volatilities are for
                            debugging uses to forbid gcc
                            from removing the variable
                            as unnecessary during its
                            lifetime.. */

      if (depth > deepest_dsw)
            deepest_dsw = depth;
      if (depth > 20) *(long*)0 = 0; /* ZAP! */
      while (current && !(current->flags & DSW_MARKER)) {
            current->flags |= DSW_MARKER;
            if (!STRING(current))
                  _cons_DSW(car(current),depth+1);
            current = cdr(current);
            ++cdrcnt;
      }
}

static void cons_DSW(source)
conscell *source;
{
  /* Use stack to descend CAR, scan thru CDR */

  _cons_DSW(source,1);
}

int cons_garbage_collect()
{
    int i, freecnt, usecnt, strusecnt, newfreecnt;
    consblock *cb = NULL;
    conscell *cc, **freep;
    struct gcpro *gcp;
#ifndef NO_CONSVARS
    int cursor;
    consvarptrs *vb = NULL;
#endif


    if (consblock_root == NULL)
      return 0;         /* Nothing to do! */

    /* Start by clearing all DSW_MARKER bits */
    for (cb = consblock_root; cb != NULL; cb = cb->nextblock) {
      cc = cb->cells;
      for (i = 0; i < cb->cellcount; ++i, ++cc)
#ifdef PURIFY  /* Turn on for 'Purify' testing... */
        if (cc->flags & (DSW_MARKER))
#endif
          cc->flags &= ~(DSW_MARKER);
    }

    /* Hookay...  Now we run marking on all cells that are
       reachable from some (any) of our registered variables */
    /* Static variables */
    for (i = 0; i < staticidx; ++i)
      if (*staticvec[i] != NULL) {
#ifdef DEBUG_xx
      fprintf(stderr," cons_DSW(STATIC->%p)\n",*staticvec[i]);
#endif
      cons_DSW(*staticvec[i]);
      }
    /* Function-format iterators */
    for (i = 0; i < functionidx; ++i)
      if (functionvec[i] != NULL)
      functionvec[i](cons_DSW);
    
    /* Dynamically inserted (and removed) GCPROx() -variables */
    gcp = gcprolist;
    while (gcp) {
#ifdef DEBUG_xx
      fprintf(stderr," cons_DSW(gcp-> %p )\n",gcp);
#endif
      for (i= 0; i < gcp->nvars; ++i) {
      if (*(gcp->var[i])) {
#ifdef DEBUG_xx
        fprintf(stderr," cons_DSW(GCPRO->%p)\n",*(gcp->var[i]));
#endif
        cons_DSW(*(gcp->var[i]));
      }
      }
      gcp = gcp->next;
    }
    
#ifndef NO_CONSVARS
    cursor = 0;
    for (vb = consvars_root; vb != NULL; vb = vb->nextvars) {
      for (i = 0; i < vb->count; ++i,++cursor) {
      if (cursor < consvars_cursor) {
        if (vb->vars[i] != NULL) {
#ifdef DEBUG
          fprintf(stderr," cons_DSW(consvar->%p)\n",*(vb->vars[i]));
#endif
          cons_DSW(*(vb->vars[i]));
        }
      } else
        break;
      }
    }
#endif


    /* All are marked.. now we can scan all non-marked, and declare
       them to belong into free..   Oh yes, all  ISNEW(cellptr)  cells
       will do  free(cellptr->string)    */

    freep = & conscell_freechain;
    strusecnt = usecnt = freecnt = newfreecnt = 0;
    for (cb = consblock_root; cb != NULL; cb = cb->nextblock) {
      cc = cb->cells;
      for (i = 0; i < cb->cellcount; ++i,++cc)
          if (cc->flags & DSW_MARKER) {

            /* It was reachable, just clean the marker bit(s) */

            cc->flags &= ~(DSW_MARKER);
            ++usecnt;
            if (ISNEW(cc))
              ++strusecnt;

          } else {

            /* This was not reachable, no marker was added.. */
            if (ISNEW(cc)) {   /* if (cc->flags & NEWSTRING) */
#ifdef __GNUC__
                if (D_conscell)
                  fprintf(stderr,
                        " freestr(%p) cell=%p called from %p s='%s'\n",
                        cc->string, cc, __builtin_return_address(0),
                        cc->string);
#else
                if (D_conscell)
                  fprintf(stderr,
                        " freestr(%p) cell=%p s='%s'\n",
                        cc->cstring, cc, cc->cstring);
#endif
                freestr(cc->string,cc->slen);
                cc->string = NULL;
            }
            if (!(cc->flags & DSW_FREEMARK)) {
              if (D_conscell)
                fprintf(stderr," freecell(%p)\n",cc);
              ++newfreecnt;
            }
            cc->flags = DSW_FREEMARK;

            /* Forward-linked free cell list */
            *freep = cc;
            freep = &cc->next;
            ++freecnt;
          }
    }
    *freep = NULL;

    newcell_gc_freecount += freecnt;
    newcell_gc_strusecnt = strusecnt;

    if (D_conscell)
      fprintf(stderr,"cons_garbage_collect() freed %d, found %d free, and %d used cells\n",
            newfreecnt, freecnt-newfreecnt, usecnt);

    return freecnt;
}



/*
 * Actual heart of this all:  Allocate the conscell!
 */
conscell *
 newcell()
{
    conscell *new;

    /* At first, see if we are to do some GC ... */

    if (D_conscell)
      fprintf(stderr," newcell() called\n");

    ++newcell_callcount;

    if (newcell_gc_interval < consblock_cellcount)
      if (++newcell_gc_callcount >= newcell_gc_interval) {
      cons_garbage_collect();
      newcell_gc_callcount = 0;
      }

    if (conscell_freechain == NULL) {

      cons_garbage_collect();
      /* if (++newcell_gc_callcount >= newcell_gc_interval)
       newcell_gc_callcount = 0; */

      /* Ok, if we were lucky, we got free cells from GC,
       or had them otherwise.. */

      if (conscell_freechain == NULL)
      if (new_consblock() == NULL)
        if (cons_garbage_collect() == 0) {
          /* XX: Unable to allocate memory, nor any freeable!
             Print something, and abort ? */
          return NULL;
        }
    }
    /* Ok, the devil is at loose now, if we don't have at least ONE cell
       in the free chain now..  We do NOT store anything into flags, or
       other fields of the structure -- to help memory access checkup
       routines, like Purify, or DEC OSF/1 ATOM Third-Degree */

    new = conscell_freechain;
    conscell_freechain = new->next;
#if 0 /* No clearing of any fields here!
       All uses of this function will handle filling of all fields
       all by themselves. */
#if 0
    new->next = NULL;
    new->flags = 0;
#else
    memset(new, 0, sizeof(*new));
#endif
#endif

#ifdef __GNUC__
    if (D_conscell)
      fprintf(stderr," newcell() returns %p to caller at %p\n", new,
            __builtin_return_address(0));
#else
    if (D_conscell)
      fprintf(stderr," newcell() returns %p\n", new);
#endif
    return new;
}

#ifdef DEBUG_MAIN       /* We test the beast... */
int main(argc, argv)
int argc;
char *argv[];
{
    int i;
    conscell *newc, *tmp;
    conscell *rootcell;
    GCVARS1;

    newcell_gc_interval = 3;

    rootcell = conststring("const-string",12);
#if 0
    GCPRO1(rootcell);
    printf("rootcell @ %p cell %p\n",&rootcell, rootcell);
#else
#ifndef NO_CONSVARS
    consvar_register(&rootcell);
    printf("consvars_cursor = %ld\n", consvars_cursor);
#endif
#endif

    for (i = 0; i < 30; ++i) {
      newc = conststring("subconst",8);
      newc->next = rootcell->next;
      rootcell->next = newc;
    }

    cons_garbage_collect();
    rootcell = NULL;
    /* UNGCPRO1; */
    cons_garbage_collect();

    return 0;
}
#endif

#ifndef copycell
conscell *copycell(X)
     conscell *X;
{
  conscell *tmp = newcell();
  *tmp = *X;
  if (STRING(tmp)) {
    tmp->string = dupnstr(tmp->string, tmp->slen);
    /* Copycell does *NOT* preserve other string flags, caller
       must do that! */
    tmp->flags = NEWSTRING;
  }
  return tmp;
}
#endif
#ifndef nconc
/* nconc(list, list) -> old (,@list ,@list) */
conscell *nconc(X, Y)
     conscell *X, *Y;
{
  return ((car(X) != NULL) ?
        cdr(s_last(car(X))) = Y :
        (car(X) = Y, X));
}
#endif
#ifndef ncons
conscell *ncons(X)
     conscell *X;
{
  conscell *tmp = newcell();
  car(tmp) = X;
  tmp->slen = tmp->flags = 0;
  cdr(tmp) = NULL;
  return tmp;
}
#endif
#ifndef cons
/* cons(s-expr, list) -> new (s-expr ,@list) */
conscell *cons(X, Y)
     conscell *X, *Y;
{
  conscell *tmp = ncons(X);
  cdar(tmp) = Y;
  return tmp;
}
#endif
#ifndef s_push
/* s_push(s-expr, list) -> old (s-expr ,@list) */
conscell *s_push(X, Y)
     conscell *X, *Y;
{
  cdr(X) = car(Y);
  car(Y) = X;
  return Y;
}
#endif
#ifndef newstring
conscell *newstring(s, slen)
     char *s;
     const int slen;
{
  conscell *tmp = newcell();
  tmp->string = s;
  tmp->flags = NEWSTRING;
  tmp->slen  = slen;
  cdr(tmp) = NULL;
  return tmp;
}
#endif
#ifndef conststring
conscell *conststring(s, slen)
     const char *s;
     const int slen;
{
  conscell *tmp = newcell();
  tmp->cstring = s;
  tmp->flags = CONSTSTRING;
  tmp->slen  = slen;
  cdr(tmp) = NULL;
  return tmp;
}
#endif


/* ********************************************************
 *
 *   STRING MALLOC ROUTINES:  DUPSTR(), DUPNSTR(), FREESTR()
 *
 * ******************************************************** */

const static int  strmagic = 0x53545200; /* 'STR\0' */

#define STRPOSOFFSET 0  /* 5 for debug,         */
                  /* 4 for run w/ check,  */
                  /* 0 for run w/o check! */


char *mallocstr(len)
     const int len;
{
  char *p = malloc((len+STRPOSOFFSET+1 +7) & ~7); /* XX: DEBUG MODE! */
#if STRPOSOFFSET > 0
  int *ip = (int*)p;
#endif
  if (!p) return p; /* NULL */
  p += STRPOSOFFSET;    /* Alignment OFF even bytes for debugging
                     of string element misuses in conscells. */
#if STRPOSOFFSET > 0
  *ip = strmagic;
#endif
#ifdef __GNUC__
  if (D_conscell)
    fprintf(stderr," mallocstr() returns %p to caller at %p\n", p,
          __builtin_return_address(0));
#else
  if (D_conscell)
    fprintf(stderr," mallocstr() returns %p\n", p);
#endif

  return p;
}

char *dupnstr(str,len)
     const char *str;
     const int len;
{
  char *p = mallocstr(len);
  memcpy(p, str, len);
  p[len] = 0;
  ++newcell_gc_dupnstrcount;

#ifdef __GNUC__
  if (D_conscell)
    fprintf(stderr," dupnstr() returns %p to caller at %p\n", p,
          __builtin_return_address(0));
#else
  if (D_conscell)
    fprintf(stderr," dupnstr() returns %p\n", p);
#endif
  return (p);
}

void freestr(str, slen)
     const char *str;
     const int slen;
{
  char *p = (char*)str;
  int *ip = (int*)(p - STRPOSOFFSET);

#if STRPOSOFFSET > 0
  if (*ip != strmagic) *(int*)0L = 0; /* ZAP! */
#endif

  free(ip);

  ++newcell_gc_freestrcount;
}

Generated by  Doxygen 1.6.0   Back to index