src/xbt/context.c

   1 /*      $Id$     */
   2
   3 /* a fast and simple context switching library                              */
   4
   5 /* Copyright (c) 2004 Arnaud Legrand.                                       */
   6 /* Copyright (c) 2004, 2005 Martin Quinson.                                 */
   7 /* All rights reserved.                                                     */
   8
   9 /* This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the license (GNU LGPL) which comes with this package. */
  11
  12 #include "portable.h"
  13 #include "context_private.h"
  14 #include "xbt/error.h"
  15 #include "xbt/dynar.h"
  16 #include "gras_config.h"
  17
  18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(context, xbt, "Context");
  19
  20 #define VOIRP(expr) DEBUG1("  {" #expr " = %p }", expr)
  21
  22 static xbt_context_t current_context = NULL;
  23 static xbt_context_t init_context = NULL;
  24 static xbt_swag_t context_to_destroy = NULL;
  25 static xbt_swag_t context_living = NULL;
  26
  27 #ifndef USE_PTHREADS /* USE_PTHREADS and USE_CONTEXT are exclusive */
  28 # ifndef HAVE_UCONTEXT_H
  29 /* don't want to play with conditional compilation in automake tonight, sorry.
  30    include directly the c file from here when needed. */
  31 #  include "context_win32.c"
  32 # endif
  33 #endif
  34
  35 static void __xbt_context_yield(xbt_context_t context)
  36 {
  37   int return_value = 0;
  38
  39   xbt_assert0(current_context,"You have to call context_init() first.");
  40
  41   DEBUG2("--------- current_context (%p) is yielding to context(%p) ---------",
  42          current_context,context);
  43
  44 #ifdef USE_PTHREADS
  45   if (context) {
  46     xbt_context_t self = current_context;
  47     pthread_mutex_lock(&(context->mutex));
  48     current_context = context;
  49     pthread_cond_signal(&(context->cond));
  50     pthread_cond_wait(&(context->cond), &(context->mutex));
  51     pthread_mutex_unlock(&(context->mutex));
  52     current_context = self;
  53   }
  54 #else
  55   if(current_context)
  56     VOIRP(current_context->save);
  57
  58   VOIRP(context);
  59   if(context) VOIRP(context->save);
  60   if (context) {
  61     if(context->save==NULL) {
  62       DEBUG0("**** Yielding to somebody else ****");
  63       DEBUG2("Saving current_context value (%p) to context(%p)->save",current_context,context);
  64       context->save = current_context ;
  65       DEBUG1("current_context becomes  context(%p) ",context);
  66       current_context = context ;
  67       DEBUG1("Current position memorized (context->save). Jumping to context (%p)",context);
  68       return_value = swapcontext (&(context->save->uc), &(context->uc));
  69       xbt_assert0((return_value==0),"Context swapping failure");
  70       DEBUG1("I am (%p). Coming back\n",context);
  71     } else {
  72       xbt_context_t old_context = context->save ;
  73       DEBUG0("**** Back ! ****");
  74       DEBUG2("Setting current_context (%p) to context(%p)->save",current_context,context);
  75       current_context = context->save ;
  76       DEBUG1("Setting context(%p)->save to NULL",context);
  77       context->save = NULL ;
  78       DEBUG2("Current position memorized (%p). Jumping to context (%p)",context,old_context);
  79       return_value = swapcontext (&(context->uc), &(old_context->uc));
  80       xbt_assert0((return_value==0),"Context swapping failure");
  81       DEBUG1("I am (%p). Coming back\n",context);
  82     }
  83   }
  84 #endif
  85   return;
  86 }
  87
  88 static void xbt_context_destroy(xbt_context_t context)
  89 {
  90 #ifdef USE_PTHREADS
  91   xbt_free(context->thread);
  92   pthread_mutex_destroy(&(context->mutex));
  93   pthread_cond_destroy(&(context->cond));
  94 #endif
  95   free(context);
  96   return;
  97 }
  98
  99 static void *__context_wrapper(void *c)
 100 {
 101   xbt_context_t context = c;
 102   int i;
 103
 104 #ifdef USE_PTHREADS
 105   pthread_cond_wait(&(context->cond), &(context->mutex));
 106   pthread_mutex_unlock(&(context->mutex));
 107 #endif
 108
 109   if(context->startup_func)
 110     context->startup_func(context->startup_arg);
 111
 112    DEBUG0("Calling the main function");
 113   (context->code) (context->argc,context->argv);
 114
 115   for(i=0;i<context->argc; i++)
 116     if(context->argv[i]) free(context->argv[i]);
 117   if(context->argv) free(context->argv);
 118
 119   if(context->cleanup_func)
 120     context->cleanup_func(context->cleanup_arg);
 121
 122   xbt_swag_remove(context, context_living);
 123   xbt_swag_insert(context, context_to_destroy);
 124
 125   __xbt_context_yield(context);
 126   xbt_assert0(0,"You're cannot be here!");
 127   return NULL;
 128 }
 129
 130 /** \name Functions
 131  *  \ingroup XBT_context
 132  */
 133 /*@{*/
 134 /** Context module initialization
 135  *
 136  * \warning It has to be called before using any other function of this module.
 137  */
 138 void xbt_context_init(void)
 139 {
 140   if(!current_context) {
 141     current_context = init_context = xbt_new0(s_xbt_context_t,1);
 142     context_to_destroy = xbt_swag_new(xbt_swag_offset(*current_context,hookup));
 143     context_living = xbt_swag_new(xbt_swag_offset(*current_context,hookup));
 144     xbt_swag_insert(init_context, context_living);
 145   }
 146 }
 147
 148 /** Garbage collection
 149  *
 150  * Should be called some time to time to free the memory allocated for contexts
 151  * that have finished executing their main functions.
 152  */
 153 void xbt_context_empty_trash(void)
 154 {
 155   xbt_context_t context=NULL;
 156
 157   while((context=xbt_swag_extract(context_to_destroy)))
 158     xbt_context_destroy(context);
 159 }
 160
 161 /**
 162  * \param context the context to start
 163  *
 164  * Calling this function prepares \a context to be run. It will
 165    however run effectively only when calling #xbt_context_schedule
 166  */
 167 void xbt_context_start(xbt_context_t context)
 168 {
 169 #ifdef USE_PTHREADS
 170   pthread_mutex_lock(&(context->mutex));
 171
 172   /* Launch the thread */
 173   xbt_assert0(!pthread_create(context->thread, NULL, __context_wrapper, context),
 174               "Unable to create a thread.");
 175 #else
 176   makecontext (&(context->uc), (void (*) (void)) __context_wrapper,
 177                1, context);
 178 #endif
 179   return;
 180 }
 181
 182 /**
 183  * \param code a main function
 184  * \param startup_func a function to call when running the context for
 185  *      the first time and just before the main function \a code
 186  * \param startup_arg the argument passed to the previous function (\a startup_func)
 187  * \param cleanup_func a function to call when running the context, just after
 188         the termination of the main function \a code
 189  * \param cleanup_arg the argument passed to the previous function (\a cleanup_func)
 190  * \param argc first argument of function \a code
 191  * \param argv seconde argument of function \a code
 192  */
 193 xbt_context_t xbt_context_new(xbt_context_function_t code,
 194                               void_f_pvoid_t startup_func, void *startup_arg,
 195                               void_f_pvoid_t cleanup_func, void *cleanup_arg,
 196                               int argc, char *argv[])
 197 {
 198   xbt_context_t res = NULL;
 199
 200   res = xbt_new0(s_xbt_context_t,1);
 201
 202   res->code = code;
 203 #ifdef USE_PTHREADS
 204   res->thread = xbt_new0(pthread_t,1);
 205   xbt_assert0(!pthread_mutex_init(&(res->mutex), NULL), "Mutex initialization error");
 206   xbt_assert0(!pthread_cond_init(&(res->cond), NULL), "Condition initialization error");
 207 #else
 208   /* FIXME: strerror is not thread safe */
 209   xbt_assert2(getcontext(&(res->uc))==0,"Error in context saving: %d (%s)", errno, strerror(errno));
 210   res->uc.uc_link = NULL;
 211   /*   res->uc.uc_link = &(current_context->uc); */
 212   /* WARNING : when this context is over, the current_context (i.e. the
 213      father), is awaken... Theorically, the wrapper should prevent using
 214      this feature. */
 215   res->uc.uc_stack.ss_sp = res->stack;
 216   res->uc.uc_stack.ss_size = STACK_SIZE;
 217 #endif
 218   res->argc = argc;
 219   res->argv = argv;
 220   res->startup_func = startup_func;
 221   res->startup_arg = startup_arg;
 222   res->cleanup_func = cleanup_func;
 223   res->cleanup_arg = cleanup_arg;
 224
 225   xbt_swag_insert(res, context_living);
 226
 227   return res;
 228 }
 229
 230 /**
 231  * Calling this function makes the current context yield. The context
 232  * that scheduled it returns from xbt_context_schedule as if nothing
 233  * had happened.
 234  */
 235 void xbt_context_yield(void)
 236 {
 237   __xbt_context_yield(current_context);
 238 }
 239
 240 /**
 241  * \param context the winner
 242  *
 243  * Calling this function blocks the current context and schedule \a context.
 244  * When \a context will call xbt_context_yield, it will return
 245  * to this function as if nothing had happened.
 246  */
 247 void xbt_context_schedule(xbt_context_t context)
 248 {
 249   xbt_assert0((current_context==init_context),
 250               "You are not supposed to run this function here!");
 251   __xbt_context_yield(context);
 252 }
 253
 254 /**
 255  * This function kill all existing context and free all the memory
 256  * that has been allocated in this module.
 257  */
 258 void xbt_context_exit(void) {
 259   xbt_context_t context=NULL;
 260
 261   xbt_context_empty_trash();
 262   xbt_swag_free(context_to_destroy);
 263
 264   while((context=xbt_swag_extract(context_living)))
 265     xbt_context_free(context);
 266
 267   xbt_swag_free(context_living);
 268
 269   init_context = current_context = NULL ;
 270 }
 271
 272 /**
 273  * \param context poor victim
 274  *
 275  * This function simply kills \a context... scarry isn't it ?
 276  */
 277 void xbt_context_free(xbt_context_t context)
 278 {
 279   int i ;
 280
 281   xbt_swag_remove(context, context_living);
 282   for(i=0;i<context->argc; i++)
 283     if(context->argv[i]) free(context->argv[i]);
 284   if(context->argv) free(context->argv);
 285
 286   if(context->cleanup_func)
 287     context->cleanup_func(context->cleanup_arg);
 288   xbt_context_destroy(context);
 289
 290   return;
 291 }
 292
 293 /*@}*/