37#define __STDC_LIMIT_MACROS
48#ifndef NO_CONFIG_HEADER
49#include "scip/config.h"
67#ifndef SCIP_THREADSAFE
71#ifdef ENABLE_MEMLIST_CHECKS
87#ifdef SCIPdebugMessage
88#define debugMessage SCIPdebugMessage
89#define errorMessage SCIPerrorMessage
91#define debugMessage while( FALSE ) printf
92#define errorMessage printf
93#define printErrorHeader(f,l) printf("[%s:%d] ERROR: ", f, l)
94#define printError printf
97#ifdef ENABLE_MEMLIST_CHECKS
98#define warningMessage printf
100#define printInfo printf
108#define MAX(x,y) ((x) >= (y) ? (x) : (y))
109#define MIN(x,y) ((x) <= (y) ? (x) : (y))
112#ifndef SCIP_LONGINT_FORMAT
113#if defined(_WIN32) || defined(_WIN64)
114#define LONGINT_FORMAT "I64d"
116#define LONGINT_FORMAT "lld"
119#define LONGINT_FORMAT SCIP_LONGINT_FORMAT
122#ifndef SCIP_MAXMEMSIZE
124#define MAXMEMSIZE SIZE_MAX / 2
126#define MAXMEMSIZE SCIP_MAXMEMSIZE
131#if defined(_WIN32) || defined(_WIN64) || defined(__STDC__)
132#define INLINE __inline
145#if !defined(NDEBUG) && defined(ENABLE_MEMLIST_CHECKS)
160static size_t memused = 0;
180#define checkMemlist()
188 const char* filename,
214 const char* filename,
236 memused -=
list->size;
243 printError(
"Tried to free unknown pointer <%p>.\n", ptr);
280 printInfo(
"Total: %8llu\n", (
unsigned long long) memused);
281 if( used != memused )
283 errorMessage(
"Used memory in list sums up to %llu instead of %llu\n", (
unsigned long long)used, (
unsigned long long)memused);
305 return (
long long) memused;
310#define addMemlistEntry(ptr, size, filename, line) do { (void) (ptr); (void) (size); (void) (filename); (void) (line); } while(0)
311#define removeMemlistEntry(ptr, filename, line) do { (void) (ptr); (void) (filename); (void) (line); } while(0)
331 printInfo(
"Optimized, threadsafe version of memory shell linked - no memory diagnostics available.\n");
355 const char* filename,
363 debugMessage(
"calloc %llu elements of %llu bytes [%s:%d]\n", (
unsigned long long)num, (
unsigned long long)
typesize,
382 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)(num) * (
typesize));
393 const char* filename,
399 debugMessage(
"malloc %llu bytes [%s:%d]\n", (
unsigned long long)size, filename, line);
416 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)size);
428 const char* filename,
435 debugMessage(
"malloc %llu elements of %llu bytes [%s:%d]\n",
436 (
unsigned long long)num, (
unsigned long long)
typesize, filename, line);
454 printError(
"Insufficient memory for allocation of %llu bytes.\n", (
unsigned long long)size);
466 const char* filename,
490 printError(
"Insufficient memory for reallocation of %llu bytes.\n", (
unsigned long long)size);
503 const char* filename,
529 printError(
"Insufficient memory for reallocation of %llu bytes.\n", (
unsigned long long)size);
586 const char* filename,
606 const char* filename,
624 const char* filename,
646 const char* filename,
667#define CHKHASH_POWER 10
668#define CHKHASH_SIZE (1<<CHKHASH_POWER)
675 long long memallocated;
676 long long maxmemused;
677 long long maxmemunused;
678 long long maxmemallocated;
695#define CHUNKLENGTH_MIN 1024
696#define CHUNKLENGTH_MAX 1048576
697#define STORESIZE_MAX 8192
698#define GARBAGE_SIZE 256
699#define ALIGNMENT (sizeof(FREELIST))
750#define CHUNK_LT(ptr,chunk) ptr < chunk->store
751#define CHUNK_GT(ptr,chunk) ptr >= chunk->storeend
798 return (ptr >= (
void*)(
chunk->store) && ptr < (
void*)(
chunk->storeend));
902 storesize += chunk->storesize;
903 eagerfreesize += chunk->eagerfreesize;
906 assert(chkmem->nchunks == nchunks);
907 assert(chkmem->storesize == storesize);
908 assert(chkmem->eagerfreesize == eagerfreesize);
910 assert(((
unsigned int) (chkmem->eagerfreesize == 0)) ^ ( (
unsigned int) (chkmem->firsteager !=
NULL)));
912 if( chkmem->firsteager !=
NULL )
913 assert(chkmem->firsteager->preveager ==
NULL);
915 lazy = chkmem->lazyfree;
924 assert(chkmem->lazyfreesize == lazyfreesize);
927#define checkChunk(chunk)
928#define checkChkmem(chkmem)
948 debugMessage(
"linking chunk %p to chunk block %p [elemsize:%d, %d chunks]\n",
949 (
void*)
chunk, (
void*)chkmem, chkmem->elemsize, chkmem->nchunks);
957 chkmem->storesize +=
chunk->storesize;
975 chkmem =
chunk->chkmem;
979 debugMessage(
"unlinking chunk %p from chunk block %p [elemsize:%d, %d chunks]\n",
980 (
void*)
chunk, (
void*)chkmem, chkmem->elemsize, chkmem->nchunks);
986 chkmem->storesize -=
chunk->storesize;
1000 chunk->nexteager = chkmem->firsteager;
1002 if( chkmem->firsteager !=
NULL )
1004 assert(chkmem->firsteager->preveager ==
NULL);
1005 chkmem->firsteager->preveager =
chunk;
1007 chkmem->firsteager =
chunk;
1020 chunk->nexteager->preveager =
chunk->preveager;
1022 chunk->preveager->nexteager =
chunk->nexteager;
1026 chunk->chkmem->firsteager =
chunk->nexteager;
1050 debugMessage(
"creating new chunk in chunk block %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1053 if( chkmem->nchunks == 0 )
1054 storesize = chkmem->initchunksize;
1056 storesize = 2 * chkmem->lastchunksize;
1061 storesize =
MAX(storesize, 1);
1062 chkmem->lastchunksize = storesize;
1079 newchunk->elemsize = chkmem->elemsize;
1083 if( memsize !=
NULL )
1084 (*memsize) += ((
long long)((
long long)
sizeof(
CHUNK) + (
long long)storesize * chkmem->elemsize));
1100 chkmem->lazyfreesize +=
newchunk->storesize;
1122 if( memsize !=
NULL )
1123 (*memsize) -= ((
long long)
sizeof(
CHUNK) + (
long long)(*chunk)->storesize * (*chunk)->elemsize);
1142 assert((*chunk)->chkmem->firsteager !=
NULL);
1143 assert((*chunk)->eagerfreesize == (*chunk)->storesize);
1145 debugMessage(
"freeing chunk %p of chunk block %p [elemsize: %d]\n", (
void*)*
chunk, (
void*)(*chunk)->chkmem, (*chunk)->chkmem->elemsize);
1148 (*chunk)->chkmem->eagerfreesize -= (*chunk)->eagerfreesize;
1149 assert((*chunk)->chkmem->eagerfreesize >= 0);
1174 debugMessage(
"allocating chunk element in chunk %p [elemsize: %d]\n", (
void*)
chunk,
chunk->chkmem->elemsize);
1177 ptr =
chunk->eagerfree;
1178 chunk->eagerfree = ptr->next;
1179 chunk->eagerfreesize--;
1180 chunk->chkmem->eagerfreesize--;
1209 debugMessage(
"freeing chunk element %p of chunk %p [elemsize: %d]\n", (
void*)ptr, (
void*)
chunk,
chunk->chkmem->elemsize);
1221 chunk->eagerfreesize++;
1222 chunk->chkmem->eagerfreesize++;
1243 if( chkmem ==
NULL )
1246 chkmem->lazyfree =
NULL;
1247 chkmem->rootchunk =
NULL;
1248 chkmem->firsteager =
NULL;
1249 chkmem->nextchkmem =
NULL;
1250 chkmem->elemsize = size;
1251 chkmem->nchunks = 0;
1252 chkmem->lastchunksize = 0;
1253 chkmem->storesize = 0;
1254 chkmem->lazyfreesize = 0;
1255 chkmem->eagerfreesize = 0;
1256 chkmem->initchunksize = initchunksize;
1257 chkmem->garbagefactor = garbagefactor;
1259 chkmem->filename =
NULL;
1261 chkmem->ngarbagecalls = 0;
1262 chkmem->ngarbagefrees = 0;
1265 if( memsize !=
NULL )
1283 SCIPrbtreeDelete(&chkmem->rootchunk, chunk);
1284 destroyChunk(&chunk, memsize);
1287 chkmem->lazyfree =
NULL;
1288 chkmem->firsteager =
NULL;
1289 chkmem->nchunks = 0;
1290 chkmem->lastchunksize = 0;
1291 chkmem->storesize = 0;
1292 chkmem->lazyfreesize = 0;
1293 chkmem->eagerfreesize = 0;
1312 if( memsize !=
NULL )
1313 (*memsize) -= (
long long)(
sizeof(
BMS_CHKMEM));
1330 if( chkmem->lazyfree ==
NULL )
1332 assert(chkmem->lazyfreesize == 0);
1335 if( chkmem->firsteager !=
NULL )
1345 assert(chkmem->lazyfreesize > 0);
1347 ptr = chkmem->lazyfree;
1348 chkmem->lazyfree = ptr->next;
1349 chkmem->lazyfreesize--;
1371 debugMessage(
"garbage collection for chunk block %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1374 if( chkmem->lazyfreesize + chkmem->eagerfreesize == chkmem->storesize )
1381 chkmem->ngarbagecalls++;
1385 while( chkmem->lazyfree !=
NULL )
1388 lazyfree = chkmem->lazyfree;
1389 chkmem->lazyfree = chkmem->lazyfree->next;
1390 chkmem->lazyfreesize--;
1397 errorMessage(
"chunk for lazy free chunk %p not found in chunk block %p\n", (
void*)lazyfree, (
void*)chkmem);
1406 assert(chkmem->lazyfreesize == 0);
1409 chunk = chkmem->firsteager;
1410 while(
chunk !=
NULL && chkmem->nchunks > 1 )
1412 nexteager =
chunk->nexteager;
1413 if(
chunk->eagerfreesize ==
chunk->storesize )
1416 chkmem->ngarbagefrees++;
1432 const char* filename,
1439#if ( defined(CHECKMEM) || defined(CHECKCHKFREE) )
1444 printError(
"Pointer %p does not belong to chunk block %p (size: %d).\n", ptr, chkmem, chkmem->elemsize);
1449 ((
FREELIST*)ptr)->next = chkmem->lazyfree;
1451 chkmem->lazyfreesize++;
1454 if( chkmem->garbagefactor >= 0 && chkmem->nchunks > 0 && chkmem->lazyfreesize >=
GARBAGE_SIZE
1455 && chkmem->lazyfreesize + chkmem->eagerfreesize
1456 > chkmem->garbagefactor * (
double)(chkmem->storesize) / (
double)(chkmem->nchunks) )
1470 const char* filename,
1478 if( chkmem ==
NULL )
1481 printError(
"Insufficient memory for chunk block.\n");
1483 debugMessage(
"created chunk memory %p [elemsize: %d]\n", (
void*)chkmem, (
int)size);
1491 const char* filename,
1495 debugMessage(
"clearing chunk memory %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1497 if( chkmem !=
NULL )
1502 printError(
"Tried to clear null chunk block.\n");
1509 const char* filename,
1515 debugMessage(
"destroying chunk memory %p [elemsize: %d]\n", (
void*)*chkmem, (*chkmem)->elemsize);
1517 if( *chkmem !=
NULL )
1522 printError(
"Tried to destroy null chunk block.\n");
1530 const char* filename,
1537 assert((
int)size == chkmem->elemsize);
1544 printError(
"Insufficient memory for new chunk.\n");
1546 debugMessage(
"alloced %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, (
void*)ptr, filename, line);
1558 const char* filename,
1566 assert((
int)size == chkmem->elemsize);
1580 const char* filename,
1585 assert((
int)size == chkmem->elemsize);
1590 debugMessage(
"free %8d bytes in %p [%s:%d]\n", chkmem->elemsize, *ptr, filename, line);
1600 printError(
"Tried to free null chunk pointer.\n");
1609 const char* filename,
1614 assert((
int)size == chkmem->elemsize);
1619 debugMessage(
"free %8d bytes in %p [%s:%d]\n", chkmem->elemsize, *ptr, filename, line);
1633 debugMessage(
"garbage collection on chunk memory %p [elemsize: %d]\n", (
void*)chkmem, chkmem->elemsize);
1645 return ((
long long)(chkmem->elemsize) * (
long long)(chkmem->storesize));
1680 chkmem = blkmem->chkmemhash[
i];
1681 while( chkmem !=
NULL )
1685 tmpmemused += (chkmem->elemsize * (chkmem->storesize - chkmem->eagerfreesize - chkmem->lazyfreesize));
1686 chkmem = chkmem->nextchkmem;
1693#define checkBlkmem(blkmem)
1716 chkmem = blkmem->chkmemhash[
i];
1718 chkmem = chkmem->nextchkmem;
1741 const char* filename,
1749 if( blkmem !=
NULL )
1752 blkmem->chkmemhash[
i] =
NULL;
1753 blkmem->initchunksize = initchunksize;
1754 blkmem->garbagefactor = garbagefactor;
1755 blkmem->memused = 0;
1756 blkmem->memallocated = 0;
1757 blkmem->maxmemused = 0;
1758 blkmem->maxmemunused = 0;
1759 blkmem->maxmemallocated = 0;
1764 printError(
"Insufficient memory for block memory header.\n");
1773 const char* filename,
1781 if( blkmem !=
NULL )
1785 chkmem = blkmem->chkmemhash[
i];
1786 while( chkmem !=
NULL )
1788 nextchkmem = chkmem->nextchkmem;
1790 chkmem = nextchkmem;
1792 blkmem->chkmemhash[
i] =
NULL;
1794 blkmem->memused = 0;
1795 assert(blkmem->memallocated == 0);
1800 printError(
"Tried to clear null block memory.\n");
1807 const char* filename,
1813 if( *blkmem !=
NULL )
1822 printError(
"Tried to destroy null block memory.\n");
1831 const char* filename,
1847 while( *
chkmemptr !=
NULL && (*chkmemptr)->elemsize != (
int)size )
1848 chkmemptr = &((*chkmemptr)->nextchkmem);
1853 *
chkmemptr =
createChkmem((
int)size, blkmem->initchunksize, blkmem->garbagefactor, &blkmem->memallocated);
1857 printError(
"Insufficient memory for chunk block.\n");
1862 (*chkmemptr)->line = line;
1872 printError(
"Insufficient memory for new chunk.\n");
1874 debugMessage(
"alloced %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, ptr, filename, line);
1877 blkmem->memused += (
long long) size;
1878 blkmem->maxmemused =
MAX(blkmem->maxmemused, blkmem->memused);
1879 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
1880 blkmem->maxmemallocated =
MAX(blkmem->maxmemallocated, blkmem->memallocated);
1882 assert(blkmem->memused >= 0);
1883 assert(blkmem->memallocated >= 0);
1894 const char* filename,
1914 const char* filename,
1932 const char* filename,
1953 const char* filename,
1972 const char* filename,
2013 const char* filename,
2050 const char* filename,
2071 const char* filename,
2092 const char* filename,
2106 debugMessage(
"free %8llu bytes in %p [%s:%d]\n", (
unsigned long long)size, *ptr, filename, line);
2111 while( chkmem !=
NULL && chkmem->elemsize != (
int)size )
2112 chkmem = chkmem->nextchkmem;
2113 if( chkmem ==
NULL )
2116 printError(
"Tried to free pointer <%p> in block memory <%p> of unknown size %llu.\n", *ptr, (
void*)blkmem, (
unsigned long long)size);
2119 assert(chkmem->elemsize == (
int)size);
2123 blkmem->memused -= (
long long) size;
2125 blkmem->maxmemunused =
MAX(blkmem->maxmemunused, blkmem->memallocated - blkmem->memused);
2127 assert(blkmem->memused >= 0);
2128 assert(blkmem->memallocated >= 0);
2140 const char* filename,
2149 else if( size != 0 )
2152 printError(
"Tried to free null block pointer.\n");
2162 const char* filename,
2196 if( (*chkmemptr)->nchunks == 0 )
2200 assert((*chkmemptr)->lazyfreesize == 0);
2201 nextchkmem = (*chkmemptr)->nextchkmem;
2219 return blkmem->memallocated;
2229 return blkmem->memused;
2239 return blkmem->memallocated - blkmem->memused;
2249 return blkmem->maxmemused;
2259 return blkmem->maxmemunused;
2269 return blkmem->maxmemallocated;
2286 if( chkmem ==
NULL )
2289 return (
size_t)(chkmem->elemsize);
2314 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr #GCl #GFr Free MBytes First Allocator\n");
2316 printInfo(
" ElSize #Chunk #Eag #Elems #EagFr #LazFr Free MBytes\n");
2323 chkmem = blkmem->chkmemhash[
i];
2324 while( chkmem !=
NULL )
2333 assert(chunk != NULL);
2334 assert(chunk->elemsize == chkmem->elemsize);
2335 assert(chunk->chkmem == chkmem);
2337 nelems += chunk->storesize;
2338 if( chunk->eagerfree != NULL )
2341 neagerelems += chunk->eagerfreesize;
2345 assert(nchunks == chkmem->nchunks);
2346 assert(nelems == chkmem->storesize);
2352 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2353 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2356 printInfo(
"%7d %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f %s:%d\n",
2358 neagerelems, chkmem->lazyfreesize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2359 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2360 (
double)chkmem->elemsize * nelems / (1024.0*1024.0),
2361 chkmem->filename, chkmem->line);
2363 printInfo(
"%7d %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2366 100.0 * (
double) (
neagerelems + chkmem->lazyfreesize) / (
double) (nelems),
2367 (
double)chkmem->elemsize * nelems / (1024.0*1024.0));
2373 printInfo(
"%7d <unused> %5d %4d %s:%d\n",
2374 chkmem->elemsize, chkmem->ngarbagecalls, chkmem->ngarbagefrees,
2375 chkmem->filename, chkmem->line);
2377 printInfo(
"%7d <unused>\n", chkmem->elemsize);
2390 chkmem = chkmem->nextchkmem;
2394 printInfo(
" Total %6d %4d %7d %7d %7d %5d %4d %5.1f%% %6.1f\n",
2400 printInfo(
" Total %6d %4d %7d %7d %7d %5.1f%% %6.1f\n",
2411 printInfo(
"Memory Peaks: Used Lazy Total\n");
2412 printInfo(
" %6.1f %6.1f %6.1f MBytes\n", (
double)blkmem->maxmemused / (1024.0 * 1024.0),
2413 (
double)blkmem->maxmemunused / (1024.0 * 1024.0), (
double)blkmem->maxmemallocated / (1024.0 * 1024.0));
2430 chkmem = blkmem->chkmemhash[
i];
2431 while( chkmem !=
NULL )
2439 assert(chunk != NULL);
2440 assert(chunk->elemsize == chkmem->elemsize);
2441 assert(chunk->chkmem == chkmem);
2443 nelems += chunk->storesize;
2444 if( chunk->eagerfree != NULL )
2445 neagerelems += chunk->eagerfreesize;
2448 assert(nchunks == chkmem->nchunks);
2450 assert(nelems == chkmem->storesize);
2455 allocedmem += (
long long)chkmem->elemsize * (
long long)nelems;
2456 freemem += (
long long)chkmem->elemsize * ((
long long)
neagerelems + (
long long)chkmem->lazyfreesize);
2458 if( nelems !=
neagerelems + chkmem->lazyfreesize )
2462 (((
long long)nelems - (
long long)
neagerelems) - (
long long)chkmem->lazyfreesize)
2463 * (
long long)(chkmem->elemsize),
2464 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize),
2465 chkmem->filename, chkmem->line);
2468 ((nelems -
neagerelems) - chkmem->lazyfreesize) * (
long long)(chkmem->elemsize),
2469 (nelems -
neagerelems) - chkmem->lazyfreesize, (
long long)(chkmem->elemsize));
2473 chkmem = chkmem->nextchkmem;
2513 double arraygrowfac,
2516 const char* filename,
2522 assert( arraygrowinit > 0 );
2523 assert( arraygrowfac > 0.0 );
2526 if ( buffer !=
NULL )
2532 buffer->
clean = clean;
2541 printError(
"Insufficient memory for buffer memory header.\n");
2550 const char* filename,
2556 if ( *buffer !=
NULL )
2558 i = (*buffer)->ndata;
2562 assert( ! (*buffer)->used[
i] );
2576 printError(
"Tried to free null buffer memory.\n");
2587 assert( arraygrowfac > 0.0 );
2599 assert( arraygrowinit > 0 );
2604#ifndef SCIP_NOBUFFERMEM
2655 const char* filename,
2661#ifndef SCIP_NOBUFFERMEM
2665#ifndef SCIP_NOBUFFERMEM
2685 printError(
"Insufficient memory for reallocating buffer data storage.\n");
2692 printError(
"Insufficient memory for reallocating buffer size storage.\n");
2699 printError(
"Insufficient memory for reallocating buffer used storage.\n");
2707 buffer->
size[
i] = 0;
2741 printError(
"Insufficient memory for reallocating buffer storage.\n");
2747#ifdef CHECKCLEANBUFFER
2764 debugMessage(
"Allocated buffer %llu/%llu at %p of size %llu (required size: %llu) for pointer %p.\n",
2766 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size, ptr);
2789 const char* filename,
2810 const char* filename,
2831 const char* filename,
2850 const char* filename,
2855#ifndef SCIP_NOBUFFERMEM
2859#ifndef SCIP_NOBUFFERMEM
2897 printError(
"Insufficient memory for reallocating buffer storage.\n");
2905 debugMessage(
"Reallocated buffer %llu/%llu at %p to size %llu (required size: %llu) for pointer %p.\n",
2907 (
unsigned long long)(buffer->
size[
bufnum]), (
unsigned long long)size,
newptr);
2922 const char* filename,
2944 const char* filename,
2965 const char* filename,
2989 const char* filename,
3012 const char* filename,
3032#ifdef CHECKBUFFERORDER
3035 warningMessage(
"[%s:%d]: freeing buffer in wrong order.\n", filename, line);
3043 printError(
"Tried to free unknown buffer pointer.\n");
3049 printError(
"Tried to free buffer pointer already freed.\n");
3054#ifdef CHECKCLEANBUFFER
3072 debugMessage(
"Freed buffer %llu/%llu at %p of size %llu for pointer %p, first free is %llu.\n",
3074 (
unsigned long long)(buffer->
size[
bufnum]), *ptr, (
unsigned long long)(buffer->
firstfree));
3083 const char* filename,
3089#ifndef SCIP_NOBUFFERMEM
3095 printError(
"Tried to free null buffer pointer.\n");
3106 const char* filename,
3114#ifndef SCIP_NOBUFFERMEM
3138 size_t totalmem = 0
UL;
3142 for (
i = 0;
i < buffer->
ndata; ++
i)
3143 totalmem += buffer->
size[
i];
3147 return (
long long) buffer->
totalmem;
3161 for (
i = 0;
i < buffer->
ndata; ++
i)
3163 printf(
"[%c] %8llu bytes at %p\n", buffer->
used[
i] ?
'*' :
' ', (
unsigned long long)(buffer->
size[
i]), buffer->
data[
i]);
3164 totalmem += buffer->
size[
i];
3166 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)
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