/* Memory allocator `malloc'. */
-/* Copyright (c) 2010-2022. 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. */
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;
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);
+ 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:
}
/* 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)
{
// 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;
* 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) {
+ 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 : */
/* 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);
}
/* 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 (int it = 0; it < BLOCKIFY(mdp->heapsize * 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;
}
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;
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));