void *MEM_mallocN(size_t len, const char *str)
{
MemHead *memh;
mem_lock_thread();
len = (len + 3 ) & ~3; /* allocate in units of 4 */
memh= (MemHead *)malloc(len+sizeof(MemHead)+sizeof(MemTail));
if(memh) {
make_memhead_header(memh, len, str);
mem_unlock_thread();
if(malloc_debug_memset && len)
memset(memh+1, 255, len);
#ifdef DEBUG_MEMCOUNTER
if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
memcount_raise("MEM_mallocN");
memh->_count= _mallocn_count++;
#endif
return (++memh);
}
mem_unlock_thread();
print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n", SIZET_ARG(len), str, mem_in_use);
return NULL;
}
/* note; mmap returns zero'd memory */
void *MEM_mapallocN(size_t len, const char *str)
{
MemHead *memh;
mem_lock_thread();
len = (len + 3 ) & ~3; /* allocate in units of 4 */
memh= mmap(NULL, len+sizeof(MemHead)+sizeof(MemTail),
PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
if(memh!=(MemHead *)-1) {
make_memhead_header(memh, len, str);
memh->mmap= 1;
mmap_in_use += len;
peak_mem = mmap_in_use > peak_mem ? mmap_in_use : peak_mem;
mem_unlock_thread();
#ifdef DEBUG_MEMCOUNTER
if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
memcount_raise("MEM_mapallocN");
memh->_count= _mallocn_count++;
#endif
return (++memh);
}
else {
mem_unlock_thread();
print_error("Mapalloc returns null, fallback to regular malloc: len=" SIZET_FORMAT " in %s, total %u\n", SIZET_ARG(len), str, mmap_in_use);
return MEM_callocN(len, str);
}
}
int MEM_get_memory_blocks_in_use(void)
{
int _totblock;
mem_lock_thread();
_totblock= totblock;
mem_unlock_thread();
return _totblock;
}
uintptr_t MEM_get_mapped_memory_in_use(void)
{
uintptr_t _mmap_in_use;
mem_lock_thread();
_mmap_in_use= mmap_in_use;
mem_unlock_thread();
return _mmap_in_use;
}
uintptr_t MEM_get_peak_memory(void)
{
uintptr_t _peak_mem;
mem_lock_thread();
_peak_mem = peak_mem;
mem_unlock_thread();
return _peak_mem;
}
/* Prints in python syntax for easy */
static void MEM_printmemlist_internal( int pydict )
{
MemHead *membl;
mem_lock_thread();
membl = membase->first;
if (membl) membl = MEMNEXT(membl);
if (pydict) {
print_error("# membase_debug.py\n");
print_error("membase = [\\\n");
}
while(membl) {
if (pydict) {
fprintf(stderr, "{'len':" SIZET_FORMAT ", 'name':'''%s''', 'pointer':'%p'},\\\n", SIZET_ARG(membl->len), membl->name, (void *)(membl+1));
} else {
#ifdef DEBUG_MEMCOUNTER
print_error("%s len: " SIZET_FORMAT " %p, count: %d\n", membl->name, SIZET_ARG(membl->len), membl+1, membl->_count);
#else
print_error("%s len: " SIZET_FORMAT " %p\n", membl->name, SIZET_ARG(membl->len), membl+1);
#endif
}
if(membl->next)
membl= MEMNEXT(membl->next);
else break;
}
if (pydict) {
fprintf(stderr, "]\n\n");
fprintf(stderr,
"mb_userinfo = {}\n"
"totmem = 0\n"
"for mb_item in membase:\n"
"\tmb_item_user_size = mb_userinfo.setdefault(mb_item['name'], [0,0])\n"
"\tmb_item_user_size[0] += 1 # Add a user\n"
"\tmb_item_user_size[1] += mb_item['len'] # Increment the size\n"
"\ttotmem += mb_item['len']\n"
"print '(membase) items:', len(membase), '| unique-names:', len(mb_userinfo), '| total-mem:', totmem\n"
"mb_userinfo_sort = mb_userinfo.items()\n"
"for sort_name, sort_func in (('size', lambda a: -a[1][1]), ('users', lambda a: -a[1][0]), ('name', lambda a: a[0])):\n"
"\tprint '\\nSorting by:', sort_name\n"
"\tmb_userinfo_sort.sort(key = sort_func)\n"
"\tfor item in mb_userinfo_sort:\n"
"\t\tprint 'name:%%s, users:%%i, len:%%i' %% (item[0], item[1][0], item[1][1])\n"
);
}
mem_unlock_thread();
}
short MEM_testN(void *vmemh) {
MemHead *membl;
mem_lock_thread();
membl = membase->first;
if (membl) membl = MEMNEXT(membl);
while(membl) {
if (vmemh == membl+1) {
mem_unlock_thread();
return 1;
}
if(membl->next)
membl= MEMNEXT(membl->next);
else break;
}
mem_unlock_thread();
print_error("Memoryblock %p: pointer not in memlist\n", vmemh);
return 0;
}
void MEM_callbackmemlist(void (*func)(void*)) {
MemHead *membl;
mem_lock_thread();
membl = membase->first;
if (membl) membl = MEMNEXT(membl);
while(membl) {
func(membl+1);
if(membl->next)
membl= MEMNEXT(membl->next);
else break;
}
mem_unlock_thread();
}
void MEM_lockfree_freeN(void *vmemh)
{
MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
size_t len = MEM_lockfree_allocN_len(vmemh);
if (vmemh == NULL) {
print_error("Attempt to free NULL pointer\n");
#ifdef WITH_ASSERT_ABORT
abort();
#endif
return;
}
atomic_sub_and_fetch_u(&totblock, 1);
atomic_sub_and_fetch_z(&mem_in_use, len);
if (MEMHEAD_IS_MMAP(memh)) {
atomic_sub_and_fetch_z(&mmap_in_use, len);
#if defined(WIN32)
/* our windows mmap implementation is not thread safe */
mem_lock_thread();
#endif
if (munmap(memh, len + sizeof(MemHead)))
printf("Couldn't unmap memory\n");
#if defined(WIN32)
mem_unlock_thread();
#endif
}
else {
if (UNLIKELY(malloc_debug_memset && len)) {
memset(memh + 1, 255, len);
}
if (UNLIKELY(MEMHEAD_IS_ALIGNED(memh))) {
MemHeadAligned *memh_aligned = MEMHEAD_ALIGNED_FROM_PTR(vmemh);
aligned_free(MEMHEAD_REAL_PTR(memh_aligned));
}
else {
free(memh);
}
}
}
void *MEM_lockfree_mapallocN(size_t len, const char *str)
{
MemHead *memh;
/* on 64 bit, simply use calloc instead, as mmap does not support
* allocating > 4 GB on Windows. the only reason mapalloc exists
* is to get around address space limitations in 32 bit OSes. */
if (sizeof(void *) >= 8)
return MEM_lockfree_callocN(len, str);
len = SIZET_ALIGN_4(len);
#if defined(WIN32)
/* our windows mmap implementation is not thread safe */
mem_lock_thread();
#endif
memh = mmap(NULL, len + sizeof(MemHead),
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
#if defined(WIN32)
mem_unlock_thread();
#endif
if (memh != (MemHead *)-1) {
memh->len = len | (size_t) MEMHEAD_MMAP_FLAG;
atomic_add_and_fetch_u(&totblock, 1);
atomic_add_and_fetch_z(&mem_in_use, len);
atomic_add_and_fetch_z(&mmap_in_use, len);
update_maximum(&peak_mem, mem_in_use);
update_maximum(&peak_mem, mmap_in_use);
return PTR_FROM_MEMHEAD(memh);
}
print_error("Mapalloc returns null, fallback to regular malloc: "
"len=" SIZET_FORMAT " in %s, total %u\n",
SIZET_ARG(len), str, (unsigned int) mmap_in_use);
return MEM_lockfree_callocN(len, str);
}
void MEM_reset_peak_memory(void)
{
mem_lock_thread();
peak_mem = 0;
mem_unlock_thread();
}
short MEM_freeN(void *vmemh) /* anders compileertie niet meer */
{
short error = 0;
MemTail *memt;
MemHead *memh= vmemh;
const char *name;
if (memh == NULL){
MemorY_ErroR("free","attempt to free NULL pointer");
/* print_error(err_stream, "%d\n", (memh+4000)->tag1); */
return(-1);
}
if(sizeof(intptr_t)==8) {
if (((intptr_t) memh) & 0x7) {
MemorY_ErroR("free","attempt to free illegal pointer");
return(-1);
}
}
else {
if (((intptr_t) memh) & 0x3) {
MemorY_ErroR("free","attempt to free illegal pointer");
return(-1);
}
}
memh--;
if(memh->tag1 == MEMFREE && memh->tag2 == MEMFREE) {
MemorY_ErroR(memh->name,"double free");
return(-1);
}
mem_lock_thread();
if ((memh->tag1 == MEMTAG1) && (memh->tag2 == MEMTAG2) && ((memh->len & 0x3) == 0)) {
memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + memh->len);
if (memt->tag3 == MEMTAG3){
memh->tag1 = MEMFREE;
memh->tag2 = MEMFREE;
memt->tag3 = MEMFREE;
/* after tags !!! */
rem_memblock(memh);
mem_unlock_thread();
return(0);
}
error = 2;
MemorY_ErroR(memh->name,"end corrupt");
name = check_memlist(memh);
if (name != NULL){
if (name != memh->name) MemorY_ErroR(name,"is also corrupt");
}
} else{
error = -1;
name = check_memlist(memh);
if (name == NULL)
MemorY_ErroR("free","pointer not in memlist");
else
MemorY_ErroR(name,"error in header");
}
totblock--;
/* here a DUMP should happen */
mem_unlock_thread();
return(error);
}
void MEM_printmemlist_stats(void)
{
MemHead *membl;
MemPrintBlock *pb, *printblock;
int totpb, a, b;
mem_lock_thread();
/* put memory blocks into array */
printblock= malloc(sizeof(MemPrintBlock)*totblock);
pb= printblock;
totpb= 0;
membl = membase->first;
if (membl) membl = MEMNEXT(membl);
while(membl) {
pb->name= membl->name;
pb->len= membl->len;
pb->items= 1;
totpb++;
pb++;
if(membl->next)
membl= MEMNEXT(membl->next);
else break;
}
/* sort by name and add together blocks with the same name */
qsort(printblock, totpb, sizeof(MemPrintBlock), compare_name);
for(a=0, b=0; a<totpb; a++) {
if(a == b) {
continue;
}
else if(strcmp(printblock[a].name, printblock[b].name) == 0) {
printblock[b].len += printblock[a].len;
printblock[b].items++;
}
else {
b++;
memcpy(&printblock[b], &printblock[a], sizeof(MemPrintBlock));
}
}
totpb= b+1;
/* sort by length and print */
qsort(printblock, totpb, sizeof(MemPrintBlock), compare_len);
printf("\ntotal memory len: %.3f MB\n", (double)mem_in_use/(double)(1024*1024));
printf(" ITEMS TOTAL-MiB AVERAGE-KiB TYPE\n");
for(a=0, pb=printblock; a<totpb; a++, pb++)
printf("%6d (%8.3f %8.3f) %s\n", pb->items, (double)pb->len/(double)(1024*1024), (double)pb->len/1024.0/(double)pb->items, pb->name);
free(printblock);
mem_unlock_thread();
#if 0 /* GLIBC only */
malloc_stats();
#endif
}