X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8f8883a78d93afcdca733415372f122e00a7fcdf..3ae39088350ad665caa35db1731009d9e3f1bda2:/src/xbt/context.c

diff --git a/src/xbt/context.c b/src/xbt/context.c
index a88d8efafc..aa49e3bc99 100644
--- a/src/xbt/context.c
+++ b/src/xbt/context.c
@@ -13,9 +13,8 @@
 #include "context_private.h"
 #include "xbt/log.h"
 #include "xbt/dynar.h"
-#include "gras_config.h"
 
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(context, xbt, "Context");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ctx, xbt, "Context");
 
 #define VOIRP(expr) DEBUG1("  {" #expr " = %p }", expr)
 
@@ -24,7 +23,7 @@ static xbt_context_t init_context = NULL;
 static xbt_swag_t context_to_destroy = NULL;
 static xbt_swag_t context_living = NULL;
 
-#ifndef USE_PTHREADS /* USE_PTHREADS and USE_CONTEXT are exclusive */
+#if (!defined(USE_PTHREADS) && !defined(USE_WIN_THREADS)) /* USE_PTHREADS and USE_CONTEXT are exclusive */
 # ifndef USE_UCONTEXT
 /* don't want to play with conditional compilation in automake tonight, sorry.
    include directly the c file from here when needed. */
@@ -35,123 +34,229 @@ static xbt_swag_t context_living = NULL;
 
 static void __xbt_context_yield(xbt_context_t context)
 {
-  xbt_assert0(current_context,"You have to call context_init() first.");
-  
-  DEBUG2("--------- current_context (%p) is yielding to context(%p) ---------",
-	 current_context,context);
-
-#ifdef USE_PTHREADS
-  if (context) {
-    xbt_context_t self = current_context;
-    DEBUG0("**** Locking ****");
-    pthread_mutex_lock(&(context->mutex));
-    DEBUG0("**** Updating current_context ****");
-    current_context = context;
-    DEBUG0("**** Releasing the prisonner ****");
-    pthread_cond_signal(&(context->cond));
-    DEBUG0("**** Going to jail ****");
-    pthread_cond_wait(&(context->cond), &(context->mutex));
-    DEBUG0("**** Unlocking ****");
-    pthread_mutex_unlock(&(context->mutex));
-    DEBUG0("**** Updating current_context ****");
-    current_context = self;
-  }
-#else
-  if(current_context)
-    VOIRP(current_context->save);
-
-  VOIRP(context);
-  if(context) VOIRP(context->save);
-  if (context) {
-
-    int return_value = 0;
-
-    if(context->save==NULL) {
-      DEBUG0("**** Yielding to somebody else ****");
-      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 ;
-      DEBUG0("**** Back ! ****");
-      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
-  return;
+	xbt_assert0(current_context,"You have to call context_init() first.");
+	
+	DEBUG2("--------- current_context (%p) is yielding to context(%p) ---------",current_context,context);
+	
+	#ifdef USE_PTHREADS
+	if (context){
+		xbt_context_t self = current_context;
+		DEBUG0("**** Locking ****");
+		pthread_mutex_lock(&(context->mutex));
+		DEBUG0("**** Updating current_context ****");
+		current_context = context;
+		DEBUG0("**** Releasing the prisonner ****");
+		pthread_cond_signal(&(context->cond));
+		DEBUG0("**** Going to jail ****");
+		pthread_cond_wait(&(context->cond), &(context->mutex));
+		DEBUG0("**** Unlocking ****");
+		pthread_mutex_unlock(&(context->mutex));
+		DEBUG0("**** Updating current_context ****");
+		current_context = self;
+	}
+	#elif defined(USE_WIN_THREADS)
+	if (context){
+		xbt_context_t self = current_context;
+		DEBUG0("**** Locking ****");
+        win_thread_mutex_lock(&(context->mutex));
+        DEBUG0("**** Updating current_context ****");
+        current_context = context;
+        DEBUG0("**** Releasing the prisonner ****");
+        win_thread_cond_signal(&(context->cond));
+        DEBUG0("**** Going to jail ****");
+        win_thread_cond_wait(&(context->cond), &(context->mutex));
+        DEBUG0("**** Unlocking ****");
+        win_thread_mutex_unlock(&(context->mutex));
+        DEBUG0("**** Updating current_context ****");
+        current_context = self;
+
+	}
+	#else
+	if(current_context)
+		VOIRP(current_context->save);
+	
+	VOIRP(context);
+	
+	if(context) 
+		VOIRP(context->save);
+	
+	if (context){
+	
+		int return_value = 0;
+		
+		if(context->save==NULL){
+		
+			DEBUG0("**** Yielding to somebody else ****");
+			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 ;
+			DEBUG0("**** Back ! ****");
+			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
+	return;
 }
 
 static void xbt_context_destroy(xbt_context_t context)
 {
-#ifdef USE_PTHREADS
-  xbt_free(context->thread);
-  pthread_mutex_destroy(&(context->mutex));
-  pthread_cond_destroy(&(context->cond));
-#endif
-  if(context->exception) free(context->exception);
-  free(context);
-  return;
+	#ifdef USE_PTHREADS
+	xbt_free(context->thread);
+	pthread_mutex_destroy(&(context->mutex));
+	pthread_cond_destroy(&(context->cond));
+	#elif defined(USE_WIN_THREADS)
+	/*xbt_free(context->thread);*/
+
+    if(context->mutex)
+        win_thread_mutex_destroy(&(context->mutex));
+
+
+    if(context->cond)
+	    win_thread_cond_destroy(&(context->cond));
+
+
+	#endif
+	
+	if(context->exception) 
+		free(context->exception);
+	
+	#ifdef USE_WIN_CONTEXT    	
+	if(context->uc.uc_stack.ss_sp)
+		free (context->uc.uc_stack.ss_sp);
+	#endif
+	
+	free(context);
+	return;
 }
-
-static void *__context_wrapper(void *c)
+	
+static void __context_exit(xbt_context_t context ,int value)
 {
-  xbt_context_t context = c;
-  int i;
-
-#ifdef USE_PTHREADS
-  DEBUG0("**** Lock ****");
-  pthread_mutex_lock(&(context->mutex));
-  DEBUG0("**** Releasing the prisonner ****");
-  pthread_cond_signal(&(context->cond));
-  DEBUG0("**** Going to Jail ****");
-  pthread_cond_wait(&(context->cond), &(context->mutex));
-  DEBUG0("**** Unlocking ****");
-  pthread_mutex_unlock(&(context->mutex));
-#endif
-
-  if(context->startup_func)
-    context->startup_func(context->startup_arg);
-
-   DEBUG0("Calling the main function");
-  (context->code) (context->argc,context->argv);
-
-  for(i=0;i<context->argc; i++) 
-    if(context->argv[i]) free(context->argv[i]);
-  if(context->argv) free(context->argv);
-
-  if(context->cleanup_func)
-    context->cleanup_func(context->cleanup_arg);
-
-  xbt_swag_remove(context, context_living);
-  xbt_swag_insert(context, context_to_destroy);
+	int i;
+	DEBUG0("Freeing arguments");
+	for(i=0;i<context->argc; i++) 
+		if(context->argv[i]) 
+			free(context->argv[i]);
+	
+	if(context->argv) 
+		free(context->argv);
+	
+	if(context->cleanup_func){
+		DEBUG0("Calling cleanup function");
+		context->cleanup_func(context->cleanup_arg);
+	}
+	
+	DEBUG0("Putting context in the to_destroy set");
+	xbt_swag_remove(context, context_living);
+	xbt_swag_insert(context, context_to_destroy);
+	DEBUG0("Context put in the to_destroy set");
+	DEBUG0("Yielding");
+	
+	#ifdef USE_PTHREADS
+	DEBUG0("**** Locking ****");
+	pthread_mutex_lock(&(context->mutex));
+	DEBUG0("**** Updating current_context ****");
+	current_context = context;
+	DEBUG0("**** Releasing the prisonner ****");
+	pthread_cond_signal(&(context->cond));  
+	DEBUG0("**** Unlocking ****");
+	pthread_mutex_unlock(&(context->mutex));
+	DEBUG0("**** Exiting ****");
+	pthread_exit(0);
+	#elif defined(USE_WIN_THREADS)
+	DEBUG0("**** Locking ****");
+	win_thread_mutex_lock(&(context->mutex));
+	DEBUG0("**** Updating current_context ****");
+	current_context = context;
+	DEBUG0("**** Releasing the prisonner ****");
+	win_thread_cond_signal(&(context->cond));  
+	DEBUG0("**** Unlocking ****");
+	win_thread_mutex_unlock(&(context->mutex));
+	DEBUG0("**** Exiting ****");
+	win_thread_exit(context->thread,0);
+	#else
+	__xbt_context_yield(context);
+	#endif
+	xbt_assert0(0,"You can't be here!");
+}
 
-  __xbt_context_yield(context);
-  xbt_assert0(0,"You're cannot be here!");
-  return NULL;
+#ifdef USE_WIN_THREADS 
+static DWORD WINAPI	/* special thread proc signature */
+#else
+static void *
+#endif 
+__context_wrapper(void* c)
+{
+	xbt_context_t context = (xbt_context_t)c;
+	
+	#ifdef USE_PTHREADS
+	DEBUG2("**[%p:%p]** Lock ****",context,(void*)pthread_self());
+	pthread_mutex_lock(&(context->mutex));
+	
+	DEBUG2("**[%p:%p]** Releasing the prisonner ****",context,(void*)pthread_self());
+	pthread_cond_signal(&(context->cond));
+	
+	DEBUG2("**[%p:%p]** Going to Jail ****",context,(void*)pthread_self());
+	pthread_cond_wait(&(context->cond), &(context->mutex));
+	
+	DEBUG2("**[%p:%p]** Unlocking ****",context,(void*)pthread_self());
+	pthread_mutex_unlock(&(context->mutex));
+	
+	#elif defined(USE_WIN_THREADS)
+	DEBUG2("**[%p:%p]** Lock ****",context,(void*)win_thread_self());
+	win_thread_mutex_lock(&(context->mutex));
+
+	DEBUG2("**[%p:%p]** Releasing the prisonner ****",context,(void*)win_thread_self());
+	win_thread_cond_signal(&(context->cond));
+
+	DEBUG2("**[%p:%p]** Going to Jail ****",context,(void*)win_thread_self());
+	win_thread_cond_wait(&(context->cond), &(context->mutex));
+
+	DEBUG2("**[%p:%p]** Unlocking ****",context,(void*)win_thread_self());
+	win_thread_mutex_unlock(&(context->mutex));
+
+	#endif
+	
+	if(context->startup_func)
+		context->startup_func(context->startup_arg);
+	
+	DEBUG0("Calling the main function");
+	
+	__context_exit(context, (context->code) (context->argc,context->argv));
+	return NULL;
 }
 
 /* callback: context fetching */
 static ex_ctx_t *__context_ex_ctx(void)
 {
-  return current_context->exception;
+ 	return current_context->exception;
 }
 
 /* callback: termination */
-static void __context_ex_terminate(xbt_ex_t *e)
-{
-  exit(e->value);
+static void __context_ex_terminate(xbt_ex_t *e) {
+  xbt_ex_display(e);
+
+  abort();
+   /* FIXME: there should be a configuration variable to choose this
+  if(current_context!=init_context) 
+    __context_exit(current_context, e->value);
+  else
+    abort();
+    */
 }
 
 /** \name Functions 
@@ -164,16 +269,17 @@ static void __context_ex_terminate(xbt_ex_t *e)
  */
 void xbt_context_init(void)
 {
-  if(!current_context) {
-    current_context = init_context = xbt_new0(s_xbt_context_t,1);
-    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;
-    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);
-  }
+	if(!current_context){
+		current_context = init_context = xbt_new0(s_xbt_context_t,1);
+
+		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;
+		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);
+	}
 }
 
 /** Garbage collection
@@ -183,10 +289,10 @@ void xbt_context_init(void)
  */
 void xbt_context_empty_trash(void)
 {
-  xbt_context_t context=NULL;
-
-  while((context=xbt_swag_extract(context_to_destroy)))
-    xbt_context_destroy(context);
+	xbt_context_t context=NULL;
+	
+	while((context=xbt_swag_extract(context_to_destroy)))
+		xbt_context_destroy(context);
 }
 
 /** 
@@ -197,22 +303,32 @@ void xbt_context_empty_trash(void)
  */
 void xbt_context_start(xbt_context_t context) 
 {
-#ifdef USE_PTHREADS
-  /* Launch the thread */
-  DEBUG0("**** Locking ****");
-  pthread_mutex_lock(&(context->mutex));
-  DEBUG0("**** Pthread create ****");
-  xbt_assert0(!pthread_create(context->thread, NULL, __context_wrapper, context),
-	      "Unable to create a thread.");
-  DEBUG0("**** Going to jail ****");
-  pthread_cond_wait(&(context->cond), &(context->mutex));
-  DEBUG0("**** Unlocking ****");
-  pthread_mutex_unlock(&(context->mutex));  
-#else
-  makecontext (&(context->uc), (void (*) (void)) __context_wrapper,
-	       1, context);
-#endif
-  return;
+	#ifdef USE_PTHREADS
+	/* Launch the thread */
+	DEBUG1("**[%p]** Locking ****",context);
+	pthread_mutex_lock(&(context->mutex));
+	DEBUG1("**[%p]** Pthread create ****",context);
+	xbt_assert0(!pthread_create(context->thread, NULL, __context_wrapper, context),"Unable to create a thread.");
+	DEBUG2("**[%p]** Pthread created : %p ****",context,(void*)(*(context->thread)));
+	DEBUG1("**[%p]** Going to jail ****",context);
+	pthread_cond_wait(&(context->cond), &(context->mutex));
+	DEBUG1("**[%p]** Unlocking ****",context);
+	pthread_mutex_unlock(&(context->mutex)); 
+	#elif defined(USE_WIN_THREADS) 
+	/* Launch the thread */
+	DEBUG1("**[%p]** Locking ****",context);
+	win_thread_mutex_lock(&(context->mutex));
+	DEBUG1("**[%p]** Windows thread create ****",context);
+	xbt_assert0(!win_thread_create(&(context->thread), __context_wrapper, context),"Unable to create a thread.");
+	DEBUG2("**[%p]** Windows created : %p ****",context,(void*)(context->thread));
+	DEBUG1("**[%p]** Going to jail ****",context);
+	win_thread_cond_wait(&(context->cond), &(context->mutex));
+	DEBUG1("**[%p]** Unlocking ****",context);
+	win_thread_mutex_unlock(&(context->mutex)); 
+	#else
+	makecontext (&(context->uc), (void (*) (void)) __context_wrapper,1, context);
+	#endif
+	return;
 }
 
 /** 
@@ -231,40 +347,48 @@ xbt_context_t xbt_context_new(xbt_context_function_t code,
 			      void_f_pvoid_t cleanup_func, void *cleanup_arg,
 			      int argc, char *argv[])
 {
-  xbt_context_t res = NULL;
-
-  res = xbt_new0(s_xbt_context_t,1);
-
-  res->code = code;
-#ifdef USE_PTHREADS
-  res->thread = xbt_new0(pthread_t,1);
-  xbt_assert0(!pthread_mutex_init(&(res->mutex), NULL), "Mutex initialization error");
-  xbt_assert0(!pthread_cond_init(&(res->cond), NULL), "Condition initialization error");
-#else 
-  /* FIXME: strerror is not thread safe */
-  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. */
-# ifndef USE_WIN_CONTEXT    
-  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);
-# endif /* USE_WIN_CONTEXT */
-#endif /* USE_PTHREADS or not */
-  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;
-  res->exception = xbt_new(ex_ctx_t,1);
-  XBT_CTX_INITIALIZE(res->exception);
-
-  xbt_swag_insert(res, context_living);
-
-  return res;
+	xbt_context_t res = NULL;
+	
+	res = xbt_new0(s_xbt_context_t,1);
+	
+	res->code = code;
+	#ifdef USE_PTHREADS
+	res->thread = xbt_new0(pthread_t,1);
+	xbt_assert0(!pthread_mutex_init(&(res->mutex), NULL), "Mutex initialization error");
+	xbt_assert0(!pthread_cond_init(&(res->cond), NULL), "Condition initialization error");
+	#elif defined(USE_WIN_THREADS)
+	/*res->thread = xbt_new0(pthread_t,1);*/
+	xbt_assert0(!win_thread_mutex_init(&(res->mutex)), "Mutex initialization error");
+	xbt_assert0(!win_thread_cond_init(&(res->cond)), "Condition initialization error");
+	#else 
+	/* FIXME: strerror is not thread safe */
+	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. */
+	# ifdef USE_WIN_CONTEXT    
+	res->uc.uc_stack.ss_sp = xbt_malloc(STACK_SIZE);
+	res->uc.uc_stack.ss_size = STACK_SIZE ;
+	#else
+	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);
+	# endif /* USE_WIN_CONTEXT */
+	#endif /* USE_PTHREADS or not */
+	
+	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;
+	res->exception = xbt_new(ex_ctx_t,1);
+	XBT_CTX_INITIALIZE(res->exception);
+	
+	xbt_swag_insert(res, context_living);
+	
+	return res;
 }
 
 /** 
@@ -274,7 +398,7 @@ xbt_context_t xbt_context_new(xbt_context_function_t code,
  */
 void xbt_context_yield(void)
 {
-  __xbt_context_yield(current_context);
+	__xbt_context_yield(current_context);
 }
 
 /** 
@@ -286,9 +410,9 @@ void xbt_context_yield(void)
  */
 void xbt_context_schedule(xbt_context_t context)
 {
-  xbt_assert0((current_context==init_context),
-	      "You are not supposed to run this function here!");
-  __xbt_context_yield(context);
+	DEBUG1("Scheduling %p",context);
+	xbt_assert0((current_context==init_context),"You are not supposed to run this function here!");
+	__xbt_context_yield(context);
 }
 
 /** 
@@ -296,17 +420,19 @@ void xbt_context_schedule(xbt_context_t context)
  * that has been allocated in this module.
  */
 void xbt_context_exit(void) {
-  xbt_context_t context=NULL;
-
-  xbt_context_empty_trash();
-  xbt_swag_free(context_to_destroy);
-
-  while((context=xbt_swag_extract(context_living)))
-    xbt_context_free(context);
-
-  xbt_swag_free(context_living);
-
-  init_context = current_context = NULL ;
+	xbt_context_t context=NULL;
+
+    
+
+	xbt_context_empty_trash();
+	xbt_swag_free(context_to_destroy);
+	
+	while((context=xbt_swag_extract(context_living)))
+		xbt_context_free(context);
+	
+	xbt_swag_free(context_living);
+	
+	init_context = current_context = NULL ;
 }
 
 /** 
@@ -316,17 +442,22 @@ void xbt_context_exit(void) {
  */
 void xbt_context_free(xbt_context_t context)
 {
-  int i ;
-
-  xbt_swag_remove(context, context_living);  
-  for(i=0;i<context->argc; i++) 
-    if(context->argv[i]) free(context->argv[i]);
-  if(context->argv) free(context->argv);
-  
-  if(context->cleanup_func)
-    context->cleanup_func(context->cleanup_arg);
-  xbt_context_destroy(context);
-
-  return;
+	int i ;
+	
+	xbt_swag_remove(context, context_living);  
+	
+	for(i=0;i<context->argc; i++) 
+		if(context->argv[i]) 
+			free(context->argv[i]);
+	
+	if(context->argv) 
+		free(context->argv);
+	
+	if(context->cleanup_func)
+		context->cleanup_func(context->cleanup_arg);
+	
+	xbt_context_destroy(context);
+	
+	return;
 }
 /* @} */