source: trunk/libs/newlib/src/libgloss/microblaze/xil_malloc.c @ 650

/* Copyright (c) 1995, 2002, 2009 Xilinx, Inc.  All rights reserved. 
   
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are
   met:
   
   1.  Redistributions source code must retain the above copyright notice,
   this list of conditions and the following disclaimer. 
   
   2.  Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution. 
   
   3.  Neither the name of Xilinx nor the names of its contributors may be
   used to endorse or promote products derived from this software without
   specific prior written permission. 
   
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#ifdef DEBUG
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#else
typedef unsigned int size_t;
#define NULL 0
#endif

#define sbrk xil_sbrk

/* The only extern functions I need if not printing. */
extern  void* sbrk(size_t incr);
extern  void *memcpy(void *s1, const void *s2, size_t n);
extern  void *memset(void *s, int c, size_t n);


typedef unsigned char BOOLEAN;
const BOOLEAN FALSE=0;
const BOOLEAN TRUE =1;

#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))

#define M_DBG_NORMAL 0
#define M_DBG_PARTIAL 1
#define M_DBG_FULL 2

/* debugging breakpoint aids */
static char xil_mem_null_free[] = "xil_mem_null_free";
static char xil_mem_chkcnt   [] = "xil_mem_chkcnt";

/* Flag values describing the state of a memory block.
/* Indicator for allocated blk */
#define M_ALLOCEDFLAG 0x5a
/* End-of-block if debug level */
#define M_ALLOCED 0xc99cc99c
/* Free block indicator. */
#define M_FREEFLAG 0xa5
/* End-of-block if debug level */
#define M_FREE 0x9cc99cc9
/* Zero length block. */
#define M_ZEROFLAG 0xaa

/* Header of a memory block. */
typedef unsigned char DATA_T;
typedef DATA_T *      DATA_P;
struct M_HEADER
{
  unsigned       dbglev:2;       /* Debug level this was created with. */
  unsigned       size:22;        /* Size of block / 8. 32 Meg max. */
  unsigned       flag:8;         /* Indicates whether allocated or freed. */
};
typedef struct M_HEADER* M_HEADERP;

BOOLEAN isalloced(M_HEADERP this)      
{ 
  return this->flag == M_ALLOCEDFLAG; 
}
BOOLEAN isfree(M_HEADERP this)         
{ 
  return this->flag == M_FREEFLAG; 
}
BOOLEAN iszero(M_HEADERP this)         
{ 
  return this->flag == M_ZEROFLAG; 
}

void           setalloced(M_HEADERP this)     { this->flag = M_ALLOCEDFLAG; }
void           setfree(M_HEADERP this)        { this->flag = M_FREEFLAG; }
void           setzero(M_HEADERP this)        { this->flag = M_ZEROFLAG; }

int            getdbglev(M_HEADERP this)      { return this->dbglev; }
void           setdbglev(M_HEADERP this, int d) { this->dbglev = d; }

size_t         getsize(M_HEADERP this)        { return this->size << 3; }  /* Alignment is 8. */
void           setsize(M_HEADERP this, size_t s){ this->size = s >> 3; }     

DATA_T *       getend(M_HEADERP this)         { return (((DATA_T *)this)+getsize(this)); }

/* Next pointer is after data in block. */
M_HEADERP     getnext(M_HEADERP this)        { return *(((M_HEADERP*)getend(this)) - 1); }
void           setnext(M_HEADERP this, M_HEADERP n) { *(((M_HEADERP*)getend(this)) - 1) = n; }

/* Routines used to set a flag at end of block if debuglevel != normal. */
/* Sentinel is right BEFORE the next pointer. */
unsigned long* getsentinel(M_HEADERP this);
void           setsentinel(M_HEADERP this, unsigned long lflag);
BOOLEAN        testsentinel(M_HEADERP this, unsigned long lflag);

/* Routines to handle data.  Depend on debug level. */
DATA_T *       getdata(M_HEADERP this)        { return (((DATA_T*)this)+sizeof(*this)); }
size_t         getdatasize(M_HEADERP this);

/* Fill data with a pattern. */
void           setdata(M_HEADERP this, int f);

/* Debug routines */
BOOLEAN        checkalloc(M_HEADERP this);    /* Is this a valid allocated memory pointer? */
BOOLEAN        checkfree(M_HEADERP this);     /* Is this a valid freelist entry? */



/* Get length of data. */
size_t 
getdatasize(M_HEADERP this)
{
  /* By default, size is size of block - size of header. */
  int tmp_size = getsize(this) - sizeof(struct M_HEADER);

  if (this->dbglev != M_DBG_NORMAL) 
    {
      /* Subtract size of sentinel, and next pointer. */
      tmp_size -= sizeof(long) + sizeof(M_HEADERP);
      /* If only eight bytes, no room for sentinel. */
      if (tmp_size < 0)
        tmp_size = 0;
    } 
  else 
    {
      /* Free block always has a next pointer.  Otherwise not. */
      if (isfree(this))
        tmp_size -= sizeof(M_HEADERP);
    }
  return tmp_size;
}

/* Set the data buffer to value f. */
void 
setdata(M_HEADERP this, int f)
{ 
  memset(getdata(this), f, getdatasize(this));
}

/* At the end of the block, there may be a longword with
   special meaning.  This is the sentinel.  If there is a sentinel,
   there is by definition a next pointer. */
unsigned long* 
getsentinel(M_HEADERP this)
{
  DATA_T* addr = (getend(this) - sizeof(M_HEADERP)); /* location of next pointer. */
  if (getdata(this) < addr)
    return ((unsigned long*)addr) - 1;        /* Right before next pointer. */
  else
    return NULL;                      /* Block too small.  No room for sent. */
}

void 
setsentinel(M_HEADERP this, unsigned long lflag)
{
  unsigned long* addr = getsentinel(this);
  if (addr)
    *addr = lflag;
}

BOOLEAN 
testsentinel(M_HEADERP this, unsigned long lflag)
{
  unsigned long* addr = getsentinel(this);
  if (addr)
    return *addr == lflag;
  else
    return TRUE;
}

/*  sizeof(struct M_HEADER)+sizeof(M_HEADERP);  Alignment */
#define M_BLOCKSIZE 8
/*  4096 / 8; // M_BLOCKSIZE ;      Number of freelist entries. */
#define M_FREESIZE 512
/*  64 * 1024;                 Size of incremental memory hunks allocated, */
#define M_BRKINC 2048

static M_HEADERP freelist[M_FREESIZE];       /* Free list. */

static M_HEADERP alloclist = NULL;           /* Pointer to linked list
                                                of Allocated blocks. */
static int mdebuglevel = M_DBG_NORMAL;

static DATA_T zerobuf[M_BLOCKSIZE] = { M_ZEROFLAG, M_ZEROFLAG, M_ZEROFLAG,
                                       M_ZEROFLAG, M_ZEROFLAG, M_ZEROFLAG, 
                                       M_ZEROFLAG, M_ZEROFLAG };
static M_HEADERP zeroblock = (M_HEADERP)zerobuf;

static unsigned long totalallocated = 0;        /* NOT actually malloced, but
                                                   rather the size of the pool. */

static unsigned long totalmalloc = 0;           /* Total amount malloced. */

static unsigned long highwater = 0;             /* Largest amount of memory
                                                   allocated at any time. */
static long nummallocs = 0;
static long numfrees = 0;
static long numreallocs = 0;

int m_prtflag  = 0;
int m_stopaddr = 0;
int m_stopcnt  = 0;
int m_reenter  = 0;
static int m_curcount = 0;

M_HEADERP 
getmemblock(size_t n)
{
  M_HEADERP block = (M_HEADERP) sbrk(n);
  if (block != NULL)
    totalallocated += n;

  return block;
}


static BOOLEAN 
die (char* msg)
{
  mdebuglevel = M_DBG_NORMAL;
#ifdef DEBUG
  printf ("%s\n", msg);
  exit (1);
#else
  /* Go into infinite loop. */
  for (;;)
    ;
#endif
  return FALSE;
}

int 
getfreeindex(size_t size)
{
  return MIN(size / M_BLOCKSIZE, M_FREESIZE - 1);
}

static
void coalesce(M_HEADERP h)
{
  /* Coalesce block h with free block any free blocks after it.
     Assumes that H is currently allocated.  Sentinel at end is
     set to allocated so if H is free, caller has to fix it. */
  for (;;) 
    {
      long i;
      M_HEADERP f;
      M_HEADERP next = (M_HEADERP)getend(h);

      if (next || isalloced(next))
        break; /* no more coalscing can be done. */
         
      /* Take it off the free list. */
      i = getfreeindex(getsize(next));
      f = freelist[i];
      if (f == next)
        freelist[i] = getnext(next);
      else 
        {
          while (f != NULL && getnext(f) != next)
            f = getnext(f);

          /* Didn't find it in the free list. */
          if (f == NULL)
            die ("Coalesce failed.");

          setnext(f, getnext(next));
        }

      /* Add two blocks together and start over. */
      setsize(h, getsize(h) + getsize(next));

      if (getdbglev(h) > M_DBG_NORMAL) 
        {
          setsentinel(h, M_ALLOCED);
        }
    } /* forever */
}

BOOLEAN 
checkalloc(M_HEADERP this)
{
  if (!isalloced(this))
    return die ("checkalloc: pointer header clobbered.");

  if (getdbglev(this) > M_DBG_NORMAL) 
    {
      if (!testsentinel(this, M_ALLOCED))
        return die ("checkalloc: pointer length overrun.");
    }
  return TRUE;
}

BOOLEAN 
checkfree(M_HEADERP this)
{
  DATA_T *d;
  int i;
  if (!isfree(this))
    die ("checkfree: pointer header clobbered.");

  if (getdbglev(this) > M_DBG_NORMAL) 
    {
      if (!testsentinel(this, M_FREE))
        die ("checkfree: pointer length overrun.");

      d = getdata(this);
      i = getdatasize(this);
      while (i-- > 0) {
        if (*d++ != M_FREEFLAG)
          die("checkfree: freed data clobbered.");
      }
    }
  return TRUE;
}

static void 
checkfreelist()
{
  long i;
  for (i = 0; i < M_FREESIZE; i += 1) 
    {
      M_HEADERP h = (M_HEADERP) freelist[i];
      while (h != NULL) 
        {
        checkfree(h);
        if (i != (M_FREESIZE - 1) && getsize(h) != (i * M_BLOCKSIZE))
          die ("checkfreelist: free list size mismatch.");
        h = getnext(h);
        }
    }
}

static void 
checkalloclist()
{
  M_HEADERP a = (M_HEADERP) alloclist;
  while (a != NULL) 
    {
      checkalloc(a);
      a = getnext(a);
    }
}

/* Free a block of memory.  This is done by adding to the free list. */
static void 
addtofreelist (M_HEADERP h)
{
  long i;
  /* Merge freed blocks together. */
  coalesce(h);

  /* link this block to the front of the appropriate free list. */
  i = getfreeindex(getsize(h));
  setnext(h, freelist[i]);
  freelist[i] = h;

  /* Set the flag info. */
  setfree(h);
  setdbglev(h, mdebuglevel);
  if (mdebuglevel > M_DBG_NORMAL) 
    {
      /* Fill with some meaningful (and testable) data. */
      setdata(h, M_FREEFLAG);
      setsentinel(h, M_FREE);
    }
}

void 
xil_malloc_verify()
{
  int i;
  for ( i = 0; i < M_BLOCKSIZE; i += 1) 
    {
      if (zerobuf[i] != M_ZEROFLAG)
        die ("malloc_verify: Zero block clobbered.");
    }
  checkfreelist();
  checkalloclist();
}

void 
xil_malloc_debug (int level)
{
  mdebuglevel = MAX (M_DBG_NORMAL, MIN (M_DBG_FULL, level));
}

void* 
xil_malloc (size_t nbytes)
{
  int i;
  int minf;
  int maxf;
  size_t msize;
  M_HEADERP p;
  M_HEADERP h;

  nummallocs += 1;

  if (nbytes == 0)
    return getdata(zeroblock);

  if (mdebuglevel == M_DBG_FULL)
    {
#ifdef DEBUG
      static unsigned do_cnt = ~0;
      static unsigned done_cnt = 0;
      if (do_cnt == ~0) 
        {
          char *x = (char *)getenv(xil_mem_chkcnt);
          do_cnt = 1;
          if (x)
            do_cnt = atoi(x);
        }
      if (do_cnt == 1 || done_cnt % do_cnt == 0)
        xil_malloc_verify();
      done_cnt++;
#else
      xil_malloc_verify();
#endif
    }

  nbytes += sizeof (struct M_HEADER);

  /* If debug, leave room for flag and next pointer. */
  if (mdebuglevel > M_DBG_NORMAL)
    nbytes += sizeof (long) + sizeof (M_HEADERP*);

  /* Round up to allocation unit */
  msize = ((nbytes + M_BLOCKSIZE - 1) / M_BLOCKSIZE) * M_BLOCKSIZE;

  /* Look around for a block of approximately the right size. */
  h = NULL;
  minf = getfreeindex(msize);
  maxf = MIN(minf * 2, M_FREESIZE);

  for (i = minf; i < M_FREESIZE; i += 1) 
    {
      if (i >= maxf)
        i = M_FREESIZE - 1;    /* Skip over blocks too large. */

      h = freelist[i];
      p = NULL;       /* Previous. */
      while (h != NULL) 
        {
          if (getsize(h) >= nbytes) 
            {
              /* Take h out of linked list */
              if (p)
                setnext(p, getnext(h));
              else
                freelist[i] = getnext(h);

              if (!isfree(h))
                die ("malloc: freelist clobbered.\n");

              goto gotit;
            }
          else 
            {
              p = h;
              h = getnext(h);
            }
        }
    }

  /* Didn't find any free pointers.  Allocate more heap. 
     Round up to next heap increment. */
  i = ((msize + sizeof(long) + M_BRKINC - 1) / M_BRKINC) * M_BRKINC;
  if ((h = getmemblock (i)) == NULL) 
    {
#ifdef DEBUG
      printf ("xil_malloc: Out of dynamic memory.\n");
#endif
      return NULL;
    }

  /* Mark end of block with zero for four bytes so we don't merge next block 
     into free list accidentally. */
  setsize(h, i - sizeof(long));
  *((long*)getend(h)) = 0;

 gotit:
  /* Merge allocated blocks so we can free a bigger part of what is left! */
  coalesce(h);
  if (getsize(h) >= msize + M_BLOCKSIZE) 
    {
      M_HEADERP r;
      int rsize;
      /* add the remainder of this block to the free list. */
      rsize = getsize(h) - msize;
      r = (M_HEADERP) (((DATA_T *)h) + msize);
      setsize (r, rsize);
      setsize (h, msize);
      addtofreelist (r);
    }

  setalloced(h);
  setdbglev(h, mdebuglevel);
  if (mdebuglevel > M_DBG_NORMAL) 
    {
      // Chain into alloc'd list and set sentinel. */
      setsentinel(h, M_ALLOCED);
      setnext(h, alloclist);
      alloclist = h;
    }

#ifdef DEBUG
  if (!m_reenter && m_prtflag) 
    {
      m_reenter = 1;
      printf("%d      malloc\n",h+1);
      fflush(stdout);
      if (m_stopaddr)
        {
          if ((DATA_T *)m_stopaddr == getdata(h))
            {
              if (m_stopcnt == ++m_curcount)
                exit(10);
            }
        }
      m_reenter = 0;
    }
#endif

  totalmalloc += getsize(h);
  if (totalmalloc > highwater)
    highwater = totalmalloc;

  return getdata(h);
}

void 
xil_free(void* ap)
{
  M_HEADERP h;
  numfrees += 1;

  if (ap == NULL) 
   {
#ifdef DEBUG
     if (mdebuglevel != M_DBG_NORMAL && getenv(xil_mem_null_free))
       die ("free: tried to free NULL pointer.");
     else
       return;        /* Let `em do it. */
#else
     return;
#endif
   }

  /* Drop through to here if not a smartheap allocation.  This
     handles free of both xil_malloc and libc malloc. */

  h = (M_HEADERP) (((DATA_T *)ap) - sizeof (struct M_HEADER));

  if (h == zeroblock)
    return;

#ifdef DEBUG
  if (!m_reenter && m_prtflag) {
    m_reenter = 1;
    printf("%d      mfree\n",h+1);
    fflush(stdout);
    m_reenter = 0;
  }
#endif

  if (!isalloced(h)) {
    if (isfree(h))
      die ("free: tried to free pointer twice.");
    else
      die ("free: tried to free a block not allocated by malloc.");
    return;
  }

  if (getdbglev(h) > M_DBG_NORMAL) 
    {
      /* Make sure things look reasonable. */
      checkalloc(h);

      /* Try to find the pointer in the alloc list. */
      if (alloclist == h)
        alloclist = getnext(h);
      else 
        {
          M_HEADERP a = alloclist;
          while (a != NULL && getnext(a) != h)
            a = getnext(a);

          /* If a is NULL, debuglevel must have been reset at some point. */
          if (a != NULL)
            setnext(a, getnext(h));
        }
    }

  totalmalloc -= getsize(h);

  addtofreelist (h);

  if (mdebuglevel == M_DBG_FULL) 
    {
#ifdef DEBUG
      static unsigned do_cnt = ~0;
      static unsigned done_cnt = 0;
      if (do_cnt == ~0) 
        {
          char *x = (char *)getenv(xil_mem_chkcnt);
          do_cnt = 1;
          if (x)
            do_cnt = atoi(x);
        }
      if (do_cnt == 1 || done_cnt % do_cnt == 0)
        xil_malloc_verify();
      done_cnt++;
#else
      xil_malloc_verify();
#endif
    }
}

unsigned 
xil_msize (void* ap)
{
  M_HEADERP h = (M_HEADERP) (((DATA_T *)ap) - sizeof (struct M_HEADER));
  return getdatasize(h);
}

void* 
xil_realloc (void* oldblk, size_t newsize )
{
  M_HEADERP h;
  size_t oldsize;
  void* newblk;

  numreallocs += 1;

  if (oldblk == NULL) 
    {
      if (mdebuglevel != M_DBG_NORMAL)
        die ("realloc: tried to realloc NULL pointer.");
      else
        return xil_malloc(newsize);        /* Don't need to copy anything. */
    }

  /* Make sure this is a valid block. */
  h = (M_HEADERP) (((char*)oldblk) - sizeof (struct M_HEADER));

  /* if old block was zero bytes, just alloc a new one. */
  if (h == zeroblock)
    return xil_malloc(newsize);           /* Source is empty anyway. */

  /* If old block was already freed, error. */
  if (isfree(h))
    die ("realloc: tried to realloc freed pointer.");

  if (!isalloced(h)) 
    {
      long* pdesc = *(long**)h;         /* Get pointer to the block descriptor. */
      long* pnextdesc = (long*)*pdesc;
      if ((pdesc[1] & ~3) != (long)h)   /* Should point back to block. */
        die ("realloc: header clobbered.");

      /* This must be a libc block.  We need to figure out how big it is.
         Length of block is delta between two descriptors - sizeof (void*). */
      
      oldsize = (size_t) ((pnextdesc[1] & ~3) - (pdesc[1] & ~3)-sizeof(void*));

      /* Don't bother to change anything unless there's not enough room. */
      if (oldsize < newsize) 
        {
          /* Alloc a new block with our malloc. */
          if ((newblk = xil_malloc(newsize)) == NULL )
            return NULL ;

          /* Copy the old data to it. */
          memcpy (newblk, oldblk, (newsize < oldsize) ? newsize : oldsize);
          xil_free(oldblk);
          return newblk;
        }
    }

  /* If the new size is bigger than my allocated
     size, or if more than 1/4 of the block would be left free, allocate
     a new block and copy the data.  Otherwise, leave well enough alone. */

  coalesce(h);

  oldsize = getdatasize(h);

  if (oldsize < newsize 
      || (newsize > (2*M_BLOCKSIZE) && (newsize*4) < (oldsize*3))) 
    {
      if (( newblk = xil_malloc( newsize )) == NULL )
        return NULL ;

      memcpy (newblk, oldblk, (newsize < oldsize) ? newsize : oldsize);

      xil_free (oldblk);
      return newblk;
    }
  else
    return oldblk;
}

void* 
xil_calloc (size_t number, size_t size)
{
  long*  longptr ;
  void*  blockptr ;
  size_t temp   = number * size + sizeof (long) - 1;
  temp -= temp % sizeof (long);

  blockptr = xil_malloc( temp );
  if ( blockptr != 0 ) 
    {
      longptr = (long*) blockptr ;
      temp /= sizeof (long);
      while ( temp-- > 0 ) 
        {
          *longptr++ = 0 ;
        }
    }
  return blockptr ;
}

#define M_STAT_NORMAL 0
#define M_STAT_VERBOSE 1
#define M_STAT_REALLYVERBOSE 2

#ifdef DEBUG
void 
xil_mstats(int verbosity)
{  
  unsigned long totalfree = 0;
  int i;
  printf("Memory Statics:\n"
         "---------------\n");
  printf("   Number of calls to malloc:   %ld.\n", nummallocs);
  printf("   Number of calls to free:     %ld.\n", numfrees);
  printf("   Number of calls to realloc:  %ld.\n", numreallocs);
  printf("   Total allocated memory:      %lu (0x%lx)\n",
         totalallocated, totalallocated);
  printf("   Currently malloced memory:   %lu (0x%lx)\n",
         totalmalloc, totalmalloc);
  fflush(stdout);

 
  for (i = 0; i < M_FREESIZE; i += 1) 
    {
      M_HEADERP h = freelist[i];
      unsigned long numblocks = 0;
      while (h != NULL) 
        {
          totalfree += getsize(h);
          numblocks += 1;
          h = getnext(h);
        }
      if (verbosity > M_STAT_NORMAL && numblocks > 0) 
        {
          printf("   There are %d blocks on freelist for size %d\n",
                 numblocks, i * M_BLOCKSIZE);
          fflush(stdout);
        }
    }
  printf("   Currently free memory:       %lu (0x%lx)\n",
         totalfree, totalfree);
  printf("   High water mark:             %lu (0x%lx)\n",
         highwater, highwater);

  printf("\n");
  fflush(stdout);
}
#else
void 
xil_mstats(int verbosity)
{
}
#endif