[444] | 1 | /* Copyright (c) 1995, 2002, 2009 Xilinx, Inc. All rights reserved. |
---|
| 2 | |
---|
| 3 | Redistribution and use in source and binary forms, with or without |
---|
| 4 | modification, are permitted provided that the following conditions are |
---|
| 5 | met: |
---|
| 6 | |
---|
| 7 | 1. Redistributions source code must retain the above copyright notice, |
---|
| 8 | this list of conditions and the following disclaimer. |
---|
| 9 | |
---|
| 10 | 2. Redistributions in binary form must reproduce the above copyright |
---|
| 11 | notice, this list of conditions and the following disclaimer in the |
---|
| 12 | documentation and/or other materials provided with the distribution. |
---|
| 13 | |
---|
| 14 | 3. Neither the name of Xilinx nor the names of its contributors may be |
---|
| 15 | used to endorse or promote products derived from this software without |
---|
| 16 | specific prior written permission. |
---|
| 17 | |
---|
| 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS |
---|
| 19 | IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
---|
| 20 | TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A |
---|
| 21 | PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
---|
| 22 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
---|
| 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED |
---|
| 24 | TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
---|
| 25 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
---|
| 26 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
---|
| 27 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
---|
| 28 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
---|
| 29 | |
---|
| 30 | */ |
---|
| 31 | |
---|
| 32 | #ifdef DEBUG |
---|
| 33 | #include <stdlib.h> |
---|
| 34 | #include <stddef.h> |
---|
| 35 | #include <stdio.h> |
---|
| 36 | #else |
---|
| 37 | typedef unsigned int size_t; |
---|
| 38 | #define NULL 0 |
---|
| 39 | #endif |
---|
| 40 | |
---|
| 41 | #define sbrk xil_sbrk |
---|
| 42 | |
---|
| 43 | /* The only extern functions I need if not printing. */ |
---|
| 44 | extern void* sbrk(size_t incr); |
---|
| 45 | extern void *memcpy(void *s1, const void *s2, size_t n); |
---|
| 46 | extern void *memset(void *s, int c, size_t n); |
---|
| 47 | |
---|
| 48 | |
---|
| 49 | typedef unsigned char BOOLEAN; |
---|
| 50 | const BOOLEAN FALSE=0; |
---|
| 51 | const BOOLEAN TRUE =1; |
---|
| 52 | |
---|
| 53 | #define MIN(a,b) (((a) < (b)) ? (a) : (b)) |
---|
| 54 | #define MAX(a,b) (((a) > (b)) ? (a) : (b)) |
---|
| 55 | |
---|
| 56 | #define M_DBG_NORMAL 0 |
---|
| 57 | #define M_DBG_PARTIAL 1 |
---|
| 58 | #define M_DBG_FULL 2 |
---|
| 59 | |
---|
| 60 | /* debugging breakpoint aids */ |
---|
| 61 | static char xil_mem_null_free[] = "xil_mem_null_free"; |
---|
| 62 | static char xil_mem_chkcnt [] = "xil_mem_chkcnt"; |
---|
| 63 | |
---|
| 64 | /* Flag values describing the state of a memory block. |
---|
| 65 | /* Indicator for allocated blk */ |
---|
| 66 | #define M_ALLOCEDFLAG 0x5a |
---|
| 67 | /* End-of-block if debug level */ |
---|
| 68 | #define M_ALLOCED 0xc99cc99c |
---|
| 69 | /* Free block indicator. */ |
---|
| 70 | #define M_FREEFLAG 0xa5 |
---|
| 71 | /* End-of-block if debug level */ |
---|
| 72 | #define M_FREE 0x9cc99cc9 |
---|
| 73 | /* Zero length block. */ |
---|
| 74 | #define M_ZEROFLAG 0xaa |
---|
| 75 | |
---|
| 76 | /* Header of a memory block. */ |
---|
| 77 | typedef unsigned char DATA_T; |
---|
| 78 | typedef DATA_T * DATA_P; |
---|
| 79 | struct M_HEADER |
---|
| 80 | { |
---|
| 81 | unsigned dbglev:2; /* Debug level this was created with. */ |
---|
| 82 | unsigned size:22; /* Size of block / 8. 32 Meg max. */ |
---|
| 83 | unsigned flag:8; /* Indicates whether allocated or freed. */ |
---|
| 84 | }; |
---|
| 85 | typedef struct M_HEADER* M_HEADERP; |
---|
| 86 | |
---|
| 87 | BOOLEAN isalloced(M_HEADERP this) |
---|
| 88 | { |
---|
| 89 | return this->flag == M_ALLOCEDFLAG; |
---|
| 90 | } |
---|
| 91 | BOOLEAN isfree(M_HEADERP this) |
---|
| 92 | { |
---|
| 93 | return this->flag == M_FREEFLAG; |
---|
| 94 | } |
---|
| 95 | BOOLEAN iszero(M_HEADERP this) |
---|
| 96 | { |
---|
| 97 | return this->flag == M_ZEROFLAG; |
---|
| 98 | } |
---|
| 99 | |
---|
| 100 | void setalloced(M_HEADERP this) { this->flag = M_ALLOCEDFLAG; } |
---|
| 101 | void setfree(M_HEADERP this) { this->flag = M_FREEFLAG; } |
---|
| 102 | void setzero(M_HEADERP this) { this->flag = M_ZEROFLAG; } |
---|
| 103 | |
---|
| 104 | int getdbglev(M_HEADERP this) { return this->dbglev; } |
---|
| 105 | void setdbglev(M_HEADERP this, int d) { this->dbglev = d; } |
---|
| 106 | |
---|
| 107 | size_t getsize(M_HEADERP this) { return this->size << 3; } /* Alignment is 8. */ |
---|
| 108 | void setsize(M_HEADERP this, size_t s){ this->size = s >> 3; } |
---|
| 109 | |
---|
| 110 | DATA_T * getend(M_HEADERP this) { return (((DATA_T *)this)+getsize(this)); } |
---|
| 111 | |
---|
| 112 | /* Next pointer is after data in block. */ |
---|
| 113 | M_HEADERP getnext(M_HEADERP this) { return *(((M_HEADERP*)getend(this)) - 1); } |
---|
| 114 | void setnext(M_HEADERP this, M_HEADERP n) { *(((M_HEADERP*)getend(this)) - 1) = n; } |
---|
| 115 | |
---|
| 116 | /* Routines used to set a flag at end of block if debuglevel != normal. */ |
---|
| 117 | /* Sentinel is right BEFORE the next pointer. */ |
---|
| 118 | unsigned long* getsentinel(M_HEADERP this); |
---|
| 119 | void setsentinel(M_HEADERP this, unsigned long lflag); |
---|
| 120 | BOOLEAN testsentinel(M_HEADERP this, unsigned long lflag); |
---|
| 121 | |
---|
| 122 | /* Routines to handle data. Depend on debug level. */ |
---|
| 123 | DATA_T * getdata(M_HEADERP this) { return (((DATA_T*)this)+sizeof(*this)); } |
---|
| 124 | size_t getdatasize(M_HEADERP this); |
---|
| 125 | |
---|
| 126 | /* Fill data with a pattern. */ |
---|
| 127 | void setdata(M_HEADERP this, int f); |
---|
| 128 | |
---|
| 129 | /* Debug routines */ |
---|
| 130 | BOOLEAN checkalloc(M_HEADERP this); /* Is this a valid allocated memory pointer? */ |
---|
| 131 | BOOLEAN checkfree(M_HEADERP this); /* Is this a valid freelist entry? */ |
---|
| 132 | |
---|
| 133 | |
---|
| 134 | |
---|
| 135 | /* Get length of data. */ |
---|
| 136 | size_t |
---|
| 137 | getdatasize(M_HEADERP this) |
---|
| 138 | { |
---|
| 139 | /* By default, size is size of block - size of header. */ |
---|
| 140 | int tmp_size = getsize(this) - sizeof(struct M_HEADER); |
---|
| 141 | |
---|
| 142 | if (this->dbglev != M_DBG_NORMAL) |
---|
| 143 | { |
---|
| 144 | /* Subtract size of sentinel, and next pointer. */ |
---|
| 145 | tmp_size -= sizeof(long) + sizeof(M_HEADERP); |
---|
| 146 | /* If only eight bytes, no room for sentinel. */ |
---|
| 147 | if (tmp_size < 0) |
---|
| 148 | tmp_size = 0; |
---|
| 149 | } |
---|
| 150 | else |
---|
| 151 | { |
---|
| 152 | /* Free block always has a next pointer. Otherwise not. */ |
---|
| 153 | if (isfree(this)) |
---|
| 154 | tmp_size -= sizeof(M_HEADERP); |
---|
| 155 | } |
---|
| 156 | return tmp_size; |
---|
| 157 | } |
---|
| 158 | |
---|
| 159 | /* Set the data buffer to value f. */ |
---|
| 160 | void |
---|
| 161 | setdata(M_HEADERP this, int f) |
---|
| 162 | { |
---|
| 163 | memset(getdata(this), f, getdatasize(this)); |
---|
| 164 | } |
---|
| 165 | |
---|
| 166 | /* At the end of the block, there may be a longword with |
---|
| 167 | special meaning. This is the sentinel. If there is a sentinel, |
---|
| 168 | there is by definition a next pointer. */ |
---|
| 169 | unsigned long* |
---|
| 170 | getsentinel(M_HEADERP this) |
---|
| 171 | { |
---|
| 172 | DATA_T* addr = (getend(this) - sizeof(M_HEADERP)); /* location of next pointer. */ |
---|
| 173 | if (getdata(this) < addr) |
---|
| 174 | return ((unsigned long*)addr) - 1; /* Right before next pointer. */ |
---|
| 175 | else |
---|
| 176 | return NULL; /* Block too small. No room for sent. */ |
---|
| 177 | } |
---|
| 178 | |
---|
| 179 | void |
---|
| 180 | setsentinel(M_HEADERP this, unsigned long lflag) |
---|
| 181 | { |
---|
| 182 | unsigned long* addr = getsentinel(this); |
---|
| 183 | if (addr) |
---|
| 184 | *addr = lflag; |
---|
| 185 | } |
---|
| 186 | |
---|
| 187 | BOOLEAN |
---|
| 188 | testsentinel(M_HEADERP this, unsigned long lflag) |
---|
| 189 | { |
---|
| 190 | unsigned long* addr = getsentinel(this); |
---|
| 191 | if (addr) |
---|
| 192 | return *addr == lflag; |
---|
| 193 | else |
---|
| 194 | return TRUE; |
---|
| 195 | } |
---|
| 196 | |
---|
| 197 | /* sizeof(struct M_HEADER)+sizeof(M_HEADERP); Alignment */ |
---|
| 198 | #define M_BLOCKSIZE 8 |
---|
| 199 | /* 4096 / 8; // M_BLOCKSIZE ; Number of freelist entries. */ |
---|
| 200 | #define M_FREESIZE 512 |
---|
| 201 | /* 64 * 1024; Size of incremental memory hunks allocated, */ |
---|
| 202 | #define M_BRKINC 2048 |
---|
| 203 | |
---|
| 204 | static M_HEADERP freelist[M_FREESIZE]; /* Free list. */ |
---|
| 205 | |
---|
| 206 | static M_HEADERP alloclist = NULL; /* Pointer to linked list |
---|
| 207 | of Allocated blocks. */ |
---|
| 208 | static int mdebuglevel = M_DBG_NORMAL; |
---|
| 209 | |
---|
| 210 | static DATA_T zerobuf[M_BLOCKSIZE] = { M_ZEROFLAG, M_ZEROFLAG, M_ZEROFLAG, |
---|
| 211 | M_ZEROFLAG, M_ZEROFLAG, M_ZEROFLAG, |
---|
| 212 | M_ZEROFLAG, M_ZEROFLAG }; |
---|
| 213 | static M_HEADERP zeroblock = (M_HEADERP)zerobuf; |
---|
| 214 | |
---|
| 215 | static unsigned long totalallocated = 0; /* NOT actually malloced, but |
---|
| 216 | rather the size of the pool. */ |
---|
| 217 | |
---|
| 218 | static unsigned long totalmalloc = 0; /* Total amount malloced. */ |
---|
| 219 | |
---|
| 220 | static unsigned long highwater = 0; /* Largest amount of memory |
---|
| 221 | allocated at any time. */ |
---|
| 222 | static long nummallocs = 0; |
---|
| 223 | static long numfrees = 0; |
---|
| 224 | static long numreallocs = 0; |
---|
| 225 | |
---|
| 226 | int m_prtflag = 0; |
---|
| 227 | int m_stopaddr = 0; |
---|
| 228 | int m_stopcnt = 0; |
---|
| 229 | int m_reenter = 0; |
---|
| 230 | static int m_curcount = 0; |
---|
| 231 | |
---|
| 232 | M_HEADERP |
---|
| 233 | getmemblock(size_t n) |
---|
| 234 | { |
---|
| 235 | M_HEADERP block = (M_HEADERP) sbrk(n); |
---|
| 236 | if (block != NULL) |
---|
| 237 | totalallocated += n; |
---|
| 238 | |
---|
| 239 | return block; |
---|
| 240 | } |
---|
| 241 | |
---|
| 242 | |
---|
| 243 | static BOOLEAN |
---|
| 244 | die (char* msg) |
---|
| 245 | { |
---|
| 246 | mdebuglevel = M_DBG_NORMAL; |
---|
| 247 | #ifdef DEBUG |
---|
| 248 | printf ("%s\n", msg); |
---|
| 249 | exit (1); |
---|
| 250 | #else |
---|
| 251 | /* Go into infinite loop. */ |
---|
| 252 | for (;;) |
---|
| 253 | ; |
---|
| 254 | #endif |
---|
| 255 | return FALSE; |
---|
| 256 | } |
---|
| 257 | |
---|
| 258 | int |
---|
| 259 | getfreeindex(size_t size) |
---|
| 260 | { |
---|
| 261 | return MIN(size / M_BLOCKSIZE, M_FREESIZE - 1); |
---|
| 262 | } |
---|
| 263 | |
---|
| 264 | static |
---|
| 265 | void coalesce(M_HEADERP h) |
---|
| 266 | { |
---|
| 267 | /* Coalesce block h with free block any free blocks after it. |
---|
| 268 | Assumes that H is currently allocated. Sentinel at end is |
---|
| 269 | set to allocated so if H is free, caller has to fix it. */ |
---|
| 270 | for (;;) |
---|
| 271 | { |
---|
| 272 | long i; |
---|
| 273 | M_HEADERP f; |
---|
| 274 | M_HEADERP next = (M_HEADERP)getend(h); |
---|
| 275 | |
---|
| 276 | if (next || isalloced(next)) |
---|
| 277 | break; /* no more coalscing can be done. */ |
---|
| 278 | |
---|
| 279 | /* Take it off the free list. */ |
---|
| 280 | i = getfreeindex(getsize(next)); |
---|
| 281 | f = freelist[i]; |
---|
| 282 | if (f == next) |
---|
| 283 | freelist[i] = getnext(next); |
---|
| 284 | else |
---|
| 285 | { |
---|
| 286 | while (f != NULL && getnext(f) != next) |
---|
| 287 | f = getnext(f); |
---|
| 288 | |
---|
| 289 | /* Didn't find it in the free list. */ |
---|
| 290 | if (f == NULL) |
---|
| 291 | die ("Coalesce failed."); |
---|
| 292 | |
---|
| 293 | setnext(f, getnext(next)); |
---|
| 294 | } |
---|
| 295 | |
---|
| 296 | /* Add two blocks together and start over. */ |
---|
| 297 | setsize(h, getsize(h) + getsize(next)); |
---|
| 298 | |
---|
| 299 | if (getdbglev(h) > M_DBG_NORMAL) |
---|
| 300 | { |
---|
| 301 | setsentinel(h, M_ALLOCED); |
---|
| 302 | } |
---|
| 303 | } /* forever */ |
---|
| 304 | } |
---|
| 305 | |
---|
| 306 | BOOLEAN |
---|
| 307 | checkalloc(M_HEADERP this) |
---|
| 308 | { |
---|
| 309 | if (!isalloced(this)) |
---|
| 310 | return die ("checkalloc: pointer header clobbered."); |
---|
| 311 | |
---|
| 312 | if (getdbglev(this) > M_DBG_NORMAL) |
---|
| 313 | { |
---|
| 314 | if (!testsentinel(this, M_ALLOCED)) |
---|
| 315 | return die ("checkalloc: pointer length overrun."); |
---|
| 316 | } |
---|
| 317 | return TRUE; |
---|
| 318 | } |
---|
| 319 | |
---|
| 320 | BOOLEAN |
---|
| 321 | checkfree(M_HEADERP this) |
---|
| 322 | { |
---|
| 323 | DATA_T *d; |
---|
| 324 | int i; |
---|
| 325 | if (!isfree(this)) |
---|
| 326 | die ("checkfree: pointer header clobbered."); |
---|
| 327 | |
---|
| 328 | if (getdbglev(this) > M_DBG_NORMAL) |
---|
| 329 | { |
---|
| 330 | if (!testsentinel(this, M_FREE)) |
---|
| 331 | die ("checkfree: pointer length overrun."); |
---|
| 332 | |
---|
| 333 | d = getdata(this); |
---|
| 334 | i = getdatasize(this); |
---|
| 335 | while (i-- > 0) { |
---|
| 336 | if (*d++ != M_FREEFLAG) |
---|
| 337 | die("checkfree: freed data clobbered."); |
---|
| 338 | } |
---|
| 339 | } |
---|
| 340 | return TRUE; |
---|
| 341 | } |
---|
| 342 | |
---|
| 343 | static void |
---|
| 344 | checkfreelist() |
---|
| 345 | { |
---|
| 346 | long i; |
---|
| 347 | for (i = 0; i < M_FREESIZE; i += 1) |
---|
| 348 | { |
---|
| 349 | M_HEADERP h = (M_HEADERP) freelist[i]; |
---|
| 350 | while (h != NULL) |
---|
| 351 | { |
---|
| 352 | checkfree(h); |
---|
| 353 | if (i != (M_FREESIZE - 1) && getsize(h) != (i * M_BLOCKSIZE)) |
---|
| 354 | die ("checkfreelist: free list size mismatch."); |
---|
| 355 | h = getnext(h); |
---|
| 356 | } |
---|
| 357 | } |
---|
| 358 | } |
---|
| 359 | |
---|
| 360 | static void |
---|
| 361 | checkalloclist() |
---|
| 362 | { |
---|
| 363 | M_HEADERP a = (M_HEADERP) alloclist; |
---|
| 364 | while (a != NULL) |
---|
| 365 | { |
---|
| 366 | checkalloc(a); |
---|
| 367 | a = getnext(a); |
---|
| 368 | } |
---|
| 369 | } |
---|
| 370 | |
---|
| 371 | /* Free a block of memory. This is done by adding to the free list. */ |
---|
| 372 | static void |
---|
| 373 | addtofreelist (M_HEADERP h) |
---|
| 374 | { |
---|
| 375 | long i; |
---|
| 376 | /* Merge freed blocks together. */ |
---|
| 377 | coalesce(h); |
---|
| 378 | |
---|
| 379 | /* link this block to the front of the appropriate free list. */ |
---|
| 380 | i = getfreeindex(getsize(h)); |
---|
| 381 | setnext(h, freelist[i]); |
---|
| 382 | freelist[i] = h; |
---|
| 383 | |
---|
| 384 | /* Set the flag info. */ |
---|
| 385 | setfree(h); |
---|
| 386 | setdbglev(h, mdebuglevel); |
---|
| 387 | if (mdebuglevel > M_DBG_NORMAL) |
---|
| 388 | { |
---|
| 389 | /* Fill with some meaningful (and testable) data. */ |
---|
| 390 | setdata(h, M_FREEFLAG); |
---|
| 391 | setsentinel(h, M_FREE); |
---|
| 392 | } |
---|
| 393 | } |
---|
| 394 | |
---|
| 395 | void |
---|
| 396 | xil_malloc_verify() |
---|
| 397 | { |
---|
| 398 | int i; |
---|
| 399 | for ( i = 0; i < M_BLOCKSIZE; i += 1) |
---|
| 400 | { |
---|
| 401 | if (zerobuf[i] != M_ZEROFLAG) |
---|
| 402 | die ("malloc_verify: Zero block clobbered."); |
---|
| 403 | } |
---|
| 404 | checkfreelist(); |
---|
| 405 | checkalloclist(); |
---|
| 406 | } |
---|
| 407 | |
---|
| 408 | void |
---|
| 409 | xil_malloc_debug (int level) |
---|
| 410 | { |
---|
| 411 | mdebuglevel = MAX (M_DBG_NORMAL, MIN (M_DBG_FULL, level)); |
---|
| 412 | } |
---|
| 413 | |
---|
| 414 | void* |
---|
| 415 | xil_malloc (size_t nbytes) |
---|
| 416 | { |
---|
| 417 | int i; |
---|
| 418 | int minf; |
---|
| 419 | int maxf; |
---|
| 420 | size_t msize; |
---|
| 421 | M_HEADERP p; |
---|
| 422 | M_HEADERP h; |
---|
| 423 | |
---|
| 424 | nummallocs += 1; |
---|
| 425 | |
---|
| 426 | if (nbytes == 0) |
---|
| 427 | return getdata(zeroblock); |
---|
| 428 | |
---|
| 429 | if (mdebuglevel == M_DBG_FULL) |
---|
| 430 | { |
---|
| 431 | #ifdef DEBUG |
---|
| 432 | static unsigned do_cnt = ~0; |
---|
| 433 | static unsigned done_cnt = 0; |
---|
| 434 | if (do_cnt == ~0) |
---|
| 435 | { |
---|
| 436 | char *x = (char *)getenv(xil_mem_chkcnt); |
---|
| 437 | do_cnt = 1; |
---|
| 438 | if (x) |
---|
| 439 | do_cnt = atoi(x); |
---|
| 440 | } |
---|
| 441 | if (do_cnt == 1 || done_cnt % do_cnt == 0) |
---|
| 442 | xil_malloc_verify(); |
---|
| 443 | done_cnt++; |
---|
| 444 | #else |
---|
| 445 | xil_malloc_verify(); |
---|
| 446 | #endif |
---|
| 447 | } |
---|
| 448 | |
---|
| 449 | nbytes += sizeof (struct M_HEADER); |
---|
| 450 | |
---|
| 451 | /* If debug, leave room for flag and next pointer. */ |
---|
| 452 | if (mdebuglevel > M_DBG_NORMAL) |
---|
| 453 | nbytes += sizeof (long) + sizeof (M_HEADERP*); |
---|
| 454 | |
---|
| 455 | /* Round up to allocation unit */ |
---|
| 456 | msize = ((nbytes + M_BLOCKSIZE - 1) / M_BLOCKSIZE) * M_BLOCKSIZE; |
---|
| 457 | |
---|
| 458 | /* Look around for a block of approximately the right size. */ |
---|
| 459 | h = NULL; |
---|
| 460 | minf = getfreeindex(msize); |
---|
| 461 | maxf = MIN(minf * 2, M_FREESIZE); |
---|
| 462 | |
---|
| 463 | for (i = minf; i < M_FREESIZE; i += 1) |
---|
| 464 | { |
---|
| 465 | if (i >= maxf) |
---|
| 466 | i = M_FREESIZE - 1; /* Skip over blocks too large. */ |
---|
| 467 | |
---|
| 468 | h = freelist[i]; |
---|
| 469 | p = NULL; /* Previous. */ |
---|
| 470 | while (h != NULL) |
---|
| 471 | { |
---|
| 472 | if (getsize(h) >= nbytes) |
---|
| 473 | { |
---|
| 474 | /* Take h out of linked list */ |
---|
| 475 | if (p) |
---|
| 476 | setnext(p, getnext(h)); |
---|
| 477 | else |
---|
| 478 | freelist[i] = getnext(h); |
---|
| 479 | |
---|
| 480 | if (!isfree(h)) |
---|
| 481 | die ("malloc: freelist clobbered.\n"); |
---|
| 482 | |
---|
| 483 | goto gotit; |
---|
| 484 | } |
---|
| 485 | else |
---|
| 486 | { |
---|
| 487 | p = h; |
---|
| 488 | h = getnext(h); |
---|
| 489 | } |
---|
| 490 | } |
---|
| 491 | } |
---|
| 492 | |
---|
| 493 | /* Didn't find any free pointers. Allocate more heap. |
---|
| 494 | Round up to next heap increment. */ |
---|
| 495 | i = ((msize + sizeof(long) + M_BRKINC - 1) / M_BRKINC) * M_BRKINC; |
---|
| 496 | if ((h = getmemblock (i)) == NULL) |
---|
| 497 | { |
---|
| 498 | #ifdef DEBUG |
---|
| 499 | printf ("xil_malloc: Out of dynamic memory.\n"); |
---|
| 500 | #endif |
---|
| 501 | return NULL; |
---|
| 502 | } |
---|
| 503 | |
---|
| 504 | /* Mark end of block with zero for four bytes so we don't merge next block |
---|
| 505 | into free list accidentally. */ |
---|
| 506 | setsize(h, i - sizeof(long)); |
---|
| 507 | *((long*)getend(h)) = 0; |
---|
| 508 | |
---|
| 509 | gotit: |
---|
| 510 | /* Merge allocated blocks so we can free a bigger part of what is left! */ |
---|
| 511 | coalesce(h); |
---|
| 512 | if (getsize(h) >= msize + M_BLOCKSIZE) |
---|
| 513 | { |
---|
| 514 | M_HEADERP r; |
---|
| 515 | int rsize; |
---|
| 516 | /* add the remainder of this block to the free list. */ |
---|
| 517 | rsize = getsize(h) - msize; |
---|
| 518 | r = (M_HEADERP) (((DATA_T *)h) + msize); |
---|
| 519 | setsize (r, rsize); |
---|
| 520 | setsize (h, msize); |
---|
| 521 | addtofreelist (r); |
---|
| 522 | } |
---|
| 523 | |
---|
| 524 | setalloced(h); |
---|
| 525 | setdbglev(h, mdebuglevel); |
---|
| 526 | if (mdebuglevel > M_DBG_NORMAL) |
---|
| 527 | { |
---|
| 528 | // Chain into alloc'd list and set sentinel. */ |
---|
| 529 | setsentinel(h, M_ALLOCED); |
---|
| 530 | setnext(h, alloclist); |
---|
| 531 | alloclist = h; |
---|
| 532 | } |
---|
| 533 | |
---|
| 534 | #ifdef DEBUG |
---|
| 535 | if (!m_reenter && m_prtflag) |
---|
| 536 | { |
---|
| 537 | m_reenter = 1; |
---|
| 538 | printf("%d malloc\n",h+1); |
---|
| 539 | fflush(stdout); |
---|
| 540 | if (m_stopaddr) |
---|
| 541 | { |
---|
| 542 | if ((DATA_T *)m_stopaddr == getdata(h)) |
---|
| 543 | { |
---|
| 544 | if (m_stopcnt == ++m_curcount) |
---|
| 545 | exit(10); |
---|
| 546 | } |
---|
| 547 | } |
---|
| 548 | m_reenter = 0; |
---|
| 549 | } |
---|
| 550 | #endif |
---|
| 551 | |
---|
| 552 | totalmalloc += getsize(h); |
---|
| 553 | if (totalmalloc > highwater) |
---|
| 554 | highwater = totalmalloc; |
---|
| 555 | |
---|
| 556 | return getdata(h); |
---|
| 557 | } |
---|
| 558 | |
---|
| 559 | void |
---|
| 560 | xil_free(void* ap) |
---|
| 561 | { |
---|
| 562 | M_HEADERP h; |
---|
| 563 | numfrees += 1; |
---|
| 564 | |
---|
| 565 | if (ap == NULL) |
---|
| 566 | { |
---|
| 567 | #ifdef DEBUG |
---|
| 568 | if (mdebuglevel != M_DBG_NORMAL && getenv(xil_mem_null_free)) |
---|
| 569 | die ("free: tried to free NULL pointer."); |
---|
| 570 | else |
---|
| 571 | return; /* Let `em do it. */ |
---|
| 572 | #else |
---|
| 573 | return; |
---|
| 574 | #endif |
---|
| 575 | } |
---|
| 576 | |
---|
| 577 | /* Drop through to here if not a smartheap allocation. This |
---|
| 578 | handles free of both xil_malloc and libc malloc. */ |
---|
| 579 | |
---|
| 580 | h = (M_HEADERP) (((DATA_T *)ap) - sizeof (struct M_HEADER)); |
---|
| 581 | |
---|
| 582 | if (h == zeroblock) |
---|
| 583 | return; |
---|
| 584 | |
---|
| 585 | #ifdef DEBUG |
---|
| 586 | if (!m_reenter && m_prtflag) { |
---|
| 587 | m_reenter = 1; |
---|
| 588 | printf("%d mfree\n",h+1); |
---|
| 589 | fflush(stdout); |
---|
| 590 | m_reenter = 0; |
---|
| 591 | } |
---|
| 592 | #endif |
---|
| 593 | |
---|
| 594 | if (!isalloced(h)) { |
---|
| 595 | if (isfree(h)) |
---|
| 596 | die ("free: tried to free pointer twice."); |
---|
| 597 | else |
---|
| 598 | die ("free: tried to free a block not allocated by malloc."); |
---|
| 599 | return; |
---|
| 600 | } |
---|
| 601 | |
---|
| 602 | if (getdbglev(h) > M_DBG_NORMAL) |
---|
| 603 | { |
---|
| 604 | /* Make sure things look reasonable. */ |
---|
| 605 | checkalloc(h); |
---|
| 606 | |
---|
| 607 | /* Try to find the pointer in the alloc list. */ |
---|
| 608 | if (alloclist == h) |
---|
| 609 | alloclist = getnext(h); |
---|
| 610 | else |
---|
| 611 | { |
---|
| 612 | M_HEADERP a = alloclist; |
---|
| 613 | while (a != NULL && getnext(a) != h) |
---|
| 614 | a = getnext(a); |
---|
| 615 | |
---|
| 616 | /* If a is NULL, debuglevel must have been reset at some point. */ |
---|
| 617 | if (a != NULL) |
---|
| 618 | setnext(a, getnext(h)); |
---|
| 619 | } |
---|
| 620 | } |
---|
| 621 | |
---|
| 622 | totalmalloc -= getsize(h); |
---|
| 623 | |
---|
| 624 | addtofreelist (h); |
---|
| 625 | |
---|
| 626 | if (mdebuglevel == M_DBG_FULL) |
---|
| 627 | { |
---|
| 628 | #ifdef DEBUG |
---|
| 629 | static unsigned do_cnt = ~0; |
---|
| 630 | static unsigned done_cnt = 0; |
---|
| 631 | if (do_cnt == ~0) |
---|
| 632 | { |
---|
| 633 | char *x = (char *)getenv(xil_mem_chkcnt); |
---|
| 634 | do_cnt = 1; |
---|
| 635 | if (x) |
---|
| 636 | do_cnt = atoi(x); |
---|
| 637 | } |
---|
| 638 | if (do_cnt == 1 || done_cnt % do_cnt == 0) |
---|
| 639 | xil_malloc_verify(); |
---|
| 640 | done_cnt++; |
---|
| 641 | #else |
---|
| 642 | xil_malloc_verify(); |
---|
| 643 | #endif |
---|
| 644 | } |
---|
| 645 | } |
---|
| 646 | |
---|
| 647 | unsigned |
---|
| 648 | xil_msize (void* ap) |
---|
| 649 | { |
---|
| 650 | M_HEADERP h = (M_HEADERP) (((DATA_T *)ap) - sizeof (struct M_HEADER)); |
---|
| 651 | return getdatasize(h); |
---|
| 652 | } |
---|
| 653 | |
---|
| 654 | void* |
---|
| 655 | xil_realloc (void* oldblk, size_t newsize ) |
---|
| 656 | { |
---|
| 657 | M_HEADERP h; |
---|
| 658 | size_t oldsize; |
---|
| 659 | void* newblk; |
---|
| 660 | |
---|
| 661 | numreallocs += 1; |
---|
| 662 | |
---|
| 663 | if (oldblk == NULL) |
---|
| 664 | { |
---|
| 665 | if (mdebuglevel != M_DBG_NORMAL) |
---|
| 666 | die ("realloc: tried to realloc NULL pointer."); |
---|
| 667 | else |
---|
| 668 | return xil_malloc(newsize); /* Don't need to copy anything. */ |
---|
| 669 | } |
---|
| 670 | |
---|
| 671 | /* Make sure this is a valid block. */ |
---|
| 672 | h = (M_HEADERP) (((char*)oldblk) - sizeof (struct M_HEADER)); |
---|
| 673 | |
---|
| 674 | /* if old block was zero bytes, just alloc a new one. */ |
---|
| 675 | if (h == zeroblock) |
---|
| 676 | return xil_malloc(newsize); /* Source is empty anyway. */ |
---|
| 677 | |
---|
| 678 | /* If old block was already freed, error. */ |
---|
| 679 | if (isfree(h)) |
---|
| 680 | die ("realloc: tried to realloc freed pointer."); |
---|
| 681 | |
---|
| 682 | if (!isalloced(h)) |
---|
| 683 | { |
---|
| 684 | long* pdesc = *(long**)h; /* Get pointer to the block descriptor. */ |
---|
| 685 | long* pnextdesc = (long*)*pdesc; |
---|
| 686 | if ((pdesc[1] & ~3) != (long)h) /* Should point back to block. */ |
---|
| 687 | die ("realloc: header clobbered."); |
---|
| 688 | |
---|
| 689 | /* This must be a libc block. We need to figure out how big it is. |
---|
| 690 | Length of block is delta between two descriptors - sizeof (void*). */ |
---|
| 691 | |
---|
| 692 | oldsize = (size_t) ((pnextdesc[1] & ~3) - (pdesc[1] & ~3)-sizeof(void*)); |
---|
| 693 | |
---|
| 694 | /* Don't bother to change anything unless there's not enough room. */ |
---|
| 695 | if (oldsize < newsize) |
---|
| 696 | { |
---|
| 697 | /* Alloc a new block with our malloc. */ |
---|
| 698 | if ((newblk = xil_malloc(newsize)) == NULL ) |
---|
| 699 | return NULL ; |
---|
| 700 | |
---|
| 701 | /* Copy the old data to it. */ |
---|
| 702 | memcpy (newblk, oldblk, (newsize < oldsize) ? newsize : oldsize); |
---|
| 703 | xil_free(oldblk); |
---|
| 704 | return newblk; |
---|
| 705 | } |
---|
| 706 | } |
---|
| 707 | |
---|
| 708 | /* If the new size is bigger than my allocated |
---|
| 709 | size, or if more than 1/4 of the block would be left free, allocate |
---|
| 710 | a new block and copy the data. Otherwise, leave well enough alone. */ |
---|
| 711 | |
---|
| 712 | coalesce(h); |
---|
| 713 | |
---|
| 714 | oldsize = getdatasize(h); |
---|
| 715 | |
---|
| 716 | if (oldsize < newsize |
---|
| 717 | || (newsize > (2*M_BLOCKSIZE) && (newsize*4) < (oldsize*3))) |
---|
| 718 | { |
---|
| 719 | if (( newblk = xil_malloc( newsize )) == NULL ) |
---|
| 720 | return NULL ; |
---|
| 721 | |
---|
| 722 | memcpy (newblk, oldblk, (newsize < oldsize) ? newsize : oldsize); |
---|
| 723 | |
---|
| 724 | xil_free (oldblk); |
---|
| 725 | return newblk; |
---|
| 726 | } |
---|
| 727 | else |
---|
| 728 | return oldblk; |
---|
| 729 | } |
---|
| 730 | |
---|
| 731 | void* |
---|
| 732 | xil_calloc (size_t number, size_t size) |
---|
| 733 | { |
---|
| 734 | long* longptr ; |
---|
| 735 | void* blockptr ; |
---|
| 736 | size_t temp = number * size + sizeof (long) - 1; |
---|
| 737 | temp -= temp % sizeof (long); |
---|
| 738 | |
---|
| 739 | blockptr = xil_malloc( temp ); |
---|
| 740 | if ( blockptr != 0 ) |
---|
| 741 | { |
---|
| 742 | longptr = (long*) blockptr ; |
---|
| 743 | temp /= sizeof (long); |
---|
| 744 | while ( temp-- > 0 ) |
---|
| 745 | { |
---|
| 746 | *longptr++ = 0 ; |
---|
| 747 | } |
---|
| 748 | } |
---|
| 749 | return blockptr ; |
---|
| 750 | } |
---|
| 751 | |
---|
| 752 | #define M_STAT_NORMAL 0 |
---|
| 753 | #define M_STAT_VERBOSE 1 |
---|
| 754 | #define M_STAT_REALLYVERBOSE 2 |
---|
| 755 | |
---|
| 756 | #ifdef DEBUG |
---|
| 757 | void |
---|
| 758 | xil_mstats(int verbosity) |
---|
| 759 | { |
---|
| 760 | unsigned long totalfree = 0; |
---|
| 761 | int i; |
---|
| 762 | printf("Memory Statics:\n" |
---|
| 763 | "---------------\n"); |
---|
| 764 | printf(" Number of calls to malloc: %ld.\n", nummallocs); |
---|
| 765 | printf(" Number of calls to free: %ld.\n", numfrees); |
---|
| 766 | printf(" Number of calls to realloc: %ld.\n", numreallocs); |
---|
| 767 | printf(" Total allocated memory: %lu (0x%lx)\n", |
---|
| 768 | totalallocated, totalallocated); |
---|
| 769 | printf(" Currently malloced memory: %lu (0x%lx)\n", |
---|
| 770 | totalmalloc, totalmalloc); |
---|
| 771 | fflush(stdout); |
---|
| 772 | |
---|
| 773 | |
---|
| 774 | for (i = 0; i < M_FREESIZE; i += 1) |
---|
| 775 | { |
---|
| 776 | M_HEADERP h = freelist[i]; |
---|
| 777 | unsigned long numblocks = 0; |
---|
| 778 | while (h != NULL) |
---|
| 779 | { |
---|
| 780 | totalfree += getsize(h); |
---|
| 781 | numblocks += 1; |
---|
| 782 | h = getnext(h); |
---|
| 783 | } |
---|
| 784 | if (verbosity > M_STAT_NORMAL && numblocks > 0) |
---|
| 785 | { |
---|
| 786 | printf(" There are %d blocks on freelist for size %d\n", |
---|
| 787 | numblocks, i * M_BLOCKSIZE); |
---|
| 788 | fflush(stdout); |
---|
| 789 | } |
---|
| 790 | } |
---|
| 791 | printf(" Currently free memory: %lu (0x%lx)\n", |
---|
| 792 | totalfree, totalfree); |
---|
| 793 | printf(" High water mark: %lu (0x%lx)\n", |
---|
| 794 | highwater, highwater); |
---|
| 795 | |
---|
| 796 | printf("\n"); |
---|
| 797 | fflush(stdout); |
---|
| 798 | } |
---|
| 799 | #else |
---|
| 800 | void |
---|
| 801 | xil_mstats(int verbosity) |
---|
| 802 | { |
---|
| 803 | } |
---|
| 804 | #endif |
---|