X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7cd83128b3740b3d66ef8d8a2ced0ffa5168efe2..645feae364d69d74fbed1325a905f7db436240d2:/src/xbt/context.c

diff --git a/src/xbt/context.c b/src/xbt/context.c
index 90b7fae229..9d313f5c83 100644
--- a/src/xbt/context.c
+++ b/src/xbt/context.c
@@ -27,6 +27,28 @@ static xbt_swag_t context_living = NULL;
 #ifdef CONTEXT_THREADS
 static xbt_os_mutex_t creation_mutex;
 static xbt_os_cond_t creation_cond;
+static xbt_os_mutex_t master_mutex;
+static xbt_os_cond_t master_cond;
+
+#ifdef WIN32
+static DWORD __current_thread_id = 0;
+#else
+static pthread_t __current_thread_id;
+#endif
+
+static int
+is_main_thread(void);
+
+static int
+is_main_thread(void)
+{
+	#ifdef WIN32
+	return (GetCurrentThreadId() == __current_thread_id) ? 1 : 0;
+	#else
+	return (pthread_self() == __current_thread_id) ? 1 : 0;
+	#endif
+}
+
 #endif
 
 
@@ -58,56 +80,75 @@ static void _context_ex_terminate(xbt_ex_t * e) {
  *
  * \warning It has to be called before using any other function of this module.
  */
-void xbt_context_init(void)
+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 */
-    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_insert(init_context, context_living);
-#ifdef CONTEXT_THREADS
-    creation_mutex = xbt_os_mutex_init();
-    creation_cond = xbt_os_cond_init();
-#else
-    init_context->exception = xbt_new(ex_ctx_t, 1);
-    XBT_CTX_INITIALIZE(init_context->exception);
-    __xbt_ex_ctx = _context_ex_ctx;
-    __xbt_ex_terminate = _context_ex_terminate;
-#endif
-  }
+	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 */
+		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_insert(init_context, context_living);
+		
+		#ifdef CONTEXT_THREADS
+		  /* only used during the creation of the processes */
+		  creation_mutex = xbt_os_mutex_init();
+		  creation_cond = xbt_os_cond_init();
+
+		  /* used to schedule/unschedule the processes */
+		  master_mutex = xbt_os_mutex_init();
+		  master_cond = xbt_os_cond_init();
+
+		  #ifdef WIN32
+		    __current_thread_id = GetCurrentThreadId();
+		  #else
+		    __current_thread_id = pthread_self();
+		  #endif
+		#else
+		  init_context->exception = xbt_new(ex_ctx_t, 1);
+		  XBT_CTX_INITIALIZE(init_context->exception);
+		  __xbt_ex_ctx = _context_ex_ctx;
+		  __xbt_ex_terminate = _context_ex_terminate;
+		#endif
+	}
 }
 
 /** 
  * This function kill all existing context and free all the memory
  * that has been allocated in this module.
  */
-void xbt_context_exit(void)
+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   
-  free(init_context->exception);
-#endif
-  free(init_context);
-  init_context = current_context = NULL;
-
-  xbt_context_empty_trash();
-  xbt_swag_free(context_to_destroy);
-  xbt_swag_free(context_living);
+	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);
+	  xbt_os_mutex_destroy(master_mutex);
+	  xbt_os_cond_destroy(master_cond);
+	#else   
+	  free(init_context->exception);
+	#endif
+	
+	free(init_context);
+	init_context = current_context = NULL;
+
+	xbt_context_empty_trash();
+	xbt_swag_free(context_to_destroy);
+	xbt_swag_free(context_living);
 
 }
 
@@ -125,50 +166,56 @@ 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;
+	xbt_context_t res = NULL;
 
-  res = xbt_new0(s_xbt_context_t, 1);
+	res = xbt_new0(s_xbt_context_t, 1);
 
-  res->code = code;
-  res->name = xbt_strdup(name);
-#ifdef CONTEXT_THREADS
-  res->mutex = xbt_os_mutex_init();
-  res->cond = xbt_os_cond_init();
-#else
+	res->code = code;
+	res->name = xbt_strdup(name);
+
+	#ifdef CONTEXT_THREADS
+	  res->mutex = xbt_os_mutex_init();
+	  res->cond = xbt_os_cond_init();
+	#else
+
+	  xbt_assert2(getcontext(&(res->uc)) == 0,
+	  "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->exception = xbt_new(ex_ctx_t, 1);
+	  XBT_CTX_INITIALIZE(res->exception);
+	#endif				/* CONTEXT_THREADS or not */
+
+	res->iwannadie = 0; /* useless but makes valgrind happy */
+
+	res->argc = argc;
+	res->argv = argv;
+	res->startup_func = startup_func;
+	res->startup_arg = startup_arg;
+	res->cleanup_func = cleanup_func;
+	res->cleanup_arg = cleanup_arg;
+
+	xbt_swag_insert(res, context_living);
 
-  xbt_assert2(getcontext(&(res->uc)) == 0,
-	      "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->exception = xbt_new(ex_ctx_t, 1);
-  XBT_CTX_INITIALIZE(res->exception);
-#endif				/* CONTEXT_THREADS or not */
-
-  res->iwannadie = 0; /* useless but makes valgrind happy */
-
-  res->argc = argc;
-  res->argv = argv;
-  res->startup_func = startup_func;
-  res->startup_arg = startup_arg;
-  res->cleanup_func = cleanup_func;
-  res->cleanup_arg = cleanup_arg;
-
-  xbt_swag_insert(res, context_living);
-
-  return res;
+	return res;
 }
 
 /* Scenario for the end of a context:
@@ -193,39 +240,44 @@ xbt_context_t xbt_context_new(const char *name,xbt_main_func_t code,
  */
 
 /* Argument must be stopped first -- runs in maestro 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);
+static void 
+xbt_context_free(xbt_context_t context) 
+{
+	int i;
 
-#ifdef CONTEXT_THREADS
-  DEBUG1("\t joining %p", (void *) context->thread);
+	if (!context)
+		return;
 
-  xbt_os_thread_join(context->thread, NULL);
+	DEBUG1("Freeing %p", context);
+	free(context->name);
 
-  xbt_os_mutex_destroy(context->mutex);
-  xbt_os_cond_destroy(context->cond);
+	DEBUG0("Freeing arguments");
 
-  context->thread = NULL;
-  context->mutex = NULL;
-  context->cond = NULL;
-#else
-  if (context->exception)
-    free(context->exception);
-#endif
-   
-  free(context);
-  return;
+	for (i = 0; i < context->argc; i++)
+		if (context->argv[i])
+			free(context->argv[i]);
+	
+	if (context->argv)
+		free(context->argv);
+
+	#ifdef CONTEXT_THREADS
+	  DEBUG1("\t joining %p", (void *) context->thread);
+
+	  xbt_os_thread_join(context->thread, NULL);
+
+	  xbt_os_mutex_destroy(context->mutex);
+	  xbt_os_cond_destroy(context->cond);
+
+	  context->thread = NULL;
+	  context->mutex = NULL;
+	  context->cond = NULL;
+	#else
+	  if (context->exception)
+	  free(context->exception);
+	#endif
+
+	free(context);
+	return;
 }
 
 /************************/
@@ -234,44 +286,38 @@ static void xbt_context_free(xbt_context_t context) {
 static void xbt_context_stop(int retvalue);
 static void __xbt_context_yield(xbt_context_t context);
 
-static void *__context_wrapper(void *c)
+static void *
+__context_wrapper(void *c)
 {
-  xbt_context_t context = current_context;
+	xbt_context_t context = current_context;
 
-#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);
-
-  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);
+	#ifdef CONTEXT_THREADS
+	  context = (xbt_context_t) c;
+	  context->thread = xbt_os_thread_self();
 
-#endif
+	  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);
+
+	  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);
 
-  if (context->startup_func)
-    context->startup_func(context->startup_arg);
+	  DEBUG3("**[ctx:%p;self:%p]** Unlocking individual %p ****",context, (void *) xbt_os_thread_self(), context->mutex);
+	  xbt_os_mutex_unlock(context->mutex);
 
-  DEBUG0("Calling the main function");
+	#endif
 
-  xbt_context_stop((context->code) (context->argc, context->argv));
-  return NULL;
+	if (context->startup_func)
+		context->startup_func(context->startup_arg);
+
+	DEBUG0("Calling the main function");
+
+	xbt_context_stop((context->code) (context->argc, context->argv));
+	return NULL;
 }
 /** 
  * \param context the context to start
@@ -279,64 +325,66 @@ static void *__context_wrapper(void *c)
  * Calling this function prepares \a context to be run. It will 
    however run effectively only when calling #xbt_context_schedule
  */
-void xbt_context_start(xbt_context_t context)
+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());
-  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);
-#else
-  makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1,
-	      context);
-#endif
-  return;
+	#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());
+	  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);
+	#else
+	  makecontext(&(context->uc), (void (*)(void)) __context_wrapper, 1, context);
+	#endif
 }
 
 /* Stops current context: calls user's cleanup function, kills os thread, and yields back to maestro */
-static void xbt_context_stop(int retvalue) {
-  DEBUG1("--------- %p is exiting ---------", current_context);
-
-  if (current_context->cleanup_func) {
-    DEBUG0("Calling cleanup function");
-    current_context->cleanup_func(current_context->cleanup_arg);
-  }
-
-  DEBUG0("Putting context in the to_destroy set");
-  xbt_swag_remove(current_context, context_living);
-  xbt_swag_insert(current_context, context_to_destroy);
-
-  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
-#else
-  __xbt_context_yield(current_context);
-#endif
-  THROW_IMPOSSIBLE;
+static void 
+xbt_context_stop(int retvalue) 
+{
+	DEBUG1("--------- %p is exiting ---------", current_context);
+
+	if (current_context->cleanup_func) 
+	{
+		DEBUG0("Calling cleanup function");
+		current_context->cleanup_func(current_context->cleanup_arg);
+	}
+
+	DEBUG0("Putting context in the to_destroy set");
+	xbt_swag_remove(current_context, context_living);
+	xbt_swag_insert(current_context, context_to_destroy);
+
+	DEBUG0("Yielding");
+
+	#ifdef CONTEXT_THREADS
+	  /* a java thread has called this function
+			 * - update the current context
+			 * - signal the condition of the main thread
+			 * - wait on its condition
+			 * - restore thr current contex
+			 */
+
+			xbt_os_mutex_lock(master_mutex);
+			xbt_os_cond_signal(master_cond);
+			xbt_os_mutex_unlock(master_mutex);
+			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!");
 }
 
 
@@ -346,92 +394,130 @@ static void xbt_context_stop(int retvalue) {
  * Should be called some time to time to free the memory allocated for contexts
  * that have finished executing their main functions.
  */
-void xbt_context_empty_trash(void)
+void 
+xbt_context_empty_trash(void)
 {
-  xbt_context_t context = NULL;
-  DEBUG1("Emptying trashbin (%d contexts to free)",
-	 xbt_swag_size(context_to_destroy));
-  while ((context = xbt_swag_extract(context_to_destroy)))
-    xbt_context_free(context);
+	xbt_context_t context = NULL;
+	DEBUG1("Emptying trashbin (%d contexts to free)",xbt_swag_size(context_to_destroy));
+	
+	while ((context = xbt_swag_extract(context_to_destroy)))
+		xbt_context_free(context);
 }
 
 /*********************/
 /* context switching */
 /*********************/
 
-static void __xbt_context_yield(xbt_context_t context)
+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");
-
-  if (current_context == context) {
-    DEBUG1("--------- current_context (%p) is yielding back to maestro ---------",
-	   context);
-  } else {
-    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 */
-  VOIRP(current_context);
-  VOIRP(current_context->save);
-
-  VOIRP(context);
-  VOIRP(context->save);
-
-  int return_value = 0;
-
-  if (context->save == NULL) {
-    DEBUG1("[%p] **** Yielding to somebody else ****", current_context);
-    DEBUG2("Saving current_context value (%p) to context(%p)->save",
-	     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);
-    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->save;
-    DEBUG1("Setting context(%p)->save to NULL", context);
-    context->save = NULL;
-    DEBUG2("Current position memorized (%p). Jumping to context (%p)",
-	   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;
+	#ifdef CONTEXT_THREADS
+	  xbt_context_t self;
+	#endif  
+	
+	  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);
+	} 
+	else 
+	{
+		DEBUG2("--------- current_context (%p) is yielding to context(%p) ---------",current_context, context);
+	}
+
+	#ifdef CONTEXT_THREADS
+		
+	  self = current_context;
+	
+	  if(is_main_thread())
+	  {
+			/* the main thread has called this function
+			 * - update the current context
+			 * - signal the condition of the process to run
+			 * - wait on its condition
+			 * - restore thr current contex
+			 */
+
+			xbt_os_mutex_lock(master_mutex);
+			xbt_os_mutex_lock(context->mutex);
+			
+			/* update the current context */
+			current_context = context;
+			xbt_os_cond_signal(context->cond);
+			xbt_os_mutex_unlock(context->mutex);
+			
+			xbt_os_cond_wait(master_cond, master_mutex);
+			xbt_os_mutex_unlock(master_mutex);
+			/* retore the current context */
+			current_context = self;
+			
+		}
+		else
+		{
+			/* a java thread has called this function
+			 * - update the current context
+			 * - signal the condition of the main thread
+			 * - wait on its condition
+			 * - restore thr current contex
+			 */
+
+			xbt_os_mutex_lock(master_mutex);
+			xbt_os_mutex_lock(context->mutex);
+			/* update the current context */
+			current_context = context;
+			xbt_os_cond_signal(master_cond);
+			xbt_os_mutex_unlock(master_mutex);
+			xbt_os_cond_wait(context->cond, context->mutex);
+			xbt_os_mutex_unlock(context->mutex);
+			/* retore the current context */
+			current_context = self;
+		}
+
+	#else				/* use SUSv2 contexts */
+	  VOIRP(current_context);
+	  VOIRP(current_context->save);
+
+	  VOIRP(context);
+	  VOIRP(context->save);
+
+	  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);
+	  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);
+	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->save;
+	DEBUG1("Setting context(%p)->save to NULL", context);
+	context->save = NULL;
+	DEBUG2("Current position memorized (%p). Jumping to context (%p)",
+	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;
 }
 
 
@@ -446,7 +532,8 @@ xbt_assert0(current_context, "You have to call context_init() first.");
  * Only the processes can call this function, giving back the control
  * to the maestro
  */
-void xbt_context_yield(void)
+void 
+xbt_context_yield(void)
 {
   __xbt_context_yield(current_context);
 }
@@ -460,11 +547,11 @@ void xbt_context_yield(void)
  * 
  * Only the maestro can call this function to run a given process.
  */
-void xbt_context_schedule(xbt_context_t context)
+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!");
+  xbt_assert0((current_context == init_context),"You are not supposed to run this function here!");
   __xbt_context_yield(context);
 }
 
@@ -474,11 +561,13 @@ void xbt_context_schedule(xbt_context_t context)
  *
  * This function simply kills \a context... scarry isn't it ?
  */
-void xbt_context_kill(xbt_context_t context)
+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);
@@ -489,6 +578,10 @@ void xbt_context_kill(xbt_context_t context)
 /* 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;}