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;
1868 (*chkmemptr)->line = line;
1878 printError(
"Insufficient memory for new chunk.\n");
1880 debugMessage(
"alloced %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, ptr, filename, line);
1883 blkmem->memused += (
long long) size;
1884 blkmem->maxmemused =
MAX(blkmem->maxmemused, blkmem->memused);
1885 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
1886 blkmem->maxmemallocated =
MAX(blkmem->maxmemallocated, blkmem->memallocated);
1888 assert(blkmem->memused >= 0);
1889 assert(blkmem->memallocated >= 0);
1900 const char* filename,
1920 const char* filename,
1938 const char* filename,
1959 const char* filename,
1978 const char* filename,
2019 const char* filename,
2056 const char* filename,
2077 const char* filename,
2098 const char* filename,
2112 debugMessage(
"free %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, *ptr, filename, line);
2117 while( chkmem !=
NULL && chkmem->elemsize != (
int)size )
2118 chkmem = chkmem->nextchkmem;
2119 if( chkmem ==
NULL )
2122 printError(
"Tried to free pointer <%p> in block memory <%p> of unknown size %llu.\n", *ptr, (
void*)blkmem, (
unsigned long long)size);
2125 assert(chkmem->elemsize == (
int)size);
2129 blkmem->memused -= (
long long) size;
2131 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
2133 assert(blkmem->memused >= 0);
2134 assert(blkmem->memallocated >= 0);
2146 const char* filename,
2155 else if( size != 0 )
2158 printError(
"Tried to free null block pointer.\n");
2168 const char* filename,
2202 if( (*chkmemptr)->nchunks == 0 )
2206 assert((*chkmemptr)->lazyfreesize == 0);
2207 nextchkmem = (*chkmemptr)->nextchkmem;
2225 return blkmem->memallocated;
2235 return blkmem->memused;
2245 return blkmem->memallocated - blkmem->memused;
2255 return blkmem->maxmemused;
2265 return blkmem->maxmemunused;
2275 return blkmem->maxmemallocated;
2292 if( chkmem ==
NULL )
2295 return (
size_t)(chkmem->elemsize);
2320 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr #GCl #GFr Free MBytes First Allocator\n");
2322 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr Free MBytes\n");
2329 chkmem = blkmem->chkmemhash[
i];
2330 while( chkmem !=
NULL )
2339 assert(chunk != NULL);
2340 assert(chunk->elemsize == chkmem->elemsize);
2341 assert(chunk->chkmem == chkmem);
2343 nelems += chunk->storesize;
2344 if( chunk->eagerfree != NULL )
2347 neagerelems += chunk->eagerfreesize;
2351 assert(nchunks == chkmem->nchunks);
2352 assert(nelems == chkmem->storesize);
2358 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2359 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2362 printInfo(
"%7d %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f %s:%d\n",
2364 neagerelems, chkmem->lazyfreesize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2365 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2366 (
double)chkmem->elemsize * nelems / (1024.0*1024.0),
2367 chkmem->filename, chkmem->line);
2369 printInfo(
"%7d %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2372 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2373 (
double)chkmem->elemsize * nelems / (1024.0*1024.0));
2379 printInfo(
"%7d <unused> %5d %4d %s:%d\n",
2380 chkmem->elemsize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2381 chkmem->filename, chkmem->line);
2383 printInfo(
"%7d <unused>\n", chkmem->elemsize);
2396 chkmem = chkmem->nextchkmem;
2400 printInfo(
" Total %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f\n",
2406 printInfo(
" Total %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2417 printInfo(
"Memory Peaks: Used Lazy Total\n");
2418 printInfo(
" %6.1f %6.1f %6.1f MBytes\n", (
double)blkmem->maxmemused / (1024.0 * 1024.0),
2419 (
double)blkmem->maxmemunused / (1024.0 * 1024.0), (
double)blkmem->maxmemallocated / (1024.0 * 1024.0));
2436 chkmem = blkmem->chkmemhash[
i];
2437 while( chkmem !=
NULL )
2445 assert(chunk != NULL);
2446 assert(chunk->elemsize == chkmem->elemsize);
2447 assert(chunk->chkmem == chkmem);
2449 nelems += chunk->storesize;
2450 if( chunk->eagerfree != NULL )
2451 neagerelems += chunk->eagerfreesize;
2454 assert(nchunks == chkmem->nchunks);
2456 assert(nelems == chkmem->storesize);
2461 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2462 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2464 if( nelems !=
neagerelems + chkmem->lazyfreesize )
2468 (((
long long)nelems - (
long long)
neagerelems) - (
long long)chkmem->lazyfreesize)
2469 * (
long long)(chkmem->elemsize),
2470 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize),
2471 chkmem->filename, chkmem->line);
2474 ((nelems -
neagerelems) - chkmem->lazyfreesize) * (
long long)(chkmem->elemsize),
2475 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize));
2479 chkmem = chkmem->nextchkmem;
2519 double arraygrowfac,
2522 const char* filename,
2528 assert( arraygrowinit > 0 );
2529 assert( arraygrowfac > 0.0 );
2532 if ( buffer !=
NULL )
2538 buffer->
clean = clean;
2547 printError(
"Insufficient memory for buffer memory header.\n");
2556 const char* filename,
2562 if ( *buffer !=
NULL )
2564 i = (*buffer)->ndata;
2568 assert( ! (*buffer)->used[
i] );
2582 printError(
"Tried to free null buffer memory.\n");
2593 assert( arraygrowfac > 0.0 );
2605 assert( arraygrowinit > 0 );
2610#ifndef SCIP_NOBUFFERMEM
2661 const char* filename,
2667#ifndef SCIP_NOBUFFERMEM
2671#ifndef SCIP_NOBUFFERMEM
2691 printError(
"Insufficient memory for reallocating buffer data storage.\n");
2698 printError(
"Insufficient memory for reallocating buffer size storage.\n");
2705 printError(
"Insufficient memory for reallocating buffer used storage.\n");
2713 buffer->
size[
i] = 0;
2747 printError(
"Insufficient memory for reallocating buffer storage.\n");
2753#ifdef CHECKCLEANBUFFER
2770 debugMessage(
"Allocated buffer %llu/%llu at %p of size %llu (required size: %llu) for pointer %p.\n",
2772 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size, ptr);
2795 const char* filename,
2816 const char* filename,
2837 const char* filename,
2856 const char* filename,
2861#ifndef SCIP_NOBUFFERMEM
2865#ifndef SCIP_NOBUFFERMEM
2903 printError(
"Insufficient memory for reallocating buffer storage.\n");
2911 debugMessage(
"Reallocated buffer %llu/%llu at %p to size %llu (required size: %llu) for pointer %p.\n",
2913 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size,
newptr);
2928 const char* filename,
2950 const char* filename,
2971 const char* filename,
2995 const char* filename,
3018 const char* filename,
3038#ifdef CHECKBUFFERORDER
3041 warningMessage(
"[%s:%d]: freeing buffer in wrong order.\n", filename, line);
3049 printError(
"Tried to free unknown buffer pointer.\n");
3055 printError(
"Tried to free buffer pointer already freed.\n");
3060#ifdef CHECKCLEANBUFFER
3078 debugMessage(
"Freed buffer %llu/%llu at %p of size %llu for pointer %p, first free is %llu.\n",
3080 (
unsigned long long)(buffer->
size[
bufnum]), *ptr, (
unsigned long long)(buffer->
firstfree));
3089 const char* filename,
3095#ifndef SCIP_NOBUFFERMEM
3101 printError(
"Tried to free null buffer pointer.\n");
3112 const char* filename,
3120#ifndef SCIP_NOBUFFERMEM
3144 size_t totalmem = 0
UL;
3148 for (
i = 0;
i < buffer->
ndata; ++
i)
3149 totalmem += buffer->
size[
i];
3153 return (
long long) buffer->
totalmem;
3167 for (
i = 0;
i < buffer->
ndata; ++
i)
3169 printf(
"[%c] %8llu bytes at %p\n", buffer->
used[
i] ?
'*' :
' ', (
unsigned long long)(buffer->
size[
i]), buffer->
data[
i]);
3170 totalmem += buffer->
size[
i];
3172 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