X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d40711aa68b41790dac747008cf849ac965c4793..797980252c46782a2b6afdc729088af5acff79bf:/src/xbt/context.c diff --git a/src/xbt/context.c b/src/xbt/context.c index 4d7f81850d..136411cf09 100644 --- a/src/xbt/context.c +++ b/src/xbt/context.c @@ -24,10 +24,7 @@ static xbt_context_t current_context = NULL; static xbt_context_t init_context = NULL; static xbt_swag_t context_to_destroy = NULL; static xbt_swag_t context_living = NULL; -#ifdef CONTEXT_THREADS -static xbt_os_mutex_t creation_mutex; -static xbt_os_cond_t creation_cond; -#endif + /********************/ @@ -36,19 +33,43 @@ static xbt_os_cond_t creation_cond; #ifndef CONTEXT_THREADS /* callback: context fetching (used only with ucontext, os_thread deal with it for us otherwise) */ -static ex_ctx_t *_context_ex_ctx(void) { +static ex_ctx_t *_context_ex_ctx(void) +{ return current_context->exception; } /* callback: termination */ -static void _context_ex_terminate(xbt_ex_t * e) { +static void _context_ex_terminate(xbt_ex_t * e) +{ xbt_ex_display(e); abort(); /* FIXME: there should be a configuration variable to choose to kill everyone or only this one */ } -#endif +#endif + +#ifdef CONTEXT_THREADS + +static void +schedule(xbt_context_t c); + +static void +yield(xbt_context_t c); + +static void +schedule(xbt_context_t c) +{ + xbt_os_sem_release(c->begin); + xbt_os_sem_acquire(c->end); +} + +static void yield(xbt_context_t c) +{ + xbt_os_sem_release(c->end); + xbt_os_sem_acquire(c->begin); +} +#endif /** \name Functions * \ingroup XBT_context @@ -63,17 +84,13 @@ void xbt_context_init(void) if (!current_context) { current_context = init_context = xbt_new0(s_xbt_context_t, 1); DEBUG1("Init Context (%p)", init_context); - - init_context->iwannadie = 0; /* useless but makes valgrind happy */ + init_context->iwannadie = 0; /* useless but makes valgrind happy */ context_to_destroy = - xbt_swag_new(xbt_swag_offset(*current_context, hookup)); - context_living = - xbt_swag_new(xbt_swag_offset(*current_context, hookup)); + xbt_swag_new(xbt_swag_offset(*current_context, hookup)); + context_living = xbt_swag_new(xbt_swag_offset(*current_context, hookup)); xbt_swag_insert(init_context, context_living); -#ifdef CONTEXT_THREADS - creation_mutex = xbt_os_mutex_init(); - creation_cond = xbt_os_cond_init(); -#else + + #ifndef CONTEXT_THREADS init_context->exception = xbt_new(ex_ctx_t, 1); XBT_CTX_INITIALIZE(init_context->exception); __xbt_ex_ctx = _context_ex_ctx; @@ -91,17 +108,17 @@ void xbt_context_exit(void) xbt_context_t context = NULL; xbt_context_empty_trash(); + while ((context = xbt_swag_extract(context_living))) { if (context != init_context) { xbt_context_kill(context); } } -#ifdef CONTEXT_THREADS - xbt_os_mutex_destroy(creation_mutex); - xbt_os_cond_destroy(creation_cond); -#else + +#ifndef CONTEXT_THREADS free(init_context->exception); #endif + free(init_context); init_context = current_context = NULL; @@ -111,6 +128,7 @@ void xbt_context_exit(void) } + /*******************************/ /* Object creation/destruction */ /*******************************/ @@ -125,11 +143,14 @@ void xbt_context_exit(void) * \param argc first argument of function \a code * \param argv seconde argument of function \a code */ -xbt_context_t xbt_context_new(const char *name,xbt_main_func_t code, - void_f_pvoid_t startup_func, - void *startup_arg, - void_f_pvoid_t cleanup_func, - void *cleanup_arg, int argc, char *argv[]) +xbt_context_t +xbt_context_new(const char *name, + xbt_main_func_t code, + void_f_pvoid_t startup_func, + void *startup_arg, + void_f_pvoid_t cleanup_func, + void *cleanup_arg, int argc, char *argv[] + ) { xbt_context_t res = NULL; @@ -137,27 +158,31 @@ xbt_context_t xbt_context_new(const char *name,xbt_main_func_t code, res->code = code; res->name = xbt_strdup(name); + #ifdef CONTEXT_THREADS - res->mutex = xbt_os_mutex_init(); - res->cond = xbt_os_cond_init(); + /* + * initialize the semaphores used to schedule/yield + * the process associated to the newly created context + */ + res->begin = xbt_os_sem_init(0); + res->end = xbt_os_sem_init(0); #else xbt_assert2(getcontext(&(res->uc)) == 0, - "Error in context saving: %d (%s)", errno, strerror(errno)); + "Error in context saving: %d (%s)", errno, strerror(errno)); res->uc.uc_link = NULL; /* res->uc.uc_link = &(current_context->uc); */ /* WARNING : when this context is over, the current_context (i.e. the father), is awaken... Theorically, the wrapper should prevent using this feature. */ res->uc.uc_stack.ss_sp = pth_skaddr_makecontext(res->stack, STACK_SIZE); - res->uc.uc_stack.ss_size = - pth_sksize_makecontext(res->stack, STACK_SIZE); - + res->uc.uc_stack.ss_size = pth_sksize_makecontext(res->stack, STACK_SIZE); + res->exception = xbt_new(ex_ctx_t, 1); XBT_CTX_INITIALIZE(res->exception); -#endif /* CONTEXT_THREADS or not */ +#endif /* CONTEXT_THREADS or not */ - res->iwannadie = 0; /* useless but makes valgrind happy */ + res->iwannadie = 0; /* useless but makes valgrind happy */ res->argc = argc; res->argv = argv; @@ -192,19 +217,24 @@ xbt_context_t xbt_context_new(const char *name,xbt_main_func_t code, * (same than first case afterward) */ + /* Argument must be stopped first -- runs in maestro context */ -static void xbt_context_free(xbt_context_t context) { +static void xbt_context_free(xbt_context_t context) +{ int i; - + if (!context) return; + DEBUG1("Freeing %p", context); free(context->name); - + DEBUG0("Freeing arguments"); + for (i = 0; i < context->argc; i++) if (context->argv[i]) free(context->argv[i]); + if (context->argv) free(context->argv); @@ -213,19 +243,19 @@ static void xbt_context_free(xbt_context_t context) { xbt_os_thread_join(context->thread, NULL); - xbt_os_mutex_destroy(context->mutex); - xbt_os_cond_destroy(context->cond); + /* destroy the semaphore used to schedule/unshedule the process */ + xbt_os_sem_destroy(context->begin); + xbt_os_sem_destroy(context->end); context->thread = NULL; - context->mutex = NULL; - context->cond = NULL; + context->begin = NULL; + context->end = NULL; #else if (context->exception) free(context->exception); #endif - + free(context); - return; } /************************/ @@ -240,28 +270,10 @@ static void *__context_wrapper(void *c) #ifdef CONTEXT_THREADS context = (xbt_context_t) c; - context->thread = xbt_os_thread_self(); - - DEBUG3("**[ctx:%p;self:%p]** Lock creation_mutex %p ****", context, - (void *) xbt_os_thread_self(), creation_mutex); - xbt_os_mutex_lock(creation_mutex); - xbt_os_mutex_lock(context->mutex); - - DEBUG4 - ("**[ctx:%p;self:%p]** Releasing the creator (creation_cond %p,%p) ****", - context, (void *) xbt_os_thread_self(), creation_cond, - creation_mutex); - xbt_os_cond_signal(creation_cond); - xbt_os_mutex_unlock(creation_mutex); + /*context->thread = xbt_os_thread_self();*/ - DEBUG4("**[ctx:%p;self:%p]** Going to Jail on lock %p and cond %p ****", - context, (void *) xbt_os_thread_self(), context->mutex, - context->cond); - xbt_os_cond_wait(context->cond, context->mutex); - - DEBUG3("**[ctx:%p;self:%p]** Unlocking individual %p ****", - context, (void *) xbt_os_thread_self(), context->mutex); - xbt_os_mutex_unlock(context->mutex); + /* signal its starting to the maestro and wait to start its job*/ + yield(context); #endif @@ -282,34 +294,19 @@ static void *__context_wrapper(void *c) void xbt_context_start(xbt_context_t context) { #ifdef CONTEXT_THREADS - /* Launch the thread */ - - DEBUG3("**[ctx:%p;self:%p]** Locking creation_mutex %p ****", context, - xbt_os_thread_self(), creation_mutex); - xbt_os_mutex_lock(creation_mutex); - - DEBUG2("**[ctx:%p;self:%p]** Thread create ****", context, - xbt_os_thread_self()); + /* create the process and start it */ context->thread = xbt_os_thread_create(context->name,__context_wrapper, context); - DEBUG3("**[ctx:%p;self:%p]** Thread created : %p ****", context, - xbt_os_thread_self(), context->thread); - - DEBUG4 - ("**[ctx:%p;self:%p]** Going to jail on creation_cond/mutex (%p,%p) ****", - context, xbt_os_thread_self(), creation_cond, creation_mutex); - xbt_os_cond_wait(creation_cond, creation_mutex); - DEBUG3("**[ctx:%p;self:%p]** Unlocking creation %p ****", context, - xbt_os_thread_self(), creation_mutex); - xbt_os_mutex_unlock(creation_mutex); + + /* wait the starting of the newly created process */ + xbt_os_sem_acquire(context->end); #else - makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1, - context); + makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1, context); #endif - return; } /* Stops current context: calls user's cleanup function, kills os thread, and yields back to maestro */ -static void xbt_context_stop(int retvalue) { +static void xbt_context_stop(int retvalue) +{ DEBUG1("--------- %p is exiting ---------", current_context); if (current_context->cleanup_func) { @@ -324,19 +321,14 @@ static void xbt_context_stop(int retvalue) { DEBUG0("Yielding"); #ifdef CONTEXT_THREADS - DEBUG2("[%p] **** Locking %p ****", current_context, current_context->mutex); - xbt_os_mutex_lock(current_context->mutex); - DEBUG1("[%p] **** Releasing the prisonner ****", current_context); - xbt_os_cond_signal(current_context->cond); - DEBUG2("[%p] **** Unlocking individual %p ****", current_context, - current_context->mutex); - xbt_os_mutex_unlock(current_context->mutex); - DEBUG1("[%p] **** Exiting ****", current_context); - xbt_os_thread_exit(NULL); // We should provide return value in case other wants it + /* signal to the maestro that it has finished */ + xbt_os_sem_release(current_context->end); + /* exit*/ + xbt_os_thread_exit(NULL); /* We should provide return value in case other wants it */ #else __xbt_context_yield(current_context); #endif - xbt_assert0(0, "You can't be here!"); + THROW_IMPOSSIBLE; } @@ -349,8 +341,10 @@ static void xbt_context_stop(int retvalue) { void xbt_context_empty_trash(void) { xbt_context_t context = NULL; + DEBUG1("Emptying trashbin (%d contexts to free)", - xbt_swag_size(context_to_destroy)); + xbt_swag_size(context_to_destroy)); + while ((context = xbt_swag_extract(context_to_destroy))) xbt_context_free(context); } @@ -361,37 +355,53 @@ void xbt_context_empty_trash(void) static void __xbt_context_yield(xbt_context_t context) { -#ifdef CONTEXT_THREADS - xbt_context_t self; -#endif -xbt_assert0(current_context, "You have to call context_init() first."); - xbt_assert0(context,"Invalid argument"); + xbt_assert0(current_context, "You have to call context_init() first."); + xbt_assert0(context, "Invalid argument"); if (current_context == context) { - DEBUG1("--------- current_context (%p) is yielding back to maestro ---------", - context); + DEBUG1 + ("--------- current_context (%p) is yielding back to maestro ---------", + context); } else { - DEBUG2("--------- current_context (%p) is yielding to context(%p) ---------", + DEBUG2 + ("--------- current_context (%p) is yielding to context(%p) ---------", current_context, context); } #ifdef CONTEXT_THREADS - self = current_context; - DEBUG2("[%p] **** Locking ctx %p ****", self, context); - xbt_os_mutex_lock(context->mutex); - DEBUG1("[%p] **** Updating current_context ****", self); - current_context = context; - DEBUG1("[%p] **** Releasing the prisonner ****", self); - xbt_os_cond_signal(context->cond); - DEBUG3("[%p] **** Going to jail on individual %p/%p ****", self, - context->cond, context->mutex); - xbt_os_cond_wait(context->cond, context->mutex); - DEBUG2("[%p] **** Unlocking individual %p ****", self, context->mutex); - xbt_os_mutex_unlock(context->mutex); - DEBUG1("[%p] **** Updating current_context ****", self); - current_context = self; - -#else /* use SUSv2 contexts */ + + if(current_context != init_context && !context->iwannadie) + {/* it's a process and it doesn't wants to die (xbt_context_yield()) */ + + /* save the current context */ + xbt_context_t self = current_context; + + /* update the current context to this context */ + current_context = context; + + /* yield itself */ + yield(context); + + /* restore the current context to the previously saved context */ + current_context = self; + } + else + { /* maestro wants to schedule a process or a process wants to die (xbt_context_schedule() or xbt_context_kill())*/ + + /* save the current context */ + xbt_context_t self = current_context; + + /* update the current context */ + current_context = context; + + /* schedule the process associated with this context */ + schedule(context); + + /* restore the current context to the previously saved context */ + current_context = self; + } + +#else /* use SUSv2 contexts */ VOIRP(current_context); VOIRP(current_context->save); @@ -401,44 +411,39 @@ xbt_assert0(current_context, "You have to call context_init() first."); int return_value = 0; if (context->save == NULL) { - xbt_assert(context == current_context); DEBUG1("[%p] **** Yielding to somebody else ****", current_context); DEBUG2("Saving current_context value (%p) to context(%p)->save", - current_context, context); + current_context, context); context->save = current_context; DEBUG1("current_context becomes context(%p) ", context); current_context = context; DEBUG1 - ("Current position memorized (context->save). Jumping to context (%p)", - context); + ("Current position memorized (context->save). Jumping to context (%p)", + context); return_value = swapcontext(&(context->save->uc), &(context->uc)); xbt_assert0((return_value == 0), "Context swapping failure"); DEBUG1("I am (%p). Coming back\n", context); } else { xbt_context_t old_context = context->save; + DEBUG1("[%p] **** Back ! ****", context); DEBUG2("Setting current_context (%p) to context(%p)->save", - current_context, context); + current_context, context); current_context = context->save; DEBUG1("Setting context(%p)->save to NULL", context); context->save = NULL; DEBUG2("Current position memorized (%p). Jumping to context (%p)", - context, old_context); + context, old_context); return_value = swapcontext(&(context->uc), &(old_context->uc)); xbt_assert0((return_value == 0), "Context swapping failure"); DEBUG1("I am (%p). Coming back\n", context); } #endif + if (current_context->iwannadie) xbt_context_stop(1); - - return; } - - - - /** * Calling this function makes the current context yield. The context * that scheduled it returns from xbt_context_schedule as if nothing @@ -465,7 +470,7 @@ void xbt_context_schedule(xbt_context_t context) { DEBUG1("Scheduling %p", context); xbt_assert0((current_context == init_context), - "You are not supposed to run this function here!"); + "You are not supposed to run this function here!"); __xbt_context_yield(context); } @@ -480,20 +485,15 @@ void xbt_context_kill(xbt_context_t context) DEBUG1("Killing %p", context); context->iwannadie = 1; + DEBUG1("Scheduling %p", context); __xbt_context_yield(context); DEBUG1("End of Scheduling %p", context); - - return; } /* Java cruft I'm gonna kill in the next cleanup round */ void xbt_context_set_jprocess(xbt_context_t context, void *jp){} void* xbt_context_get_jprocess(xbt_context_t context){return NULL;} -void xbt_context_set_jmutex(xbt_context_t context,void *jm){} -void* xbt_context_get_jmutex(xbt_context_t context){return NULL;} -void xbt_context_set_jcond(xbt_context_t context,void *jc){} -void* xbt_context_get_jcond(xbt_context_t context){return NULL;} void xbt_context_set_jenv(xbt_context_t context,void* je){} void* xbt_context_get_jenv(xbt_context_t context){return NULL;}