X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/77bbf3027c4240a2e833209a3a3f186589da8577..ea74f5d95928a521a588737e81f1de94eef25d19:/src/xbt/mmalloc/mmalloc.c diff --git a/src/xbt/mmalloc/mmalloc.c b/src/xbt/mmalloc/mmalloc.c index 2636c29f26..5b48368a63 100644 --- a/src/xbt/mmalloc/mmalloc.c +++ b/src/xbt/mmalloc/mmalloc.c @@ -1,6 +1,6 @@ /* Memory allocator `malloc'. */ -/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2022. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -44,17 +44,17 @@ static void *align(struct mdesc *mdp, size_t size) mmorecore(mdp, adj); result = (char *) result + adj; } - return (result); + return result; } -/** Initialise heapinfo about the heapinfo pages :) +/** Initialize heapinfo about the heapinfo pages :) * */ -static void initialize_heapinfo_heapinfo(xbt_mheap_t mdp) +static void initialize_heapinfo_heapinfo(const s_xbt_mheap_t* mdp) { // Update heapinfo about the heapinfo pages (!): xbt_assert((uintptr_t) mdp->heapinfo % BLOCKSIZE == 0); - int block = BLOCK(mdp->heapinfo); + size_t block = BLOCK(mdp->heapinfo); size_t nblocks = mdp->heapsize * sizeof(malloc_info) / BLOCKSIZE; // Mark them as free: for (size_t j=0; j!=nblocks; ++j) { @@ -70,9 +70,6 @@ static void initialize_heapinfo_heapinfo(xbt_mheap_t mdp) * properly, we need to make the align function publicly visible, too */ static void initialize(xbt_mheap_t mdp) { - int i; - malloc_info mi; /* to compute the offset of the swag hook */ - // Update mdp meta-data: mdp->heapsize = HEAP / BLOCKSIZE; mdp->heapinfo = (malloc_info *) @@ -89,9 +86,9 @@ static void initialize(xbt_mheap_t mdp) initialize_heapinfo_heapinfo(mdp); - for (i=0;ifraghead[i]), - xbt_swag_offset(mi, freehook)); + for (int i = 0; i < BLOCKLOG; i++) { + malloc_info mi; /* to compute the offset of the swag hook */ + xbt_swag_init(&(mdp->fraghead[i]), xbt_swag_offset(mi, freehook)); } } @@ -109,8 +106,6 @@ static void *register_morecore(struct mdesc *mdp, size_t size) /* Check if we need to grow the info table (in a multiplicative manner) */ if ((size_t) BLOCK((char *) result + size) > mdp->heapsize) { - int it; - size_t newsize = mdp->heapsize; while ((size_t) BLOCK((char *) result + size) > newsize) newsize *= 2; @@ -120,7 +115,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size) malloc_info* newinfo = (malloc_info*)align(mdp, newsize * sizeof(malloc_info)); memcpy(newinfo, oldinfo, mdp->heapsize * sizeof(malloc_info)); - /* Initialise the new blockinfo : */ + /* Initialize the new blockinfo : */ memset((char*) newinfo + mdp->heapsize * sizeof(malloc_info), 0, (newsize - mdp->heapsize)* sizeof(malloc_info)); @@ -140,7 +135,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size) /* mark the space previously occupied by the block info as free by first marking it * as occupied in the regular way, and then freing it */ - for (it=0; itheapsize * sizeof(malloc_info)); it++){ + for (int it = 0; it < BLOCKIFY(mdp->heapsize * sizeof(malloc_info)); it++) { newinfo[BLOCK(oldinfo)+it].type = MMALLOC_TYPE_UNFRAGMENTED; newinfo[BLOCK(oldinfo)+it].busy_block.ignore = 0; } @@ -154,7 +149,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size) } mdp->heaplimit = BLOCK((char *) result + size); - return (result); + return result; } /* Allocate memory from the heap. */ @@ -176,15 +171,11 @@ static void mmalloc_mark_used(xbt_mheap_t mdp, size_t block, size_t nblocks, siz } mdp->heapinfo[block].busy_block.size = nblocks; mdp->heapinfo[block].busy_block.busy_size = requested_size; - // mdp->heapinfo[block].busy_block.bt_size = - // xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_block.bt, XBT_BACKTRACE_SIZE); - // mdp->heapinfo[block].busy_block.bt_size = - // xbt_libunwind_backtrace(mdp->heapinfo[block].busy_block.bt, XBT_BACKTRACE_SIZE); mdp->heapstats.chunks_used++; mdp->heapstats.bytes_used += nblocks * BLOCKSIZE; } -/* Spliting mmalloc this way is mandated by a trick in mrealloc, that gives +/* Splitting mmalloc this way is mandated by a trick in mrealloc, that gives back the memory of big blocks to the system before reallocating them: we don't want to loose the beginning of the area when this happens */ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) @@ -201,8 +192,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) if (size < SMALLEST_POSSIBLE_MALLOC) size = SMALLEST_POSSIBLE_MALLOC; - // printf("(%s) Mallocing %d bytes on %p (default: %p)...",xbt_thread_self_name(),size,mdp,__mmalloc_default_mdp);fflush(stdout); - if (!(mdp->flags & MMALLOC_INITIALIZED)) initialize(mdp); @@ -242,8 +231,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) /* Update our metadata about this fragment */ candidate_info->busy_frag.frag_size[candidate_frag] = requested_size; candidate_info->busy_frag.ignore[candidate_frag] = 0; - //xbt_backtrace_no_malloc(candidate_info->busy_frag.bt[candidate_frag],XBT_BACKTRACE_SIZE); - //xbt_libunwind_backtrace(candidate_info->busy_frag.bt[candidate_frag],XBT_BACKTRACE_SIZE); /* Update the statistics. */ mdp -> heapstats.chunks_used++; @@ -258,7 +245,7 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) result = mmalloc(mdp, BLOCKSIZE); // does not return NULL block = BLOCK(result); - mdp->heapinfo[block].type = log; + mdp->heapinfo[block].type = (int)log; /* Link all fragments but the first as free, and add the block to the swag of blocks containing free frags */ size_t i; for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) { @@ -274,8 +261,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) /* mark the fragment returned as busy */ mdp->heapinfo[block].busy_frag.frag_size[0] = requested_size; mdp->heapinfo[block].busy_frag.ignore[0] = 0; - //xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_frag.bt[0],XBT_BACKTRACE_SIZE); - //xbt_libunwind_backtrace(mdp->heapinfo[block].busy_frag.bt[0],XBT_BACKTRACE_SIZE); /* update stats */ mdp -> heapstats.chunks_free += (BLOCKSIZE >> log) - 1; @@ -292,7 +277,9 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) block = MALLOC_SEARCH_START; while (mdp->heapinfo[block].free_block.size < blocks) { if (mdp->heapinfo[block].type >=0) { // Don't trust xbt_die and friends in malloc-level library, you fool! - fprintf(stderr,"Internal error: found a free block not marked as such (block=%lu type=%lu). Please report this bug.\n",(unsigned long)block,(unsigned long)mdp->heapinfo[block].type); + fprintf(stderr, + "Internal error: found a free block not marked as such (block=%zu type=%d). Please report this bug.\n", + block, mdp->heapinfo[block].type); abort(); } @@ -353,7 +340,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) mdp -> heapstats.bytes_free -= blocks * BLOCKSIZE; } - //printf("(%s) Done mallocing. Result is %p\n",xbt_thread_self_name(),result);fflush(stdout); - return (result); + return result; }