X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3203ed1f4fb6f4617e94d5351661ba07e8b8f833..9a4ec91cc24a9a54ff3a060cc2828ac54d0c0c26:/src/xbt/mmalloc/mm_legacy.c diff --git a/src/xbt/mmalloc/mm_legacy.c b/src/xbt/mmalloc/mm_legacy.c index e9e250fa23..fb22a59865 100644 --- a/src/xbt/mmalloc/mm_legacy.c +++ b/src/xbt/mmalloc/mm_legacy.c @@ -1,5 +1,4 @@ -/* Copyright (c) 2010-2015. 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. */ @@ -7,18 +6,13 @@ /* Redefine the classical malloc/free/realloc functions so that they fit well in the mmalloc framework */ #define _GNU_SOURCE -#include - -#include - -#include "src/mc/mc_base.h" #include "mmprivate.h" -#include "src/xbt_modinter.h" -#include "src/internal_config.h" +#include "src/mc/mc_environ.h" // MC_ENV_SOCKET_FD +#include #include -#include "src/mc/mc_protocol.h" +#include -/* ***** Whether to use `mmalloc` of the undrlying malloc ***** */ +/* ***** Whether to use `mmalloc` of the underlying malloc ***** */ static int __malloc_use_mmalloc; @@ -43,23 +37,15 @@ xbt_mheap_t mmalloc_get_current_heap(void) return __mmalloc_current_heap; } -xbt_mheap_t mmalloc_set_current_heap(xbt_mheap_t new_heap) -{ - xbt_mheap_t heap = __mmalloc_current_heap; - __mmalloc_current_heap = new_heap; - return heap; -} - -#ifdef MMALLOC_WANT_OVERRIDE_LEGACY - +/* Override the malloc-like functions if MC is activated at compile time */ /* ***** Temporary allocator * * This is used before we have found the real malloc implementation with dlsym. */ -#define BUFFER_SIZE 32 static size_t fake_alloc_index; -static uint64_t buffer[BUFFER_SIZE]; +static uint64_t buffer[mmalloc_preinit_buffer_size]; +uint64_t* mmalloc_preinit_buffer = buffer; /* Fake implementations, they are used to fool dlsym: * dlsym used calloc and falls back to some other mechanism @@ -67,13 +53,18 @@ static uint64_t buffer[BUFFER_SIZE]; */ static void* mm_fake_malloc(size_t n) { + mmalloc_preinit_buffer = buffer; + // How many uint64_t do w need? size_t count = n / sizeof(uint64_t); if (n % sizeof(uint64_t)) count++; - // Check that we have enough availabel memory: - if (fake_alloc_index + count >= BUFFER_SIZE) + // Check that we have enough available memory: + if (fake_alloc_index + count >= mmalloc_preinit_buffer_size) { + puts("mmalloc is not initialized yet, but the static buffer used as malloc replacement is already exhausted. " + "Please increase `mmalloc_preinit_buffer_size` in mm_legacy.c\n"); exit(127); + } // Allocate it: uint64_t* res = buffer + fake_alloc_index; fake_alloc_index += count; @@ -87,13 +78,14 @@ static void* mm_fake_calloc(size_t nmemb, size_t size) return mm_fake_malloc(n); } -static void* mm_fake_realloc(void *p, size_t s) +static void* mm_fake_realloc(XBT_ATTRIB_UNUSED void* p, size_t s) { return mm_fake_malloc(s); } -static void mm_fake_free(void *p) +static void mm_fake_free(XBT_ATTRIB_UNUSED void* p) { + // Nothing to do } /* Function signatures for the main malloc functions: */ @@ -113,20 +105,28 @@ static int mm_initialized; /** Constructor functions used to initialize the malloc implementation */ -static void __attribute__((constructor(101))) mm_legacy_constructor() +XBT_ATTRIB_CONSTRUCTOR(101) static void mm_legacy_constructor() { if (mm_initialized) return; mm_initializing = 1; - __malloc_use_mmalloc = getenv(MC_ENV_VARIABLE) ? 1 : 0; + __malloc_use_mmalloc = getenv(MC_ENV_SOCKET_FD) != NULL; if (__malloc_use_mmalloc) { __mmalloc_current_heap = mmalloc_preinit(); } else { +#if HAVE_DLFUNC + mm_real_realloc = (void *(*)(void *, size_t))dlfunc(RTLD_NEXT, "realloc"); + mm_real_malloc = (void *(*)(size_t))dlfunc(RTLD_NEXT, "malloc"); + mm_real_free = (void (*)(void *))dlfunc(RTLD_NEXT, "free"); + mm_real_calloc = (void *(*)(size_t, size_t))dlfunc(RTLD_NEXT, "calloc"); +#else mm_real_realloc = dlsym(RTLD_NEXT, "realloc"); mm_real_malloc = dlsym(RTLD_NEXT, "malloc"); mm_real_free = dlsym(RTLD_NEXT, "free"); mm_real_calloc = dlsym(RTLD_NEXT, "calloc"); +#endif } + mm_initializing = 0; mm_initialized = 1; } @@ -142,28 +142,6 @@ static void __attribute__((constructor(101))) mm_legacy_constructor() #define GET_HEAP() __mmalloc_current_heap -void* malloc_no_memset(size_t n) -{ - if (!mm_initialized) { - if (mm_initializing) - return mm_fake_malloc(n); - mm_legacy_constructor(); - } - - if (!__malloc_use_mmalloc) { - return mm_real_malloc(n); - } - - xbt_mheap_t mdp = GET_HEAP(); - if (!mdp) - return NULL; - - LOCK(mdp); - void *ret = mmalloc_no_memset(mdp, n); - UNLOCK(mdp); - return ret; -} - void *malloc(size_t n) { if (!mm_initialized) { @@ -180,10 +158,7 @@ void *malloc(size_t n) if (!mdp) return NULL; - LOCK(mdp); - void *ret = mmalloc(mdp, n); - UNLOCK(mdp); - return ret; + return mmalloc(mdp, n); } void *calloc(size_t nmemb, size_t size) @@ -202,9 +177,7 @@ void *calloc(size_t nmemb, size_t size) if (!mdp) return NULL; - LOCK(mdp); void *ret = mmalloc(mdp, nmemb*size); - UNLOCK(mdp); // This was already done in the callee: if(!(mdp->options & XBT_MHEAP_OPTION_MEMSET)) { memset(ret, 0, nmemb * size); @@ -228,10 +201,7 @@ void *realloc(void *p, size_t s) if (!mdp) return NULL; - LOCK(mdp); - void* ret = mrealloc(mdp, p, s); - UNLOCK(mdp); - return ret; + return mrealloc(mdp, p, s); } void free(void *p) @@ -251,8 +221,5 @@ void free(void *p) return; xbt_mheap_t mdp = GET_HEAP(); - LOCK(mdp); mfree(mdp, p); - UNLOCK(mdp); } -#endif /* WANT_MALLOC_OVERRIDE */