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

diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c
index 0b59641ff5..812ff7f096 100644
--- a/src/xbt/dynar.c
+++ b/src/xbt/dynar.c
@@ -89,7 +89,6 @@ static XBT_INLINE
     char *const old_data = (char *) dynar->data;
 
     const unsigned long elmsize = dynar->elmsize;
-    const unsigned long old_length = old_size * elmsize;
 
     const unsigned long used = dynar->used;
     const unsigned long used_length = used * elmsize;
@@ -104,7 +103,6 @@ static XBT_INLINE
 
     if (old_data) {
       memcpy(new_data, old_data, used_length);
-      _xbt_clear_mem(old_data, old_length);
       free(old_data);
     }
 
@@ -173,9 +171,11 @@ _xbt_dynar_remove_at(xbt_dynar_t const dynar,
   }
 
   nb_shift = dynar->used - 1 - idx;
-  offset = nb_shift * dynar->elmsize;
 
-  memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1), offset);
+  if (nb_shift) {
+    offset = nb_shift * dynar->elmsize;
+    memmove(_xbt_dynar_elm(dynar, idx), _xbt_dynar_elm(dynar, idx + 1), offset);
+  }
 
   dynar->used--;
 }
@@ -254,7 +254,7 @@ void xbt_dynar_free_container(xbt_dynar_t * dynar)
  *
  * \param dynar who to squeeze
  */
-void xbt_dynar_reset(xbt_dynar_t const dynar)
+XBT_INLINE void xbt_dynar_reset(xbt_dynar_t const dynar)
 {
   _dynar_lock(dynar);
 
@@ -290,7 +290,7 @@ void xbt_dynar_reset(xbt_dynar_t const dynar)
  * Set \a empty_slots_wanted to zero to reduce the dynar internal array as much
  * as possible.
  * Note that if \a empty_slots_wanted is greater than the array size, the internal
- * array is not expanded and nothing is done.
+ * array is expanded instead of shriked.
  */
 void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted)
 {
@@ -299,7 +299,7 @@ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted)
   _dynar_lock(dynar);
 
   size_wanted = dynar->used + empty_slots_wanted;
-  if (size_wanted < dynar->size) {
+  if (size_wanted != dynar->size) {
     dynar->size = size_wanted;
     dynar->data = xbt_realloc(dynar->data, sizeof(void *) * dynar->size);
   }
@@ -313,7 +313,7 @@ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted)
  * kilkil a dynar and its content
  */
 
-void xbt_dynar_free(xbt_dynar_t * dynar)
+XBT_INLINE void xbt_dynar_free(xbt_dynar_t * dynar)
 {
   if (dynar && *dynar) {
     xbt_dynar_reset(*dynar);
@@ -331,7 +331,7 @@ void xbt_dynar_free_voidp(void *d)
  *
  * \param dynar the dynar we want to mesure
  */
-unsigned long xbt_dynar_length(const xbt_dynar_t dynar)
+XBT_INLINE unsigned long xbt_dynar_length(const xbt_dynar_t dynar)
 {
   return (dynar ? (unsigned long) dynar->used : (unsigned long) 0);
 }
@@ -342,7 +342,7 @@ unsigned long xbt_dynar_length(const xbt_dynar_t dynar)
  * \param idx index of the slot we want to retrieve
  * \param[out] dst where to put the result to.
  */
-void
+XBT_INLINE void
 xbt_dynar_get_cpy(const xbt_dynar_t dynar,
                   const unsigned long idx, void *const dst)
 {
@@ -363,7 +363,7 @@ xbt_dynar_get_cpy(const xbt_dynar_t dynar,
  * \warning The returned value is the actual content of the dynar.
  * Make a copy before fooling with it.
  */
-void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx)
+XBT_INLINE void *xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx)
 {
 
   void *res;
@@ -402,7 +402,7 @@ _xbt_dynar_set(xbt_dynar_t dynar,
  *
  * If you want to free the previous content, use xbt_dynar_replace().
  */
-void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *const src)
+XBT_INLINE void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *const src)
 {
 
   _dynar_lock(dynar);
@@ -487,7 +487,7 @@ void *xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx)
  * moving the previously existing value and all subsequent ones to one
  * position right in the dynar.
  */
-void
+XBT_INLINE void
 xbt_dynar_insert_at(xbt_dynar_t const dynar,
                     const int idx, const void *const src)
 {
@@ -559,7 +559,7 @@ int xbt_dynar_member(xbt_dynar_t const dynar, void *const elem)
  * You can then use regular affectation to set its value instead of relying
  * on the slow memcpy. This is what xbt_dynar_push_as() does.
  */
-void *xbt_dynar_push_ptr(xbt_dynar_t const dynar)
+XBT_INLINE void *xbt_dynar_push_ptr(xbt_dynar_t const dynar)
 {
   void *res;
 
@@ -573,7 +573,7 @@ void *xbt_dynar_push_ptr(xbt_dynar_t const dynar)
 }
 
 /** @brief Add an element at the end of the dynar */
-void xbt_dynar_push(xbt_dynar_t const dynar, const void *const src)
+XBT_INLINE void xbt_dynar_push(xbt_dynar_t const dynar, const void *const src)
 {
   _dynar_lock(dynar);
   /* checks done in xbt_dynar_insert_at_ptr */
@@ -586,7 +586,7 @@ void xbt_dynar_push(xbt_dynar_t const dynar, const void *const src)
  * You can then use regular affectation to set its value instead of relying
  * on the slow memcpy. This is what xbt_dynar_pop_as() does.
  */
-void *xbt_dynar_pop_ptr(xbt_dynar_t const dynar)
+XBT_INLINE void *xbt_dynar_pop_ptr(xbt_dynar_t const dynar)
 {
   void *res;
 
@@ -600,7 +600,7 @@ void *xbt_dynar_pop_ptr(xbt_dynar_t const dynar)
 }
 
 /** @brief Get and remove the last element of the dynar */
-void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst)
+XBT_INLINE void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst)
 {
 
   /* sanity checks done by remove_at */
@@ -614,7 +614,7 @@ void xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst)
  *
  * This is less efficient than xbt_dynar_push()
  */
-void xbt_dynar_unshift(xbt_dynar_t const dynar, const void *const src)
+XBT_INLINE void xbt_dynar_unshift(xbt_dynar_t const dynar, const void *const src)
 {
 
   /* sanity checks done by insert_at */
@@ -625,7 +625,7 @@ void xbt_dynar_unshift(xbt_dynar_t const dynar, const void *const src)
  *
  * This is less efficient than xbt_dynar_pop()
  */
-void xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst)
+XBT_INLINE void xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst)
 {
 
   /* sanity checks done by remove_at */
@@ -653,7 +653,7 @@ static void _dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
  * operation, so make sure your function don't call any function
  * from xbt_dynar_* on it, or you'll get a deadlock.
  */
-void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
+XBT_INLINE void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
 {
 
   _sanity_check_dynar(dynar);
@@ -669,7 +669,7 @@ void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op)
  *
  * This function can be used while traversing without problem.
  */
-void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor)
+XBT_INLINE void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor)
 {
 
   _xbt_dynar_remove_at(dynar, (*cursor)--, NULL);
@@ -681,7 +681,7 @@ void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor)
  * xbt_dynar_foreach loop, but shouldn't be called at the end of a
  * regular traversal reaching the end of the elements
  */
-void xbt_dynar_cursor_unlock(xbt_dynar_t dynar)
+XBT_INLINE void xbt_dynar_cursor_unlock(xbt_dynar_t dynar)
 {
   _dynar_unlock(dynar);
 }
@@ -707,8 +707,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   xbt_dynar_foreach(d, cursor, i) {
     xbt_assert0(0, "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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
     ("==== Push %d int, set them again 3 times, traverse them, shift them",
@@ -770,9 +771,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   }
 
   /* 5. Free the resources */
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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("==== Unshift/pop %d int", NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
@@ -787,8 +788,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      i, cpt);
     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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
@@ -823,9 +825,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      "The retrieved value is not the same than the injected one at the end (%d!=%d)",
                      i, cpt);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM);
   d = xbt_dynar_new(sizeof(int), NULL);
@@ -838,8 +840,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
                      "Remove a bad value. Got %d, expected %d", i, cpt);
     DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d));
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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 */
 }
 
 /*******************************************************************************/
@@ -857,8 +860,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
   xbt_dynar_foreach(d, cursor, cpt) {
     xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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_add0("==== Push/shift 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
@@ -879,9 +883,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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_add0("==== Unshift/pop 5000 doubles");
   d = xbt_dynar_new(sizeof(double), NULL);
@@ -896,8 +900,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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 */
 
 
 
@@ -935,8 +940,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
                      d1, d2);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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_add0("==== Push 5000 double, remove 2000-4000. free the rest");
@@ -951,8 +957,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
     xbt_test_assert2(d1 == d2,
                      "Remove a bad value. Got %f, expected %f", d2, d1);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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 */
 }
 
 
@@ -974,8 +981,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   xbt_dynar_foreach(d, iter, s1) {
     xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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("==== Push %d strings, set them again 3 times, shift them",
                 NB_ELEM);
@@ -1010,9 +1018,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
                      buf, s2);
     free(s2);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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("==== Unshift, traverse and pop %d strings", NB_ELEM);
   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
@@ -1038,8 +1046,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
     free(s2);
   }
   /* 4. Free the resources */
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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_add2
@@ -1081,8 +1090,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
                      buf, s2);
     free(s2);
   }
-  xbt_dynar_free(&d);
-  xbt_dynar_free(&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_add3("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM,
@@ -1148,8 +1158,8 @@ XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of in
 
   xbt_test_add0("==== 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);
-  poper = xbt_thread_create("poper", poper_f, d);
+  pusher = xbt_thread_create("pusher", pusher_f, d,0/*not joinable*/);
+  poper = xbt_thread_create("poper", poper_f, d,0/*not joinable*/);
   xbt_thread_join(pusher);
   xbt_thread_join(poper);
   xbt_dynar_free(&d);