#define _dynar_lock(dynar) \
if (dynar->mutex) \
- xbt_mutex_lock(dynar->mutex)
+ xbt_mutex_acquire(dynar->mutex)
#define _dynar_unlock(dynar) \
if (dynar->mutex) \
- xbt_mutex_unlock(dynar->mutex)
+ xbt_mutex_release(dynar->mutex)
#define _sanity_check_dynar(dynar) \
xbt_assert0(dynar, \
"dynar is NULL")
const unsigned long new_length = new_size*elmsize;
char * const new_data = (char *) xbt_malloc0(elmsize*new_size);
- DEBUG3("expend %p from %lu to %d elements", (void*)dynar, (unsigned long)old_size, nb);
+ DEBUG3("expend %p from %lu to %lu elements", (void*)dynar, (unsigned long)old_size, nb);
if (old_data) {
memcpy(new_data, old_data, used_length);
void * const object) {
_dynar_lock(dynar);
- _xbt_dynar_remove_at(dynar, idx, object);
+ _xbt_dynar_remove_at(dynar, idx, object);
_dynar_unlock(dynar);
}
*/
void *
xbt_dynar_push_ptr(xbt_dynar_t const dynar) {
- return xbt_dynar_insert_at_ptr(dynar, dynar->used);
+ void *res;
+
+ /* we have to inline xbt_dynar_insert_at_ptr here to make sure that
+ dynar->used don't change between reading it and getting the lock
+ within xbt_dynar_insert_at_ptr */
+ _dynar_lock(dynar);
+ res = _xbt_dynar_insert_at_ptr(dynar,dynar->used);
+ _dynar_unlock(dynar);
+ return res;
}
/** @brief Add an element at the end of the dynar */
void
xbt_dynar_push(xbt_dynar_t const dynar,
const void * const src) {
- /* sanity checks done by insert_at */
- xbt_dynar_insert_at(dynar, dynar->used, src);
+ _dynar_lock(dynar);
+ /* checks done in xbt_dynar_insert_at_ptr */
+ memcpy(_xbt_dynar_insert_at_ptr(dynar,dynar->used),
+ src,
+ dynar->elmsize);
+ _dynar_unlock(dynar);
}
/** @brief Mark the last dynar's element as unused and return a pointer to it.
/* sanity checks done by remove_at */
DEBUG1("Pop %p",(void*)dynar);
- xbt_dynar_remove_at(dynar, dynar->used-1, dst);
+ _dynar_lock(dynar);
+ _xbt_dynar_remove_at(dynar, dynar->used-1, dst);
+ _dynar_unlock(dynar);
}
/** @brief Add an element at the begining of the dynar.
*/
void
_xbt_dynar_cursor_first(const xbt_dynar_t dynar,
- int * const cursor) {
+ unsigned int * const cursor) {
_dynar_lock(dynar);
DEBUG1("Set cursor on %p to the first position",(void*)dynar);
*/
void
_xbt_dynar_cursor_step(const xbt_dynar_t dynar,
- int * const cursor) {
+ unsigned int * const cursor) {
(*cursor)++;
}
*/
int
_xbt_dynar_cursor_get(const xbt_dynar_t dynar,
- int * const cursor,
+ unsigned int * const cursor,
void * const dst) {
_sanity_check_dynar(dynar);
_dynar_unlock(dynar);
return FALSE;
}
- DEBUG2("Cash out cursor on %p at %d",(void*)dynar,idx);
+ DEBUG2("Cash out cursor on %p at %lu",(void*)dynar,idx);
_xbt_dynar_get_elm(dst, dynar, idx);
}
* This function can be used while traversing without problem.
*/
void xbt_dynar_cursor_rm(xbt_dynar_t dynar,
- int * const cursor) {
+ unsigned int * const cursor) {
_xbt_dynar_remove_at(dynar,(*cursor)--,NULL);
}
XBT_TEST_UNIT("int",test_dynar_int,"Dynars of integers") {
/* Vars_decl [doxygen cruft] */
xbt_dynar_t d;
- int i,cpt,cursor;
+ int i,cpt;
+ unsigned int cursor;
int *iptr;
xbt_test_add0("==== Traverse the empty dynar");
/*******************************************************************************/
XBT_TEST_UNIT("double",test_dynar_double,"Dynars of doubles") {
xbt_dynar_t d;
- int cpt,cursor;
+ int cpt;
+ unsigned int cursor;
double d1,d2;
xbt_test_add0("==== Traverse the empty dynar");
/* doxygen_string_cruft */
-/* The function we will use to free the data */
-static void free_string(void *d){
- free(*(void**)d);
-}
-
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
XBT_TEST_UNIT("string",test_dynar_string,"Dyars of strings") {
xbt_dynar_t d;
int cpt;
+ unsigned int iter;
char buf[1024];
char *s1,*s2;
xbt_test_add0("==== Traverse the empty dynar");
- d=xbt_dynar_new(sizeof(char *),&free_string);
- xbt_dynar_foreach(d,cpt,s1){
+ d=xbt_dynar_new(sizeof(char *),&xbt_free_ref);
+ xbt_dynar_foreach(d,iter,s1){
xbt_test_assert0(FALSE,
"Damnit, there is something in the empty dynar");
}
xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",NB_ELEM);
/* Populate_str [doxygen cruft] */
- d=xbt_dynar_new(sizeof(char*),&free_string);
+ d=xbt_dynar_new(sizeof(char*),&xbt_free_ref);
/* 1. Populate the dynar */
for (cpt=0; cpt< NB_ELEM; cpt++) {
sprintf(buf,"%d",cpt);
xbt_test_add1("==== Unshift, traverse and pop %d strings",NB_ELEM);
- d=xbt_dynar_new(sizeof(char**),&free_string);
+ d=xbt_dynar_new(sizeof(char**),&xbt_free_ref);
for (cpt=0; cpt< NB_ELEM; cpt++) {
sprintf(buf,"%d",cpt);
s1=strdup(buf);
xbt_dynar_unshift(d,&s1);
}
/* 2. Traverse the dynar with the macro */
- xbt_dynar_foreach(d,cpt,s1) {
- sprintf(buf,"%d",NB_ELEM - cpt -1);
+ xbt_dynar_foreach(d,iter,s1) {
+ sprintf(buf,"%d",NB_ELEM - iter -1);
xbt_test_assert2 (!strcmp(buf,s1),
"The retrieved value is not the same than the injected one (%s!=%s)",
buf,s1);
xbt_test_add2("==== Push %d strings, insert %d strings in the middle, shift everything",NB_ELEM,NB_ELEM/5);
- d=xbt_dynar_new(sizeof(char*),&free_string);
+ d=xbt_dynar_new(sizeof(char*),&xbt_free_ref);
for (cpt=0; cpt< NB_ELEM; cpt++) {
sprintf(buf,"%d",cpt);
s1=strdup(buf);
xbt_test_add3("==== 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*),&free_string);
+ d=xbt_dynar_new(sizeof(char*),&xbt_free_ref);
for (cpt=0; cpt< NB_ELEM; cpt++) {
sprintf(buf,"%d",cpt);
s1=strdup(buf);