/* 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 #include #include #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