37#define __STDC_LIMIT_MACROS
48#include "scip/config.h"
65#ifndef SCIP_THREADSAFE
69#ifdef ENABLE_MEMLIST_CHECKS
85#ifdef SCIPdebugMessage
86#define debugMessage SCIPdebugMessage
87#define errorMessage SCIPerrorMessage
89#define debugMessage while( FALSE ) printf
90#define errorMessage printf
91#define printErrorHeader(f,l) printf("[%s:%d] ERROR: ", f, l)
92#define printError printf
95#ifdef ENABLE_MEMLIST_CHECKS
96#define warningMessage printf
98#define printInfo printf
106#define MAX(x,y) ((x) >= (y) ? (x) : (y))
107#define MIN(x,y) ((x) <= (y) ? (x) : (y))
110#ifndef SCIP_LONGINT_FORMAT
111#if defined(_WIN32) || defined(_WIN64)
112#define LONGINT_FORMAT "I64d"
114#define LONGINT_FORMAT "lld"
117#define LONGINT_FORMAT SCIP_LONGINT_FORMAT
120#ifndef SCIP_MAXMEMSIZE
122#define MAXMEMSIZE SIZE_MAX / 2
124#define MAXMEMSIZE SCIP_MAXMEMSIZE
129#if defined(_WIN32) || defined(_WIN64) || defined(__STDC__)
130#define INLINE __inline
143#if !defined(NDEBUG) && defined(ENABLE_MEMLIST_CHECKS)
158static size_t memused = 0;
178#define checkMemlist()
186 const char* filename,
212 const char* filename,
234 memused -=
list->size;
241 printError(
"Tried to free unknown pointer <%p>.\n", ptr);
278 printInfo(
"Total: %8llu\n", (
unsigned long long) memused);
279 if( used != memused )
281 errorMessage(
"Used memory in list sums up to %llu instead of %llu\n", (
unsigned long long)used, (
unsigned long long)memused);
303 return (
long long) memused;
308#define addMemlistEntry(ptr, size, filename, line) do { (void) (ptr); (void) (size); (void) (filename); (void) (line); } while(0)
309#define removeMemlistEntry(ptr, filename, line) do { (void) (ptr); (void) (filename); (void) (line); } while(0)
329 printInfo(
"Optimized, threadsafe version of memory shell linked - no memory diagnostics available.\n");
353 const char* filename,
361 debugMessage(
"calloc %llu elements of %llu bytes [%s:%d]\n", (
unsigned long long)num, (
unsigned long long)
typesize,
380 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)(num) * (
typesize));
391 const char* filename,
397 debugMessage(
"malloc %llu bytes [%s:%d]\n", (
unsigned long long)size, filename, line);
414 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)size);
426 const char* filename,
433 debugMessage(
"malloc %llu elements of %llu bytes [%s:%d]\n",
434 (
unsigned long long)num, (
unsigned long long)
typesize, filename, line);
452 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)size);
464 const char* filename,
488 printError(
"Insufficient memory for reallocation of %llu bytes.\n", (
unsigned long long)size);
501 const char* filename,
527 printError(
"Insufficient memory for reallocation of %llu bytes.\n", (
unsigned long long)size);
584 const char* filename,
604 const char* filename,
622 const char* filename,
644 const char* filename,
665#define CHKHASH_POWER 10
666#define CHKHASH_SIZE (1<<CHKHASH_POWER)
673 long long memallocated;
674 long long maxmemused;
675 long long maxmemunused;
676 long long maxmemallocated;
693#define CHUNKLENGTH_MIN 1024
694#define CHUNKLENGTH_MAX 1048576
695#define STORESIZE_MAX 8192
696#define GARBAGE_SIZE 256
697#define ALIGNMENT (sizeof(FREELIST))
748#define CHUNK_LT(ptr,chunk) ptr < chunk->store
749#define CHUNK_GT(ptr,chunk) ptr >= chunk->storeend
796 return (ptr >= (
void*)(
chunk->store) && ptr < (
void*)(
chunk->storeend));
900 storesize += chunk->storesize;
901 eagerfreesize += chunk->eagerfreesize;
904 assert(chkmem->nchunks == nchunks);
905 assert(chkmem->storesize == storesize);
906 assert(chkmem->eagerfreesize == eagerfreesize);
908 assert(((
unsigned int) (chkmem->eagerfreesize == 0)) ^ ( (
unsigned int) (chkmem->firsteager !=
NULL)));
910 if( chkmem->firsteager !=
NULL )
911 assert(chkmem->firsteager->preveager ==
NULL);
913 lazy = chkmem->lazyfree;
922 assert(chkmem->lazyfreesize == lazyfreesize);
925#define checkChunk(chunk)
926#define checkChkmem(chkmem)
946 debugMessage(
"linking chunk %p to chunk block %p [elemsize:%d, %d chunks]\n",
947 (
void*)
chunk, (
void*)chkmem, chkmem->elemsize, chkmem->nchunks);
955 chkmem->storesize +=
chunk->storesize;
973 chkmem =
chunk->chkmem;
977 debugMessage(
"unlinking chunk %p from chunk block %p [elemsize:%d, %d chunks]\n",
978 (
void*)
chunk, (
void*)chkmem, chkmem->elemsize, chkmem->nchunks);
984 chkmem->storesize -=
chunk->storesize;
998 chunk->nexteager = chkmem->firsteager;
1000 if( chkmem->firsteager !=
NULL )
1002 assert(chkmem->firsteager->preveager ==
NULL);
1003 chkmem->firsteager->preveager =
chunk;
1005 chkmem->firsteager =
chunk;
1018 chunk->nexteager->preveager =
chunk->preveager;
1020 chunk->preveager->nexteager =
chunk->nexteager;
1024 chunk->chkmem->firsteager =
chunk->nexteager;
1048 debugMessage(
"creating new chunk in chunk block %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1051 if( chkmem->nchunks == 0 )
1052 storesize = chkmem->initchunksize;
1054 storesize = 2 * chkmem->lastchunksize;
1059 storesize =
MAX(storesize, 1);
1060 chkmem->lastchunksize = storesize;
1077 newchunk->elemsize = chkmem->elemsize;
1081 if( memsize !=
NULL )
1082 (*memsize) += ((
long long)((
long long)
sizeof(
CHUNK) + (
long long)storesize * chkmem->elemsize));
1098 chkmem->lazyfreesize +=
newchunk->storesize;
1120 if( memsize !=
NULL )
1121 (*memsize) -= ((
long long)
sizeof(
CHUNK) + (
long long)(*chunk)->storesize * (*chunk)->elemsize);
1140 assert((*chunk)->chkmem->firsteager !=
NULL);
1141 assert((*chunk)->eagerfreesize == (*chunk)->storesize);
1143 debugMessage(
"freeing chunk %p of chunk block %p [elemsize: %d]\n", (
void*)*
chunk, (
void*)(*chunk)->chkmem, (*chunk)->chkmem->elemsize);
1146 (*chunk)->chkmem->eagerfreesize -= (*chunk)->eagerfreesize;
1147 assert((*chunk)->chkmem->eagerfreesize >= 0);
1172 debugMessage(
"allocating chunk element in chunk %p [elemsize: %d]\n", (
void*)
chunk,
chunk->chkmem->elemsize);
1175 ptr =
chunk->eagerfree;
1176 chunk->eagerfree = ptr->next;
1177 chunk->eagerfreesize--;
1178 chunk->chkmem->eagerfreesize--;
1207 debugMessage(
"freeing chunk element %p of chunk %p [elemsize: %d]\n", (
void*)ptr, (
void*)
chunk,
chunk->chkmem->elemsize);
1219 chunk->eagerfreesize++;
1220 chunk->chkmem->eagerfreesize++;
1241 if( chkmem ==
NULL )
1244 chkmem->lazyfree =
NULL;
1245 chkmem->rootchunk =
NULL;
1246 chkmem->firsteager =
NULL;
1247 chkmem->nextchkmem =
NULL;
1248 chkmem->elemsize = size;
1249 chkmem->nchunks = 0;
1250 chkmem->lastchunksize = 0;
1251 chkmem->storesize = 0;
1252 chkmem->lazyfreesize = 0;
1253 chkmem->eagerfreesize = 0;
1254 chkmem->initchunksize = initchunksize;
1255 chkmem->garbagefactor = garbagefactor;
1257 chkmem->filename =
NULL;
1259 chkmem->ngarbagecalls = 0;
1260 chkmem->ngarbagefrees = 0;
1263 if( memsize !=
NULL )
1281 SCIPrbtreeDelete(&chkmem->rootchunk, chunk);
1282 destroyChunk(&chunk, memsize);
1285 chkmem->lazyfree =
NULL;
1286 chkmem->firsteager =
NULL;
1287 chkmem->nchunks = 0;
1288 chkmem->lastchunksize = 0;
1289 chkmem->storesize = 0;
1290 chkmem->lazyfreesize = 0;
1291 chkmem->eagerfreesize = 0;
1310 if( memsize !=
NULL )
1311 (*memsize) -= (
long long)(
sizeof(
BMS_CHKMEM));
1328 if( chkmem->lazyfree ==
NULL )
1330 assert(chkmem->lazyfreesize == 0);
1333 if( chkmem->firsteager !=
NULL )
1343 assert(chkmem->lazyfreesize > 0);
1345 ptr = chkmem->lazyfree;
1346 chkmem->lazyfree = ptr->next;
1347 chkmem->lazyfreesize--;
1369 debugMessage(
"garbage collection for chunk block %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1372 if( chkmem->lazyfreesize + chkmem->eagerfreesize == chkmem->storesize )
1379 chkmem->ngarbagecalls++;
1383 while( chkmem->lazyfree !=
NULL )
1386 lazyfree = chkmem->lazyfree;
1387 chkmem->lazyfree = chkmem->lazyfree->next;
1388 chkmem->lazyfreesize--;
1395 errorMessage(
"chunk for lazy free chunk %p not found in chunk block %p\n", (
void*)lazyfree, (
void*)chkmem);
1404 assert(chkmem->lazyfreesize == 0);
1407 chunk = chkmem->firsteager;
1408 while(
chunk !=
NULL && chkmem->nchunks > 1 )
1410 nexteager =
chunk->nexteager;
1411 if(
chunk->eagerfreesize ==
chunk->storesize )
1414 chkmem->ngarbagefrees++;
1430 const char* filename,
1437#if ( defined(CHECKMEM) || defined(CHECKCHKFREE) )
1442 printError(
"Pointer %p does not belong to chunk block %p (size: %d).\n", ptr, chkmem, chkmem->elemsize);
1447 ((
FREELIST*)ptr)->next = chkmem->lazyfree;
1449 chkmem->lazyfreesize++;
1452 if( chkmem->garbagefactor >= 0 && chkmem->nchunks > 0 && chkmem->lazyfreesize >=
GARBAGE_SIZE
1453 && chkmem->lazyfreesize + chkmem->eagerfreesize
1454 > chkmem->garbagefactor * (
double)(chkmem->storesize) / (
double)(chkmem->nchunks) )
1468 const char* filename,
1476 if( chkmem ==
NULL )
1479 printError(
"Insufficient memory for chunk block.\n");
1481 debugMessage(
"created chunk memory %p [elemsize: %d]\n", (
void*)chkmem, (
int)size);
1489 const char* filename,
1493 debugMessage(
"clearing chunk memory %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1495 if( chkmem !=
NULL )
1500 printError(
"Tried to clear null chunk block.\n");
1507 const char* filename,
1513 debugMessage(
"destroying chunk memory %p [elemsize: %d]\n", (
void*)*chkmem, (*chkmem)->elemsize);
1515 if( *chkmem !=
NULL )
1520 printError(
"Tried to destroy null chunk block.\n");
1528 const char* filename,
1535 assert((
int)size == chkmem->elemsize);
1542 printError(
"Insufficient memory for new chunk.\n");
1544 debugMessage(
"alloced %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, (
void*)ptr, filename, line);
1556 const char* filename,
1564 assert((
int)size == chkmem->elemsize);
1578 const char* filename,
1583 assert((
int)size == chkmem->elemsize);
1588 debugMessage(
"free %8d bytes in %p [%s:%d]\n", chkmem->elemsize, *ptr, filename, line);
1598 printError(
"Tried to free null chunk pointer.\n");
1607 const char* filename,
1612 assert((
int)size == chkmem->elemsize);
1617 debugMessage(
"free %8d bytes in %p [%s:%d]\n", chkmem->elemsize, *ptr, filename, line);
1631 debugMessage(
"garbage collection on chunk memory %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1643 return ((
long long)(chkmem->elemsize) * (
long long)(chkmem->storesize));
1678 chkmem = blkmem->chkmemhash[
i];
1679 while( chkmem !=
NULL )
1683 tmpmemused += (chkmem->elemsize * (chkmem->storesize - chkmem->eagerfreesize - chkmem->lazyfreesize));
1684 chkmem = chkmem->nextchkmem;
1691#define checkBlkmem(blkmem)
1714 chkmem = blkmem->chkmemhash[
i];
1716 chkmem = chkmem->nextchkmem;
1739 const char* filename,
1747 if( blkmem !=
NULL )
1750 blkmem->chkmemhash[
i] =
NULL;
1751 blkmem->initchunksize = initchunksize;
1752 blkmem->garbagefactor = garbagefactor;
1753 blkmem->memused = 0;
1754 blkmem->memallocated = 0;
1755 blkmem->maxmemused = 0;
1756 blkmem->maxmemunused = 0;
1757 blkmem->maxmemallocated = 0;
1762 printError(
"Insufficient memory for block memory header.\n");
1771 const char* filename,
1779 if( blkmem !=
NULL )
1783 chkmem = blkmem->chkmemhash[
i];
1784 while( chkmem !=
NULL )
1786 nextchkmem = chkmem->nextchkmem;
1788 chkmem = nextchkmem;
1790 blkmem->chkmemhash[
i] =
NULL;
1792 blkmem->memused = 0;
1793 assert(blkmem->memallocated == 0);
1798 printError(
"Tried to clear null block memory.\n");
1805 const char* filename,
1811 if( *blkmem !=
NULL )
1820 printError(
"Tried to destroy null block memory.\n");
1829 const char* filename,
1845 while( *
chkmemptr !=
NULL && (*chkmemptr)->elemsize != (
int)size )
1846 chkmemptr = &((*chkmemptr)->nextchkmem);
1851 *
chkmemptr =
createChkmem((
int)size, blkmem->initchunksize, blkmem->garbagefactor, &blkmem->memallocated);
1855 printError(
"Insufficient memory for chunk block.\n");
1860 (*chkmemptr)->line = line;
1870 printError(
"Insufficient memory for new chunk.\n");
1872 debugMessage(
"alloced %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, ptr, filename, line);
1875 blkmem->memused += (
long long) size;
1876 blkmem->maxmemused =
MAX(blkmem->maxmemused, blkmem->memused);
1877 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
1878 blkmem->maxmemallocated =
MAX(blkmem->maxmemallocated, blkmem->memallocated);
1880 assert(blkmem->memused >= 0);
1881 assert(blkmem->memallocated >= 0);
1892 const char* filename,
1912 const char* filename,
1930 const char* filename,
1951 const char* filename,
1970 const char* filename,
2011 const char* filename,
2048 const char* filename,
2069 const char* filename,
2090 const char* filename,
2104 debugMessage(
"free %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, *ptr, filename, line);
2109 while( chkmem !=
NULL && chkmem->elemsize != (
int)size )
2110 chkmem = chkmem->nextchkmem;
2111 if( chkmem ==
NULL )
2114 printError(
"Tried to free pointer <%p> in block memory <%p> of unknown size %llu.\n", *ptr, (
void*)blkmem, (
unsigned long long)size);
2117 assert(chkmem->elemsize == (
int)size);
2121 blkmem->memused -= (
long long) size;
2123 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
2125 assert(blkmem->memused >= 0);
2126 assert(blkmem->memallocated >= 0);
2138 const char* filename,
2147 else if( size != 0 )
2150 printError(
"Tried to free null block pointer.\n");
2160 const char* filename,
2194 if( (*chkmemptr)->nchunks == 0 )
2198 assert((*chkmemptr)->lazyfreesize == 0);
2199 nextchkmem = (*chkmemptr)->nextchkmem;
2217 return blkmem->memallocated;
2227 return blkmem->memused;
2237 return blkmem->memallocated - blkmem->memused;
2247 return blkmem->maxmemused;
2257 return blkmem->maxmemunused;
2267 return blkmem->maxmemallocated;
2284 if( chkmem ==
NULL )
2287 return (
size_t)(chkmem->elemsize);
2312 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr #GCl #GFr Free MBytes First Allocator\n");
2314 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr Free MBytes\n");
2321 chkmem = blkmem->chkmemhash[
i];
2322 while( chkmem !=
NULL )
2331 assert(chunk != NULL);
2332 assert(chunk->elemsize == chkmem->elemsize);
2333 assert(chunk->chkmem == chkmem);
2335 nelems += chunk->storesize;
2336 if( chunk->eagerfree != NULL )
2339 neagerelems += chunk->eagerfreesize;
2343 assert(nchunks == chkmem->nchunks);
2344 assert(nelems == chkmem->storesize);
2350 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2351 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2354 printInfo(
"%7d %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f %s:%d\n",
2356 neagerelems, chkmem->lazyfreesize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2357 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2358 (
double)chkmem->elemsize * nelems / (1024.0*1024.0),
2359 chkmem->filename, chkmem->line);
2361 printInfo(
"%7d %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2364 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2365 (
double)chkmem->elemsize * nelems / (1024.0*1024.0));
2371 printInfo(
"%7d <unused> %5d %4d %s:%d\n",
2372 chkmem->elemsize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2373 chkmem->filename, chkmem->line);
2375 printInfo(
"%7d <unused>\n", chkmem->elemsize);
2388 chkmem = chkmem->nextchkmem;
2392 printInfo(
" Total %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f\n",
2398 printInfo(
" Total %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2409 printInfo(
"Memory Peaks: Used Lazy Total\n");
2410 printInfo(
" %6.1f %6.1f %6.1f MBytes\n", (
double)blkmem->maxmemused / (1024.0 * 1024.0),
2411 (
double)blkmem->maxmemunused / (1024.0 * 1024.0), (
double)blkmem->maxmemallocated / (1024.0 * 1024.0));
2428 chkmem = blkmem->chkmemhash[
i];
2429 while( chkmem !=
NULL )
2437 assert(chunk != NULL);
2438 assert(chunk->elemsize == chkmem->elemsize);
2439 assert(chunk->chkmem == chkmem);
2441 nelems += chunk->storesize;
2442 if( chunk->eagerfree != NULL )
2443 neagerelems += chunk->eagerfreesize;
2446 assert(nchunks == chkmem->nchunks);
2448 assert(nelems == chkmem->storesize);
2453 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2454 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2456 if( nelems !=
neagerelems + chkmem->lazyfreesize )
2460 (((
long long)nelems - (
long long)
neagerelems) - (
long long)chkmem->lazyfreesize)
2461 * (
long long)(chkmem->elemsize),
2462 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize),
2463 chkmem->filename, chkmem->line);
2466 ((nelems -
neagerelems) - chkmem->lazyfreesize) * (
long long)(chkmem->elemsize),
2467 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize));
2471 chkmem = chkmem->nextchkmem;
2511 double arraygrowfac,
2514 const char* filename,
2520 assert( arraygrowinit > 0 );
2521 assert( arraygrowfac > 0.0 );
2524 if ( buffer !=
NULL )
2530 buffer->
clean = clean;
2539 printError(
"Insufficient memory for buffer memory header.\n");
2548 const char* filename,
2554 if ( *buffer !=
NULL )
2556 i = (*buffer)->ndata;
2560 assert( ! (*buffer)->used[
i] );
2574 printError(
"Tried to free null buffer memory.\n");
2585 assert( arraygrowfac > 0.0 );
2597 assert( arraygrowinit > 0 );
2602#ifndef SCIP_NOBUFFERMEM
2653 const char* filename,
2659#ifndef SCIP_NOBUFFERMEM
2663#ifndef SCIP_NOBUFFERMEM
2683 printError(
"Insufficient memory for reallocating buffer data storage.\n");
2690 printError(
"Insufficient memory for reallocating buffer size storage.\n");
2697 printError(
"Insufficient memory for reallocating buffer used storage.\n");
2705 buffer->
size[
i] = 0;
2739 printError(
"Insufficient memory for reallocating buffer storage.\n");
2745#ifdef CHECKCLEANBUFFER
2762 debugMessage(
"Allocated buffer %llu/%llu at %p of size %llu (required size: %llu) for pointer %p.\n",
2764 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size, ptr);
2787 const char* filename,
2808 const char* filename,
2829 const char* filename,
2848 const char* filename,
2853#ifndef SCIP_NOBUFFERMEM
2857#ifndef SCIP_NOBUFFERMEM
2895 printError(
"Insufficient memory for reallocating buffer storage.\n");
2903 debugMessage(
"Reallocated buffer %llu/%llu at %p to size %llu (required size: %llu) for pointer %p.\n",
2905 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size,
newptr);
2920 const char* filename,
2942 const char* filename,
2963 const char* filename,
2987 const char* filename,
3010 const char* filename,
3030#ifdef CHECKBUFFERORDER
3033 warningMessage(
"[%s:%d]: freeing buffer in wrong order.\n", filename, line);
3041 printError(
"Tried to free unknown buffer pointer.\n");
3047 printError(
"Tried to free buffer pointer already freed.\n");
3052#ifdef CHECKCLEANBUFFER
3070 debugMessage(
"Freed buffer %llu/%llu at %p of size %llu for pointer %p, first free is %llu.\n",
3072 (
unsigned long long)(buffer->
size[
bufnum]), *ptr, (
unsigned long long)(buffer->
firstfree));
3081 const char* filename,
3087#ifndef SCIP_NOBUFFERMEM
3093 printError(
"Tried to free null buffer pointer.\n");
3104 const char* filename,
3112#ifndef SCIP_NOBUFFERMEM
3136 size_t totalmem = 0
UL;
3140 for (
i = 0;
i < buffer->
ndata; ++
i)
3141 totalmem += buffer->
size[
i];
3145 return (
long long) buffer->
totalmem;
3159 for (
i = 0;
i < buffer->
ndata; ++
i)
3161 printf(
"[%c] %8llu bytes at %p\n", buffer->
used[
i] ?
'*' :
' ', (
unsigned long long)(buffer->
size[
i]), buffer->
data[
i]);
3162 totalmem += buffer->
size[
i];
3164 printf(
" %8llu bytes total in %llu buffers\n", (
unsigned long long)totalmem, (
unsigned long long)(buffer->
ndata));
common defines and data types used in all packages of SCIP
if(SCIPgetNBinVars(scip)+SCIPgetNIntVars(scip)==0)
while((nfrac > 0||nviolrows > 0) &&nnonimprovingshifts< MAXSHIFTINGS &&!SCIPisStopped(scip))
assert(minobj< SCIPgetCutoffbound(scip))
static CHUNK * findChunk(const BMS_CHKMEM *chkmem, const void *ptr)
void BMSfreeChunkMemory_call(BMS_CHKMEM *chkmem, void **ptr, size_t size, const char *filename, int line)
void * BMSallocClearMemory_call(size_t num, size_t typesize, const char *filename, int line)
static int getHashNumber(int size)
static int isPtrInChkmem(const BMS_CHKMEM *chkmem, const void *ptr)
void * BMSduplicateBufferMemory_call(BMS_BUFMEM *buffer, const void *source, size_t size, const char *filename, int line)
void * BMSduplicateMemoryArray_call(const void *source, size_t num, size_t typesize, const char *filename, int line)
#define removeMemlistEntry(ptr, filename, line)
void * BMSallocMemory_call(size_t size, const char *filename, int line)
void BMSfreeBlockMemoryNull_call(BMS_BLKMEM *blkmem, void **ptr, size_t size, const char *filename, int line)
#define CHUNK_LT(ptr, chunk)
static void destroyChunk(CHUNK **chunk, long long *memsize)
void BMSgarbagecollectChunkMemory_call(BMS_CHKMEM *chkmem)
size_t BMSgetBlockPointerSize_call(const BMS_BLKMEM *blkmem, const void *ptr)
void BMSdisplayMemory_call(void)
static void destroyChkmem(BMS_CHKMEM **chkmem, long long *memsize)
static INLINE void BMSfreeBlockMemory_work(BMS_BLKMEM *blkmem, void **ptr, size_t size, const char *filename, int line)
int BMSisAligned(size_t size)
void BMSclearBlockMemory_call(BMS_BLKMEM *blkmem, const char *filename, int line)
#define CHUNK_GT(ptr, chunk)
long long BMScheckEmptyBlockMemory_call(const BMS_BLKMEM *blkmem)
long long BMSgetBufferMemoryUsed(const BMS_BUFMEM *buffer)
void BMSfreeBufferMemory_call(BMS_BUFMEM *buffer, void **ptr, const char *filename, int line)
void BMSfreeMemory_call(void **ptr, const char *filename, int line)
size_t BMSgetPointerSize_call(const void *ptr)
void * BMSreallocBlockMemory_call(BMS_BLKMEM *blkmem, void *ptr, size_t oldsize, size_t newsize, const char *filename, int line)
void BMSfreeMemoryNull_call(void **ptr, const char *filename, int line)
void BMSsetBufferMemoryArraygrowinit(BMS_BUFMEM *buffer, int arraygrowinit)
static void unlinkChunk(CHUNK *chunk)
void BMSdestroyBufferMemory_call(BMS_BUFMEM **buffer, const char *filename, int line)
#define addMemlistEntry(ptr, size, filename, line)
void BMSclearChunkMemory_call(BMS_CHKMEM *chkmem, const char *filename, int line)
void * BMSreallocBufferMemory_call(BMS_BUFMEM *buffer, void *ptr, size_t size, const char *filename, int line)
static INLINE void BMSfreeBufferMemory_work(BMS_BUFMEM *buffer, void **ptr, const char *filename, int line)
static size_t calcMemoryGrowSize(size_t initsize, SCIP_Real growfac, size_t num)
#define printErrorHeader(f, l)
void * BMSreallocMemoryArray_call(void *ptr, size_t num, size_t typesize, const char *filename, int line)
long long BMSgetBlockMemoryUsedMax_call(const BMS_BLKMEM *blkmem)
static BMS_CHKMEM * findChkmem(const BMS_BLKMEM *blkmem, const void *ptr)
static BMS_CHKMEM * createChkmem(int size, int initchunksize, int garbagefactor, long long *memsize)
void * BMSallocBufferMemoryArray_call(BMS_BUFMEM *buffer, size_t num, size_t typesize, const char *filename, int line)
void BMSmoveMemory_call(void *ptr, const void *source, size_t size)
static void freeChunk(CHUNK **chunk, long long *memsize)
static void freeChkmemElement(BMS_CHKMEM *chkmem, void *ptr, long long *memsize, const char *filename, int line)
static void freeChunkElement(CHUNK *chunk, void *ptr)
void * BMSallocBlockMemoryArray_call(BMS_BLKMEM *blkmem, size_t num, size_t typesize, const char *filename, int line)
static INLINE void * BMSallocBlockMemory_work(BMS_BLKMEM *blkmem, size_t size, const char *filename, int line)
void * BMSreallocBufferMemoryArray_call(BMS_BUFMEM *buffer, void *ptr, size_t num, size_t typesize, const char *filename, int line)
static void garbagecollectChkmem(BMS_CHKMEM *chkmem, long long *memsize)
void BMSdisplayBlockMemory_call(const BMS_BLKMEM *blkmem)
long long BMSgetBlockMemoryAllocated_call(const BMS_BLKMEM *blkmem)
void BMSclearMemory_call(void *ptr, size_t size)
long long BMSgetBlockMemoryUsed_call(const BMS_BLKMEM *blkmem)
void BMSfreeBufferMemoryNull_call(BMS_BUFMEM *buffer, void **ptr, const char *filename, int line)
void * BMSallocChunkMemory_call(BMS_CHKMEM *chkmem, size_t size, const char *filename, int line)
void * BMSreallocMemory_call(void *ptr, size_t size, const char *filename, int line)
BMS_BLKMEM * BMScreateBlockMemory_call(int initchunksize, int garbagefactor, const char *filename, int line)
void * BMSallocClearBlockMemoryArray_call(BMS_BLKMEM *blkmem, size_t num, size_t typesize, const char *filename, int line)
void * BMSduplicateBlockMemoryArray_call(BMS_BLKMEM *blkmem, const void *source, size_t num, size_t typesize, const char *filename, int line)
void * BMSduplicateMemory_call(const void *source, size_t size, const char *filename, int line)
BMS_BUFMEM * BMScreateBufferMemory_call(double arraygrowfac, int arraygrowinit, unsigned int clean, const char *filename, int line)
static INLINE void * BMSreallocBufferMemory_work(BMS_BUFMEM *buffer, void *ptr, size_t size, const char *filename, int line)
static void unlinkEagerChunk(CHUNK *chunk)
void BMSdestroyBlockMemory_call(BMS_BLKMEM **blkmem, const char *filename, int line)
static void linkEagerChunk(BMS_CHKMEM *chkmem, CHUNK *chunk)
void * BMSallocMemoryArray_call(size_t num, size_t typesize, const char *filename, int line)
long long BMSgetBlockMemoryUnused_call(const BMS_BLKMEM *blkmem)
void BMSprintBufferMemory(BMS_BUFMEM *buffer)
void * BMSduplicateChunkMemory_call(BMS_CHKMEM *chkmem, const void *source, size_t size, const char *filename, int line)
long long BMSgetMemoryUsed_call(void)
void BMScheckEmptyMemory_call(void)
static int linkChunk(BMS_CHKMEM *chkmem, CHUNK *chunk)
static void * allocChkmemElement(BMS_CHKMEM *chkmem, long long *memsize)
static void clearChkmem(BMS_CHKMEM *chkmem, long long *memsize)
#define checkBlkmem(blkmem)
void * BMSallocClearBlockMemory_call(BMS_BLKMEM *blkmem, size_t size, const char *filename, int line)
void * BMSallocBufferMemory_call(BMS_BUFMEM *buffer, size_t size, const char *filename, int line)
BMS_CHKMEM * BMScreateChunkMemory_call(size_t size, int initchunksize, int garbagefactor, const char *filename, int line)
static INLINE void * BMSallocBufferMemory_work(BMS_BUFMEM *buffer, size_t size, const char *filename, int line)
void * BMSallocBlockMemory_call(BMS_BLKMEM *blkmem, size_t size, const char *filename, int line)
void BMScopyMemory_call(void *ptr, const void *source, size_t size)
static void * allocChunkElement(CHUNK *chunk)
#define checkChkmem(chkmem)
static int createChunk(BMS_CHKMEM *chkmem, long long *memsize)
long long BMSgetChunkMemoryUsed_call(const BMS_CHKMEM *chkmem)
static static void alignSize(size_t *size)
void BMSfreeChunkMemoryNull_call(BMS_CHKMEM *chkmem, void **ptr, size_t size, const char *filename, int line)
void BMSsetBufferMemoryArraygrowfac(BMS_BUFMEM *buffer, double arraygrowfac)
static int isPtrInChunk(const CHUNK *chunk, const void *ptr)
void * BMSduplicateBufferMemoryArray_call(BMS_BUFMEM *buffer, const void *source, size_t num, size_t typesize, const char *filename, int line)
void BMSdestroyChunkMemory_call(BMS_CHKMEM **chkmem, const char *filename, int line)
void BMSgarbagecollectBlockMemory_call(BMS_BLKMEM *blkmem)
void BMSfreeBlockMemory_call(BMS_BLKMEM *blkmem, void **ptr, size_t size, const char *filename, int line)
void * BMSallocClearBufferMemoryArray_call(BMS_BUFMEM *buffer, size_t num, size_t typesize, const char *filename, int line)
long long BMSgetBlockMemoryUnusedMax_call(const BMS_BLKMEM *blkmem)
void * BMSduplicateBlockMemory_call(BMS_BLKMEM *blkmem, const void *source, size_t size, const char *filename, int line)
void BMSalignMemsize(size_t *size)
void * BMSreallocBlockMemoryArray_call(BMS_BLKMEM *blkmem, void *ptr, size_t oldnum, size_t newnum, size_t typesize, const char *filename, int line)
size_t BMSgetNUsedBufferMemory(BMS_BUFMEM *buffer)
long long BMSgetBlockMemoryAllocatedMax_call(const BMS_BLKMEM *blkmem)
#define checkChunk(chunk)
memory allocation routines
#define BMSallocClearMemorySize(ptr, size)
#define BMSfreeMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
struct BMS_ChkMem BMS_CHKMEM
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSreallocMemorySize(ptr, size)
#define BMScopyMemorySize(ptr, source, size)
#define BMSclearMemorySize(ptr, size)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemorySize(ptr, size)
#define BMSallocMemory(ptr)
public methods for message output
intrusive red black tree datastructure
#define SCIP_RBTREE_HOOKS
#define SCIPrbtreeDelete(root, node)
#define SCIPrbtreeInsert(r, p, c, n)
#define SCIP_DEF_RBTREE_FIND(NAME, KEYTYPE, NODETYPE, LT, GT)
#define FOR_EACH_NODE(type, n, r, body)
unsigned int arraygrowinit