X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1ecbb4c88462e9ec9be0c830a257da6e9b774a25..f249ab2158bcbed49cf4db2d249cf5ffbc59b22e:/src/xbt/dynar.c

diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c
index 22eb8d27a4..ae75d30cce 100644
--- a/src/xbt/dynar.c
+++ b/src/xbt/dynar.c
@@ -6,7 +6,6 @@
 /* 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. */
 
-#include "portable.h"           /* SIZEOF_MAX */
 #include "xbt/misc.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
@@ -35,19 +34,19 @@ static XBT_INLINE void _dynar_unlock(xbt_dynar_t dynar)
 
 static XBT_INLINE void _sanity_check_dynar(xbt_dynar_t dynar)
 {
-  xbt_assert0(dynar, "dynar is NULL");
+  xbt_assert(dynar, "dynar is NULL");
 }
 
 static XBT_INLINE void _sanity_check_idx(int idx)
 {
-  xbt_assert1(idx >= 0, "dynar idx(=%d) < 0", (int) (idx));
+  xbt_assert(idx >= 0, "dynar idx(=%d) < 0", (int) (idx));
 }
 
 static XBT_INLINE void _check_inbound_idx(xbt_dynar_t dynar, int idx)
 {
   if (idx < 0 || idx >= dynar->used) {
     _dynar_unlock(dynar);
-    THROW2(bound_error, idx,
+    THROWF(bound_error, idx,
            "dynar is not that long. You asked %d, but it's only %lu long",
            (int) (idx), (unsigned long) dynar->used);
   }
@@ -58,7 +57,7 @@ static XBT_INLINE void _check_sloppy_inbound_idx(xbt_dynar_t dynar,
 {
   if (idx > dynar->used) {
     _dynar_unlock(dynar);
-    THROW2(bound_error, idx,
+    THROWF(bound_error, idx,
            "dynar is not that long. You asked %d, but it's only %lu long (could have been equal to it)",
            (int) (idx), (unsigned long) dynar->used);
   }
@@ -68,16 +67,19 @@ static XBT_INLINE void _check_populated_dynar(xbt_dynar_t dynar)
 {
   if (dynar->used == 0) {
     _dynar_unlock(dynar);
-    THROW1(bound_error, 0, "dynar %p is empty", dynar);
+    THROWF(bound_error, 0, "dynar %p is empty", dynar);
   }
 }
 
 static void _dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op);
 
 static XBT_INLINE
-    void _xbt_clear_mem(void *const ptr, const unsigned long length)
+void _xbt_dynar_resize(xbt_dynar_t dynar, unsigned long new_size)
 {
-  memset(ptr, 0, length);
+  if (new_size != dynar->size) {
+    dynar->size = new_size;
+    dynar->data = xbt_realloc(dynar->data, new_size * dynar->elmsize);
+  }
 }
 
 static XBT_INLINE
@@ -86,30 +88,10 @@ static XBT_INLINE
   const unsigned long old_size = dynar->size;
 
   if (nb > old_size) {
-    char *const old_data = (char *) dynar->data;
-
-    const unsigned long elmsize = dynar->elmsize;
-
-    const unsigned long used = dynar->used;
-    const unsigned long used_length = used * elmsize;
-
-    const unsigned long new_size =
-        nb > (2 * (old_size + 1)) ? nb : (2 * (old_size + 1));
-    const unsigned long new_length = new_size * elmsize;
-    char *const new_data = (char *) xbt_malloc0(elmsize * new_size);
-
-    XBT_DEBUG("expand %p from %lu to %lu elements", (void *) dynar,
-           (unsigned long) old_size, nb);
-
-    if (old_data) {
-      memcpy(new_data, old_data, used_length);
-      free(old_data);
-    }
-
-    _xbt_clear_mem(new_data + used_length, new_length - used_length);
-
-    dynar->size = new_size;
-    dynar->data = new_data;
+    const unsigned long expand = 2 * (old_size + 1);
+    _xbt_dynar_resize(dynar, (nb > expand ? nb : expand));
+    XBT_DEBUG("expand %p from %lu to %lu elements",
+              dynar, old_size, dynar->size);
   }
 }
 
@@ -158,16 +140,7 @@ _xbt_dynar_remove_at(xbt_dynar_t const dynar,
   if (object) {
     _xbt_dynar_get_elm(object, dynar, idx);
   } else if (dynar->free_f) {
-    if (dynar->elmsize <= SIZEOF_MAX) {
-      char elm[SIZEOF_MAX];
-      _xbt_dynar_get_elm(elm, dynar, idx);
-      (*dynar->free_f) (elm);
-    } else {
-      char *elm = malloc(dynar->elmsize);
-      _xbt_dynar_get_elm(elm, dynar, idx);
-      (*dynar->free_f) (elm);
-      free(elm);
-    }
+    dynar->free_f(_xbt_dynar_elm(dynar, idx));
   }
 
   nb_shift = dynar->used - 1 - idx;
@@ -237,18 +210,11 @@ xbt_dynar_new_sync(const unsigned long elmsize,
 void xbt_dynar_free_container(xbt_dynar_t * dynar)
 {
   if (dynar && *dynar) {
-
-    if ((*dynar)->data) {
-      _xbt_clear_mem((*dynar)->data, (*dynar)->size);
-      free((*dynar)->data);
-    }
-
-    if ((*dynar)->mutex)
-      xbt_mutex_destroy((*dynar)->mutex);
-
-    _xbt_clear_mem(*dynar, sizeof(s_xbt_dynar_t));
-
-    free(*dynar);
+    xbt_dynar_t d = *dynar;
+    free(d->data);
+    if (d->mutex)
+      xbt_mutex_destroy(d->mutex);
+    free(d);
     *dynar = NULL;
   }
 }
@@ -267,17 +233,9 @@ XBT_INLINE void xbt_dynar_reset(xbt_dynar_t const dynar)
   if (dynar->free_f) {
     _dynar_map(dynar, dynar->free_f);
   }
-  /*
-     if (dynar->data)
-     free(dynar->data);
-
-     dynar->size = 0;
-   */
   dynar->used = 0;
 
   _dynar_unlock(dynar);
-
-  /*  dynar->data = NULL; */
 }
 
 /**
@@ -297,15 +255,8 @@ XBT_INLINE void xbt_dynar_reset(xbt_dynar_t const dynar)
  */
 void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted)
 {
-  unsigned long size_wanted;
-
   _dynar_lock(dynar);
-
-  size_wanted = dynar->used + empty_slots_wanted;
-  if (size_wanted != dynar->size) {
-    dynar->size = size_wanted;
-    dynar->data = xbt_realloc(dynar->data, dynar->elmsize * dynar->size);
-  }
+  _xbt_dynar_resize(dynar, dynar->used + empty_slots_wanted);
   _dynar_unlock(dynar);
 }
 
@@ -327,7 +278,8 @@ XBT_INLINE void xbt_dynar_free(xbt_dynar_t * dynar)
 /** \brief free a dynar passed as void* (handy to store dynar in dynars or dict) */
 void xbt_dynar_free_voidp(void *d)
 {
-  xbt_dynar_free((xbt_dynar_t *) d);
+  xbt_dynar_t dynar = (xbt_dynar_t)d;
+  xbt_dynar_free(&dynar);
 }
 
 /** @brief Count of dynar's elements
@@ -390,26 +342,30 @@ XBT_INLINE void *xbt_dynar_get_ptr(const xbt_dynar_t dynar,
   return res;
 }
 
-XBT_INLINE void *xbt_dynar_set_at_ptr(const xbt_dynar_t dynar,
-                                      const unsigned long idx)
+/* not synchronized */
+static XBT_INLINE void *_xbt_dynar_set_at_ptr(const xbt_dynar_t dynar,
+                                              const unsigned long idx)
 {
-
-  void *res;
-  _dynar_lock(dynar);
   _sanity_check_dynar(dynar);
 
-  _xbt_dynar_expand(dynar, idx + 1);
-
   if (idx >= dynar->used) {
-    _xbt_clear_mem(((char * const)dynar->data) + dynar->used * dynar->elmsize,
-                   (idx + 1 - dynar->used)*dynar->elmsize);
+    _xbt_dynar_expand(dynar, idx + 1);
+    if (idx > dynar->used) {
+      memset(_xbt_dynar_elm(dynar, dynar->used), 0,
+             (idx - dynar->used) * dynar->elmsize);
+    }
     dynar->used = idx + 1;
   }
-  
-  _dynar_unlock(dynar);
-
-  res = _xbt_dynar_elm(dynar, idx);
+  return _xbt_dynar_elm(dynar, idx);
+}
 
+XBT_INLINE void *xbt_dynar_set_at_ptr(const xbt_dynar_t dynar,
+                                      const unsigned long idx)
+{
+  void *res;
+  _dynar_lock(dynar);
+  res = _xbt_dynar_set_at_ptr(dynar, idx);
+  _dynar_unlock(dynar);
   return res;
 }
 
@@ -417,18 +373,7 @@ static void XBT_INLINE          /* not synchronized */
 _xbt_dynar_set(xbt_dynar_t dynar,
                const unsigned long idx, const void *const src)
 {
-
-  _sanity_check_dynar(dynar);
-
-  _xbt_dynar_expand(dynar, idx + 1);
-
-  if (idx >= dynar->used) {
-    _xbt_clear_mem(((char * const)dynar->data) + dynar->used * dynar->elmsize,
-                   (idx + 1 - dynar->used)*dynar->elmsize);
-    dynar->used = idx + 1;
-  }
-
-  _xbt_dynar_put_elm(dynar, idx, src);
+  memcpy(_xbt_dynar_set_at_ptr(dynar, idx), src, dynar->elmsize);
 }
 
 /** @brief Set the Nth element of a dynar (expanded if needed). Previous value at this position is NOT freed
@@ -468,7 +413,7 @@ xbt_dynar_replace(xbt_dynar_t dynar,
   if (idx < dynar->used && dynar->free_f) {
     void *const old_object = _xbt_dynar_elm(dynar, idx);
 
-    (*(dynar->free_f)) (old_object);
+    dynar->free_f(old_object);
   }
 
   _xbt_dynar_set(dynar, idx, object);
@@ -570,7 +515,7 @@ unsigned int xbt_dynar_search(xbt_dynar_t const dynar, void *const elem)
     }
 
   _dynar_unlock(dynar);
-  THROW2(not_found_error, 0, "Element %p not part of dynar %p", elem,
+  THROWF(not_found_error, 0, "Element %p not part of dynar %p", elem,
          dynar);
 }
 
@@ -582,7 +527,8 @@ int xbt_dynar_member(xbt_dynar_t const dynar, void *const elem)
 
   TRY {
     xbt_dynar_search(dynar, elem);
-  } CATCH(e) {
+  }
+  CATCH(e) {
     if (e.category == not_found_error) {
       xbt_ex_free(e);
       return 0;
@@ -675,13 +621,14 @@ XBT_INLINE void xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst)
 
 static void _dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
 {
-  char elm[SIZEOF_MAX];
+  char *const data = (char *) dynar->data;
+  const unsigned long elmsize = dynar->elmsize;
   const unsigned long used = dynar->used;
-  unsigned long i = 0;
+  unsigned long i;
 
   for (i = 0; i < used; i++) {
-    _xbt_dynar_get_elm(elm, dynar, i);
-    (*op) (elm);
+    char* elm = (char*) data + i * elmsize;
+    op(elm);
   }
 }
 
@@ -743,8 +690,11 @@ XBT_INLINE void xbt_dynar_sort(xbt_dynar_t dynar,
 
   _dynar_lock(dynar);
 
+#ifdef HAVE_MERGESORT
+  mergesort(dynar->data, dynar->used, dynar->elmsize, compar_fn);
+#else
   qsort(dynar->data, dynar->used, dynar->elmsize, compar_fn);
-
+#endif
   _dynar_unlock(dynar);
 }
 
@@ -775,16 +725,19 @@ XBT_INLINE int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2,
 	if((!d1) || (!d2))
 	{
 		XBT_DEBUG("NULL dynar d1=%p d2=%p",d1,d2);
+		xbt_dynar_free(&d2);
 		return 1;
 	}
 	if((d1->elmsize)!=(d2->elmsize))
 	{
 		XBT_DEBUG("Size of elmsize d1=%ld d2=%ld",d1->elmsize,d2->elmsize);
+		xbt_dynar_free(&d2);
 		return 1; // xbt_die
 	}
 	if(xbt_dynar_length(d1) != xbt_dynar_length(d2))
 	{
 		XBT_DEBUG("Size of dynar d1=%ld d2=%ld",xbt_dynar_length(d1),xbt_dynar_length(d2));
+		xbt_dynar_free(&d2);
 		return 1;
 	}
 
@@ -794,8 +747,12 @@ XBT_INLINE int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2,
 		void *data1 = xbt_dynar_get_as(d1, i, void *);
 		void *data2 = xbt_dynar_get_as(d2, i, void *);
 		XBT_DEBUG("link[%d] d1=%p d2=%p",i,data1,data2);
-		if(compar(data1,data2)) return 1;
+		if(compar(data1,data2)){
+			xbt_dynar_free(&d2);
+			return 1;
+		}
 	}
+	xbt_dynar_free(&d2);
 	return 0;
 }
 
@@ -815,7 +772,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   unsigned int cursor;
   int *iptr;
 
-  xbt_test_add0("==== Traverse the empty dynar");
+  xbt_test_add("==== Traverse the empty dynar");
   d = xbt_dynar_new(sizeof(int), NULL);
   xbt_dynar_foreach(d, cursor, i) {
     xbt_die( "Damnit, there is something in the empty dynar");
@@ -824,7 +781,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1
+  xbt_test_add
       ("==== Push %d int, set them again 3 times, traverse them, shift them",
        NB_ELEM);
   /* Populate_ints [doxygen cruft] */
@@ -833,20 +790,20 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_push_as(d, int, cpt);     /* This is faster (and possible only with scalars) */
     /* xbt_dynar_push(d,&cpt);       This would also work */
-    xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
+    xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
   /* 2. Traverse manually the dynar */
   for (cursor = 0; cursor < NB_ELEM; cursor++) {
     iptr = xbt_dynar_get_ptr(d, cursor);
-    xbt_test_assert2(cursor == *iptr,
+    xbt_test_assert(cursor == *iptr,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
 
   /* 3. Traverse the dynar using the neat macro to that extend */
   xbt_dynar_foreach(d, cursor, cpt) {
-    xbt_test_assert2(cursor == cpt,
+    xbt_test_assert(cursor == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
@@ -864,12 +821,12 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   cpt = 0;
   xbt_dynar_foreach(d, cursor, i) {
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      i, cpt);
     cpt++;
   }
-  xbt_test_assert2(cpt == NB_ELEM,
+  xbt_test_assert(cpt == NB_ELEM,
                    "Cannot retrieve my %d values. Last got one is %d",
                    NB_ELEM, cpt);
 
@@ -877,10 +834,10 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* 4. Shift all the values */
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_shift(d, &i);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      i, cpt);
-    xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
+    xbt_test_log("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
   /* 5. Free the resources */
@@ -888,7 +845,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1("==== Unshift/pop %d int", NB_ELEM);
+  xbt_test_add("==== Unshift/pop %d int", NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_unshift(d, &cpt);
@@ -896,17 +853,17 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   }
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     i = xbt_dynar_pop_as(d, int);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      i, cpt);
-    xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
+    xbt_test_log("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
   }
   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
 
-  xbt_test_add1
+  xbt_test_add
       ("==== Push %d int, insert 1000 int in the middle, shift everything",
        NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
@@ -921,20 +878,20 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   for (cpt = 0; cpt < NB_ELEM/2; cpt++) {
     xbt_dynar_shift(d, &i);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one at the begining (%d!=%d)",
                      i, cpt);
     XBT_DEBUG("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
   }
   for (cpt = 999; cpt >= 0; cpt--) {
     xbt_dynar_shift(d, &i);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one in the middle (%d!=%d)",
                      i, cpt);
   }
   for (cpt = 2500; cpt < NB_ELEM; cpt++) {
     xbt_dynar_shift(d, &i);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "The retrieved value is not the same than the injected one at the end (%d!=%d)",
                      i, cpt);
   }
@@ -942,7 +899,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest",
+  xbt_test_add("==== Push %d int, remove 2000-4000. free the rest",
                 NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
   for (cpt = 0; cpt < NB_ELEM; cpt++)
@@ -950,7 +907,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   for (cpt = 2000; cpt < 4000; cpt++) {
     xbt_dynar_remove_at(d, 2000, &i);
-    xbt_test_assert2(i == cpt,
+    xbt_test_assert(i == cpt,
                      "Remove a bad value. Got %d, expected %d", i, cpt);
     XBT_DEBUG("remove %d, length=%lu", cpt, xbt_dynar_length(d));
   }
@@ -968,17 +925,17 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
   unsigned int cursor;
   int cpt;
 
-  xbt_test_add1("==== Insert %d int, traverse them, remove them",NB_ELEM);
+  xbt_test_add("==== Insert %d int, traverse them, remove them",NB_ELEM);
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     xbt_dynar_insert_at(d, cpt, &cpt);
-    xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
+    xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
   /* 3. Traverse the dynar */
   xbt_dynar_foreach(d, cursor, cpt) {
-    xbt_test_assert2(cursor == cpt,
+    xbt_test_assert(cursor == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
@@ -988,33 +945,33 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
   for (cpt = 0; cpt < NB_ELEM; cpt++)
     xbt_dynar_set_as(d, cpt, int, cpt);
   xbt_dynar_foreach(d, cursor, cpt)
-    xbt_test_assert2(cursor == cpt,
+    xbt_test_assert(cursor == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
 
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     int val;
     xbt_dynar_remove_at(d,0,&val);
-    xbt_test_assert2(cpt == val,
+    xbt_test_assert(cpt == val,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
-  xbt_test_assert1(xbt_dynar_length(d) == 0,
+  xbt_test_assert(xbt_dynar_is_empty(d),
                    "There is still %lu elements in the dynar after removing everything",
                    xbt_dynar_length(d));
   xbt_dynar_free(&d);
 
   /* ********************* */
-  xbt_test_add1("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
+  xbt_test_add("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
   for (cpt = NB_ELEM-1; cpt >=0; cpt--) {
     xbt_dynar_replace(d, cpt, &cpt);
-    xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
+    xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d));
   }
 
   /* 3. Traverse the dynar */
   xbt_dynar_foreach(d, cursor, cpt) {
-    xbt_test_assert2(cursor == cpt,
+    xbt_test_assert(cursor == cpt,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
@@ -1023,11 +980,11 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
   for (cpt =NB_ELEM-1; cpt >=0; cpt--) {
     int val;
     xbt_dynar_remove_at(d,xbt_dynar_length(d)-1,&val);
-    xbt_test_assert2(cpt == val,
+    xbt_test_assert(cpt == val,
                      "The retrieved value is not the same than the injected one (%d!=%d)",
                      cursor, cpt);
   }
-  xbt_test_assert1(xbt_dynar_length(d) == 0,
+  xbt_test_assert(xbt_dynar_is_empty(d),
                    "There is still %lu elements in the dynar after removing everything",
                    xbt_dynar_length(d));
   xbt_dynar_free(&d);
@@ -1043,17 +1000,17 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   unsigned int cursor;
   double d1, d2;
 
-  xbt_test_add0("==== Traverse the empty dynar");
+  xbt_test_add("==== Traverse the empty dynar");
   d = xbt_dynar_new(sizeof(int), NULL);
   xbt_dynar_foreach(d, cursor, cpt) {
-    xbt_test_assert0(FALSE,
+    xbt_test_assert(FALSE,
                      "Damnit, there is something in the empty dynar");
   }
   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add0("==== Push/shift 5000 doubles");
+  xbt_test_add("==== Push/shift 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
@@ -1061,14 +1018,14 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   }
   xbt_dynar_foreach(d, cursor, d2) {
     d1 = (double) cursor;
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_shift(d, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
@@ -1076,7 +1033,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add0("==== Unshift/pop 5000 doubles");
+  xbt_test_add("==== Unshift/pop 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
@@ -1085,7 +1042,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_pop(d, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
@@ -1095,7 +1052,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
 
 
 
-  xbt_test_add0
+  xbt_test_add
       ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
   d = xbt_dynar_new(sizeof(double), NULL);
   for (cpt = 0; cpt < 5000; cpt++) {
@@ -1110,7 +1067,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   for (cpt = 0; cpt < 2500; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_shift(d, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one at the begining (%f!=%f)",
                      d1, d2);
     XBT_DEBUG("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
@@ -1118,14 +1075,14 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   for (cpt = 999; cpt >= 0; cpt--) {
     d1 = (double) cpt;
     xbt_dynar_shift(d, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one in the middle (%f!=%f)",
                      d1, d2);
   }
   for (cpt = 2500; cpt < 5000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_shift(d, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
                      d1, d2);
   }
@@ -1134,7 +1091,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   /* in your code is naturally the way to go outside a regression test */
 
 
-  xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
+  xbt_test_add("==== Push 5000 double, remove 2000-4000. free the rest");
   d = xbt_dynar_new(sizeof(double), NULL);
   for (cpt = 0; cpt < 5000; cpt++) {
     d1 = (double) cpt;
@@ -1143,7 +1100,7 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   for (cpt = 2000; cpt < 4000; cpt++) {
     d1 = (double) cpt;
     xbt_dynar_remove_at(d, 2000, &d2);
-    xbt_test_assert2(d1 == d2,
+    xbt_test_assert(d1 == d2,
                      "Remove a bad value. Got %f, expected %f", d2, d1);
   }
   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
@@ -1165,17 +1122,17 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   char buf[1024];
   char *s1, *s2;
 
-  xbt_test_add0("==== Traverse the empty dynar");
+  xbt_test_add("==== Traverse the empty dynar");
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   xbt_dynar_foreach(d, iter, s1) {
-    xbt_test_assert0(FALSE,
+    xbt_test_assert(FALSE,
                      "Damnit, there is something in the empty dynar");
   }
   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
+  xbt_test_add("==== Push %d strings, set them again 3 times, shift them",
                 NB_ELEM);
   /* Populate_str [doxygen cruft] */
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
@@ -1203,7 +1160,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_shift(d, &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one (%s!=%s)",
                      buf, s2);
     free(s2);
@@ -1212,7 +1169,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
   /* in your code is naturally the way to go outside a regression test */
 
-  xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM);
+  xbt_test_add("==== Unshift, traverse and pop %d strings", NB_ELEM);
   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
@@ -1222,7 +1179,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   /* 2. Traverse the dynar with the macro */
   xbt_dynar_foreach(d, iter, s1) {
     sprintf(buf, "%d", NB_ELEM - iter - 1);
-    xbt_test_assert2(!strcmp(buf, s1),
+    xbt_test_assert(!strcmp(buf, s1),
                      "The retrieved value is not the same than the injected one (%s!=%s)",
                      buf, s1);
   }
@@ -1230,7 +1187,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_pop(d, &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one (%s!=%s)",
                      buf, s2);
     free(s2);
@@ -1241,7 +1198,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   /* in your code is naturally the way to go outside a regression test */
 
 
-  xbt_test_add2
+  xbt_test_add
       ("==== Push %d strings, insert %d strings in the middle, shift everything",
        NB_ELEM, NB_ELEM / 5);
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
@@ -1259,7 +1216,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_shift(d, &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)",
                      buf, s2);
     free(s2);
@@ -1267,7 +1224,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_shift(d, &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)",
                      buf, s2);
     free(s2);
@@ -1275,7 +1232,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_shift(d, &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one at the end (%s!=%s)",
                      buf, s2);
     free(s2);
@@ -1285,7 +1242,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   /* in your code is naturally the way to go outside a regression test */
 
 
-  xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest",
+  xbt_test_add("==== Push %d strings, remove %d-%d. free the rest",
                 NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   for (cpt = 0; cpt < NB_ELEM; cpt++) {
@@ -1296,7 +1253,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
     sprintf(buf, "%d", cpt);
     xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
-    xbt_test_assert2(!strcmp(buf, s2),
+    xbt_test_assert(!strcmp(buf, s2),
                      "Remove a bad value. Got %s, expected %s", s2, buf);
     free(s2);
   }
@@ -1320,7 +1277,7 @@ static void pusher_f(void *a)
 static void poper_f(void *a)
 {
   xbt_dynar_t d = (xbt_dynar_t) a;
-  int i;
+  volatile int i;
   int data;
   xbt_ex_t e;
 
@@ -1346,7 +1303,7 @@ XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of i
   xbt_dynar_t d;
   xbt_thread_t pusher, poper;
 
-  xbt_test_add0("==== Have a pusher and a popper on the dynar");
+  xbt_test_add("==== Have a pusher and a popper on the dynar");
   d = xbt_dynar_new_sync(sizeof(int), NULL);
   pusher = xbt_thread_create("pusher", pusher_f, d, 0 /*not joinable */ );
   poper = xbt_thread_create("poper", poper_f, d, 0 /*not joinable */ );