X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/dff9e15c44ab6340d27215957c56fa72fad246a2..1a0f69168109c0b38b03b1d1deb9773fdac83e9e:/src/xbt/mallocator.c diff --git a/src/xbt/mallocator.c b/src/xbt/mallocator.c index 460dda86aa..ed415a5ed7 100644 --- a/src/xbt/mallocator.c +++ b/src/xbt/mallocator.c @@ -1,6 +1,7 @@ /* mallocator - recycle objects to avoid malloc() / free() */ -/* Copyright (c) 2006 Christophe Thiery. All rights reserved. */ +/* Copyright (c) 2006-2011. 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. */ @@ -8,10 +9,22 @@ #include "xbt/mallocator.h" #include "xbt/asserts.h" #include "xbt/sysdep.h" +#include "mc/mc.h" /* kill mallocators when model-checking is enabled */ #include "mallocator_private.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_mallocator, xbt, "Mallocators"); + +/* Change to 0 to completely disable mallocators. */ +#define MALLOCATOR_IS_WANTED 1 + +/* Mallocators and memory mess introduced by model-checking do not mix well + * together: the mallocator will give standard memory when we are using raw + * memory (so these blocks are killed on restore) and the contrary (so these + * blocks will leak accross restores). + */ +#define MALLOCATOR_IS_ENABLED (MALLOCATOR_IS_WANTED && !MC_IS_ENABLED) + /** * \brief Constructor * \param size size of the internal stack: number of objects the mallocator @@ -22,7 +35,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_mallocator, xbt, "Mallocators"); * in \a xbt_mallocator_release() when the stack is full, and when * the mallocator is freed. * \param reset_f function to reinitialise an object of your datatype, called - * when you extract an object from the mallocator + * when you extract an object from the mallocator (can be NULL) * * Create and initialize a new mallocator for a given datatype. * @@ -34,26 +47,28 @@ xbt_mallocator_t xbt_mallocator_new(int size, void_f_pvoid_t free_f, void_f_pvoid_t reset_f) { - - xbt_mallocator_t m; - xbt_assert0(size > 0, "size must be positive"); - xbt_assert0(new_f != NULL && free_f != NULL - && reset_f != NULL, "invalid parameter"); + xbt_assert(size > 0, "size must be positive"); + xbt_assert(new_f != NULL && free_f != NULL, "invalid parameter"); m = xbt_new0(s_xbt_mallocator_t, 1); - VERB1("Create mallocator %p", m); - if (XBT_LOG_ISENABLED(xbt_mallocator, xbt_log_priority_verbose)) - xbt_backtrace_display_current(); - - m->objects = xbt_new0(void *, size); - m->max_size = size; + XBT_VERB("Create mallocator %p", m); m->current_size = 0; m->new_f = new_f; m->free_f = free_f; m->reset_f = reset_f; + if (MALLOCATOR_IS_ENABLED) { + m->objects = xbt_new0(void *, size); + m->max_size = size; + } else { + if (!MALLOCATOR_IS_WANTED) /* Warn to avoid to commit debugging settings */ + XBT_WARN("Mallocator is disabled!"); + m->objects = NULL; + m->max_size = 0; + } + return m; } @@ -69,11 +84,12 @@ void xbt_mallocator_free(xbt_mallocator_t m) { int i; - xbt_assert0(m != NULL, "Invalid parameter"); + xbt_assert(m != NULL, "Invalid parameter"); - VERB3("Frees mallocator %p (size:%d/%d)", m, m->current_size, m->max_size); + XBT_VERB("Frees mallocator %p (size:%d/%d)", m, m->current_size, + m->max_size); for (i = 0; i < m->current_size; i++) { - (*(m->free_f)) (m->objects[i]); + m->free_f(m->objects[i]); } xbt_free(m->objects); xbt_free(m); @@ -91,27 +107,38 @@ void xbt_mallocator_free(xbt_mallocator_t m) * If the mallocator is empty, a new object is created, * by calling the function new_f(). * - * In both cases, the function reset_f() is called on the object. + * In both cases, the function reset_f() (if defined) is called on the object. * * \see xbt_mallocator_release() */ void *xbt_mallocator_get(xbt_mallocator_t m) { void *object; - xbt_assert0(m != NULL, "Invalid parameter"); - if (m->current_size > 0) { - /* there is at least an available object */ - DEBUG3("Reuse an old object for mallocator %p (size:%d/%d)", m, - m->current_size, m->max_size); + if (MALLOCATOR_IS_ENABLED) { + if (m->current_size <= 0) { + /* No object is ready yet. Create a bunch of them to try to group the + * mallocs on the same memory pages (to help the cache lines) */ + + /* XBT_DEBUG("Create a new object for mallocator %p (size:%d/%d)", */ + /* m, m->current_size, m->max_size); */ + int i; + int amount = MIN(m->max_size / 2, 1000); + for (i = 0; i < amount; i++) + m->objects[i] = m->new_f(); + m->current_size = amount; + } + + /* there is at least an available object, now */ + /* XBT_DEBUG("Reuse an old object for mallocator %p (size:%d/%d)", */ + /* m, m->current_size, m->max_size); */ object = m->objects[--m->current_size]; } else { - /* otherwise we must allocate a new object */ - DEBUG3("Create a new object for mallocator %p (size:%d/%d)", m, - m->current_size, m->max_size); - object = (*(m->new_f)) (); + object = m->new_f(); } - (*(m->reset_f)) (object); + + if (m->reset_f) + m->reset_f(object); return object; } @@ -130,18 +157,16 @@ void *xbt_mallocator_get(xbt_mallocator_t m) */ void xbt_mallocator_release(xbt_mallocator_t m, void *object) { - xbt_assert0(m != NULL && object != NULL, "Invalid parameter"); - if (m->current_size < m->max_size) { /* there is enough place to push the object */ - DEBUG3 - ("Store deleted object in mallocator %p for further use (size:%d/%d)", - m, m->current_size, m->max_size); + /* XBT_DEBUG + ("Store deleted object in mallocator %p for further use (size:%d/%d)", + m, m->current_size, m->max_size); */ m->objects[m->current_size++] = object; } else { /* otherwise we don't have a choice, we must free the object */ - DEBUG3("Free deleted object: mallocator %p is full (size:%d/%d)", m, - m->current_size, m->max_size); - (*(m->free_f)) (object); + /* XBT_DEBUG("Free deleted object: mallocator %p is full (size:%d/%d)", m, + m->current_size, m->max_size); */ + m->free_f(object); } }