X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9104957deccc59e0e804215d5db498fabfd40d29..b6d29644d566a866a7cec0ab4c601700fdb47020:/src/xbt/mmalloc/mmalloc.c diff --git a/src/xbt/mmalloc/mmalloc.c b/src/xbt/mmalloc/mmalloc.c index e3ba23c211..ea99da9983 100644 --- a/src/xbt/mmalloc/mmalloc.c +++ b/src/xbt/mmalloc/mmalloc.c @@ -1,6 +1,6 @@ /* Memory allocator `malloc'. */ -/* Copyright (c) 2010-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2023. 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. */ @@ -18,13 +18,13 @@ static void initialize(xbt_mheap_t mdp); static void *register_morecore(xbt_mheap_t mdp, size_t size); -static void *align(xbt_mheap_t mdp, size_t size); +static void* mmalloc_aligned(xbt_mheap_t mdp, size_t size); /* Allocation aligned on block boundary. * * It never returns NULL, but dies verbosely on error. */ -static void *align(struct mdesc *mdp, size_t size) +static void* mmalloc_aligned(struct mdesc* mdp, size_t size) { void *result; unsigned long int adj; @@ -44,17 +44,15 @@ static void *align(struct mdesc *mdp, size_t size) mmorecore(mdp, adj); result = (char *) result + adj; } - return (result); + return result; } -/** Initialize heapinfo about the heapinfo pages :) - * - */ +/** Initialize heapinfo about the heapinfo pages :) */ 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); + mmalloc_assert((uintptr_t)mdp->heapinfo % BLOCKSIZE == 0, "Failed assert in initialize_heapinfo_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) { @@ -67,16 +65,12 @@ static void initialize_heapinfo_heapinfo(const s_xbt_mheap_t* mdp) } /* Finish the initialization of the mheap. If we want to inline it - * properly, we need to make the align function publicly visible, too */ + * properly, we need to make the mmalloc_aligned 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 *) - align(mdp, mdp->heapsize * sizeof(malloc_info)); + mdp->heapinfo = (malloc_info*)mmalloc_aligned(mdp, mdp->heapsize * sizeof(malloc_info)); mdp->heapbase = (void *) mdp->heapinfo; mdp->flags |= MMALLOC_INITIALIZED; @@ -89,9 +83,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)); } } @@ -105,19 +99,17 @@ static inline void update_hook(void **a, size_t offset) * into the heap info table as necessary. */ static void *register_morecore(struct mdesc *mdp, size_t size) { - void* result = align(mdp, size); // Never returns NULL + void* result = mmalloc_aligned(mdp, size); // Never returns NULL /* Check if we need to grow the info table (in a multiplicative manner) */ - if ((size_t) BLOCK((char *) result + size) > mdp->heapsize) { - int it; - + if (BLOCK((char*)result + size) > mdp->heapsize) { size_t newsize = mdp->heapsize; - while ((size_t) BLOCK((char *) result + size) > newsize) + while (BLOCK((char*)result + size) > newsize) newsize *= 2; /* Copy old info into new location */ malloc_info* oldinfo = mdp->heapinfo; - malloc_info* newinfo = (malloc_info*)align(mdp, newsize * sizeof(malloc_info)); + malloc_info* newinfo = (malloc_info*)mmalloc_aligned(mdp, newsize * sizeof(malloc_info)); memcpy(newinfo, oldinfo, mdp->heapsize * sizeof(malloc_info)); /* Initialize the new blockinfo : */ @@ -127,7 +119,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size) /* Update the swag of busy blocks containing free fragments by applying the offset to all swag_hooks. Yeah. My hand is right in the fan and I still type */ size_t offset=((char*)newinfo)-((char*)oldinfo); - for (int i = 1 /*first element of heapinfo describes the mdesc area*/; i < mdp->heaplimit; i++) { + for (size_t i = 1 /*first element of heapinfo describes the mdesc area*/; i < mdp->heaplimit; i++) { update_hook(&newinfo[i].freehook.next, offset); update_hook(&newinfo[i].freehook.prev, offset); } @@ -140,7 +132,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 (size_t 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 +146,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. */ @@ -168,7 +160,7 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) { static void mmalloc_mark_used(xbt_mheap_t mdp, size_t block, size_t nblocks, size_t requested_size) { - for (int it = 0; it < nblocks; it++) { + for (size_t it = 0; it < nblocks; it++) { mdp->heapinfo[block + it].type = MMALLOC_TYPE_UNFRAGMENTED; mdp->heapinfo[block + it].busy_block.busy_size = 0; mdp->heapinfo[block + it].busy_block.ignore = 0; @@ -222,8 +214,9 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) for (candidate_frag=0;candidate_frag<(size_t) (BLOCKSIZE >> log);candidate_frag++) if (candidate_info->busy_frag.frag_size[candidate_frag] == -1) break; - xbt_assert(candidate_frag < (size_t) (BLOCKSIZE >> log), - "Block %zu was registered as containing free fragments of type %zu, but I can't find any",candidate_block,log); + mmalloc_assert(candidate_frag < (size_t)(BLOCKSIZE >> log), + "Block %zu was registered as containing free fragments of type %zu, but I can't find any", + candidate_block, log); result = (void*) (((char*)ADDRESS(candidate_block)) + (candidate_frag << log)); @@ -250,7 +243,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) { @@ -282,7 +275,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(); } @@ -344,5 +339,5 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size) } - return (result); + return result; }