X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a45aaae8ebc4570ee3d14f2c4bfe2d6bc3aa177e..4a201b7ceece70d2bc461ac48c8b746a36d07243:/src/xbt/dynar.c diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c index 0b59641ff5..9cdc39febb 100644 --- a/src/xbt/dynar.c +++ b/src/xbt/dynar.c @@ -1,5 +1,3 @@ -/* $Id$ */ - /* a generic DYNamic ARray implementation. */ /* Copyright (c) 2003, 2004 Martin Quinson. All rights reserved. */ @@ -89,7 +87,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 +101,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 +169,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 +252,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 +288,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 +297,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 +311,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 +329,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 +340,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 +361,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 +400,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 +485,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 +557,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 +571,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 +584,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 +598,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 +612,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 +623,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 +651,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 +667,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 +679,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 +705,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 +769,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 +786,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 +823,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 +838,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 +858,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 +881,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 +898,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 +938,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 +955,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 +979,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 +1016,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 +1044,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 +1088,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 +1156,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);