X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5eecba1cd4850c7820f9cfa3c1af484f674b1e8b..6e5cfd7ff86900354c20502af95ee5f751492753:/src/simix/smx_context_sysv.c

diff --git a/src/simix/smx_context_sysv.c b/src/simix/smx_context_sysv.c
index f7f59fd748..a6fef0dcc6 100644
--- a/src/simix/smx_context_sysv.c
+++ b/src/simix/smx_context_sysv.c
@@ -19,7 +19,6 @@
 
 #ifdef _XBT_WIN32
 #include "win32_ucontext.h"
-#include "win32_ucontext.c"
 #else
 #include "ucontext.h"
 #endif
@@ -27,8 +26,13 @@
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
 
 #ifdef CONTEXT_THREADS
-static xbt_parmap_t parmap;
+static xbt_parmap_t smx_ctx_sysv_parmap;
+static ucontext_t* smx_ctx_sysv_local_maestro_uc;    /* space to save maestro's stack in each thread */
 #endif
+static unsigned long smx_ctx_sysv_process_index = 0; /* index of the next process to run in the
+                                                      * list of runnable processes */
+static smx_ctx_sysv_t smx_ctx_sysv_maestro_context;
+
 
 static smx_context_t
 smx_ctx_sysv_create_context(xbt_main_func_t code, int argc, char **argv,
@@ -36,6 +40,17 @@ smx_ctx_sysv_create_context(xbt_main_func_t code, int argc, char **argv,
 
 static void smx_ctx_sysv_wrapper(int count, ...);
 
+static void smx_ctx_sysv_stop_serial(smx_context_t context);
+static void smx_ctx_sysv_suspend_serial(smx_context_t context);
+static void smx_ctx_sysv_resume_serial(smx_process_t first_process);
+static void smx_ctx_sysv_runall_serial(void);
+
+static void smx_ctx_sysv_stop_parallel(smx_context_t context);
+static void smx_ctx_sysv_suspend_parallel(smx_context_t context);
+static void smx_ctx_sysv_resume_parallel(smx_process_t first_process);
+static void smx_ctx_sysv_runall_parallel(void);
+
+
 /* This is a bit paranoid about SIZEOF_VOIDP not being a multiple of SIZEOF_INT,
  * but it doesn't harm. */
 #define CTX_ADDR_LEN (SIZEOF_VOIDP / SIZEOF_INT + !!(SIZEOF_VOIDP % SIZEOF_INT))
@@ -54,34 +69,40 @@ union u_ctx_addr {
 void SIMIX_ctx_sysv_factory_init(smx_context_factory_t *factory)
 {
   smx_ctx_base_factory_init(factory);
-  VERB0("Activating SYSV context factory");
+  XBT_VERB("Activating SYSV context factory");
 
   (*factory)->finalize = smx_ctx_sysv_factory_finalize;
   (*factory)->create_context = smx_ctx_sysv_create_context;
   /* Do not overload that method (*factory)->finalize */
   (*factory)->free = smx_ctx_sysv_free;
-  (*factory)->stop = smx_ctx_sysv_stop;
-  (*factory)->suspend = smx_ctx_sysv_suspend;
   (*factory)->name = "smx_sysv_context_factory";
 
   if (SIMIX_context_is_parallel()) {
 #ifdef CONTEXT_THREADS	/* To use parallel ucontexts a thread pool is needed */
-    parmap = xbt_parmap_new(2);
+    int nthreads = SIMIX_context_get_nthreads();
+    smx_ctx_sysv_parmap = xbt_parmap_new(nthreads);
+    smx_ctx_sysv_local_maestro_uc = xbt_new(ucontext_t, nthreads);
+    (*factory)->stop = smx_ctx_sysv_stop_parallel;
+    (*factory)->suspend = smx_ctx_sysv_suspend_parallel;
     (*factory)->runall = smx_ctx_sysv_runall_parallel;
     (*factory)->self = smx_ctx_sysv_self_parallel;
-    (*factory)->get_thread_id = smx_ctx_sysv_get_thread_id;
 #else
-    THROW0(arg_error, 0, "No thread support for parallel context execution");
+    THROWF(arg_error, 0, "No thread support for parallel context execution");
 #endif
-  }else{
-    (*factory)->runall = smx_ctx_sysv_runall;
+  } else {
+    (*factory)->stop = smx_ctx_sysv_stop_serial;
+    (*factory)->suspend = smx_ctx_sysv_suspend_serial;
+    (*factory)->runall = smx_ctx_sysv_runall_serial;
   }    
 }
 
 int smx_ctx_sysv_factory_finalize(smx_context_factory_t *factory)
 { 
-  if(parmap)
-    xbt_parmap_destroy(parmap);
+#ifdef CONTEXT_THREADS
+  if (smx_ctx_sysv_parmap)
+    xbt_parmap_destroy(smx_ctx_sysv_parmap);
+  xbt_free(smx_ctx_sysv_local_maestro_uc);
+#endif
   return smx_ctx_base_factory_finalize(factory);
 }
 
@@ -100,13 +121,11 @@ smx_ctx_sysv_create_context_sized(size_t size, xbt_main_func_t code,
                                                                  cleanup_func,
                                                                  data);
 
-  /* If the user provided a function for the process then use it
-     otherwise is the context for maestro */
+  /* if the user provided a function for the process then use it,
+     otherwise it is the context for maestro */
   if (code) {
 
-    xbt_assert2(getcontext(&(context->uc)) == 0,
-                "Error in context saving: %d (%s)", errno,
-                strerror(errno));
+    getcontext(&(context->uc));
 
     context->uc.uc_link = NULL;
 
@@ -125,12 +144,11 @@ smx_ctx_sysv_create_context_sized(size_t size, xbt_main_func_t code,
     ctx_addr.addr = context;
     makecontext(&context->uc, (void (*)())smx_ctx_sysv_wrapper,
                 CTX_ADDR_LEN, CTX_ADDR_SPLIT(ctx_addr));
-  }else{
-    maestro_context = context;
+  } else {
+    smx_ctx_sysv_maestro_context = context;
   }
 
   return (smx_context_t) context;
-
 }
 
 static smx_context_t
@@ -159,12 +177,6 @@ void smx_ctx_sysv_free(smx_context_t context)
   smx_ctx_base_free(context);
 }
 
-void smx_ctx_sysv_stop(smx_context_t context)
-{
-  smx_ctx_base_stop(context);
-  smx_ctx_sysv_suspend(context);
-}
-
 void smx_ctx_sysv_wrapper(int first, ...)
 { 
   union u_ctx_addr ctx_addr;
@@ -175,71 +187,120 @@ void smx_ctx_sysv_wrapper(int first, ...)
     va_list ap;
     int i;
     va_start(ap, first);
-    for(i = 1; i < CTX_ADDR_LEN; i++)
+    for (i = 1; i < CTX_ADDR_LEN; i++)
       ctx_addr.intv[i] = va_arg(ap, int);
     va_end(ap);
   }
   context = ctx_addr.addr;
   (context->super.code) (context->super.argc, context->super.argv);
 
-  smx_ctx_sysv_stop((smx_context_t) context);
+  simix_global->context_factory->stop((smx_context_t) context);
+}
+
+static void smx_ctx_sysv_stop_serial(smx_context_t context)
+{
+  smx_ctx_base_stop(context);
+  smx_ctx_sysv_suspend_serial(context);
 }
 
-void smx_ctx_sysv_suspend(smx_context_t context)
+static void smx_ctx_sysv_suspend_serial(smx_context_t context)
 {
-  smx_current_context = (smx_context_t)maestro_context;
-  int rv;
-  rv = swapcontext(&((smx_ctx_sysv_t) context)->uc, &((smx_ctx_sysv_t)context)->old_uc);
+  /* determine the next context */
+  smx_context_t next_context;
+  unsigned long int i = smx_ctx_sysv_process_index++;
+
+  if (i < xbt_dynar_length(simix_global->process_to_run)) {
+    /* execute the next process */
+    XBT_DEBUG("Run next process");
+    next_context = xbt_dynar_get_as(
+        simix_global->process_to_run,i, smx_process_t)->context;
+  }
+  else {
+    /* all processes were run, return to maestro */
+    XBT_DEBUG("No more process to run");
+    next_context = (smx_context_t) smx_ctx_sysv_maestro_context;
+  }
+  SIMIX_context_set_current(next_context);
+  swapcontext(&((smx_ctx_sysv_t) context)->uc,
+      &((smx_ctx_sysv_t) next_context)->uc);
+}
 
-  xbt_assert0((rv == 0), "Context swapping failure");
+static void smx_ctx_sysv_resume_serial(smx_process_t first_process)
+{
+  smx_context_t context = first_process->context;
+  SIMIX_context_set_current(context);
+  swapcontext(&smx_ctx_sysv_maestro_context->uc,
+      &((smx_ctx_sysv_t) context)->uc);
 }
 
-void smx_ctx_sysv_resume(smx_context_t context)
+static void smx_ctx_sysv_runall_serial(void)
 {
-  smx_current_context = context; 
-  int rv;
-  rv = swapcontext(&((smx_ctx_sysv_t)context)->old_uc, &((smx_ctx_sysv_t) context)->uc);
+  if (xbt_dynar_length(simix_global->process_to_run) > 0) {
+    smx_process_t first_process =
+        xbt_dynar_get_as(simix_global->process_to_run, 0, smx_process_t);
+    smx_ctx_sysv_process_index = 1;
 
-  xbt_assert0((rv == 0), "Context swapping failure");
+    /* execute the first process */
+    smx_ctx_sysv_resume_serial(first_process);
+  }
 }
 
-void smx_ctx_sysv_runall(xbt_dynar_t processes)
+static void smx_ctx_sysv_stop_parallel(smx_context_t context)
 {
-  smx_process_t process;
-  unsigned int cursor;
+  smx_ctx_base_stop(context);
+  smx_ctx_sysv_suspend_parallel(context);
+}
 
-  xbt_dynar_foreach(processes, cursor, process) {
-    DEBUG2("Schedule item %u of %lu",cursor,xbt_dynar_length(processes));
-    smx_ctx_sysv_resume(process->context);
+static void smx_ctx_sysv_suspend_parallel(smx_context_t context)
+{
+#ifdef CONTEXT_THREADS
+  /* determine the next context */
+  smx_process_t next_work = xbt_parmap_next(smx_ctx_sysv_parmap);
+  smx_context_t next_context;
+  ucontext_t* next_uc;
+
+  if (next_work != NULL) {
+    /* there is a next process to resume */
+    XBT_DEBUG("Run next process");
+    next_context = next_work->context;
+    next_uc = &((smx_ctx_sysv_t) next_context)->uc;
   }
-  xbt_dynar_reset(processes);
+  else {
+    /* all processes were run, go to the barrier */
+    XBT_DEBUG("No more processes to run");
+    next_context = (smx_context_t) smx_ctx_sysv_maestro_context;
+    unsigned long worker_id = xbt_parmap_get_worker_id(smx_ctx_sysv_parmap);
+    next_uc = &smx_ctx_sysv_local_maestro_uc[worker_id];
+  }
+
+  SIMIX_context_set_current(next_context);
+  swapcontext(&((smx_ctx_sysv_t) context)->uc, next_uc);
+#endif
 }
 
-void smx_ctx_sysv_resume_parallel(smx_process_t process)
+static void smx_ctx_sysv_resume_parallel(smx_process_t first_process)
 {
-  smx_context_t context = process->context;
-  smx_current_context = (smx_context_t)context;
-  int rv;
-  rv = swapcontext(&((smx_ctx_sysv_t)context)->old_uc, &((smx_ctx_sysv_t) context)->uc);
-  smx_current_context = (smx_context_t)maestro_context;
+#ifdef CONTEXT_THREADS
+  unsigned long worker_id = xbt_parmap_get_worker_id(smx_ctx_sysv_parmap);
+  ucontext_t* local_maestro_uc = &smx_ctx_sysv_local_maestro_uc[worker_id];
 
-  xbt_assert0((rv == 0), "Context swapping failure");
+  smx_context_t context = first_process->context;
+  SIMIX_context_set_current(context);
+  swapcontext(local_maestro_uc, &((smx_ctx_sysv_t) context)->uc);
+#endif
 }
 
-void smx_ctx_sysv_runall_parallel(xbt_dynar_t processes)
+static void smx_ctx_sysv_runall_parallel(void)
 {
-  xbt_parmap_apply(parmap, (void_f_pvoid_t)smx_ctx_sysv_resume_parallel, processes);
-  xbt_dynar_reset(processes);
+#ifdef CONTEXT_THREADS
+  xbt_parmap_apply(smx_ctx_sysv_parmap, (void_f_pvoid_t) smx_ctx_sysv_resume_parallel,
+      simix_global->process_to_run);
+#endif
 }
 
 smx_context_t smx_ctx_sysv_self_parallel(void)
 {
   /*smx_context_t self_context = (smx_context_t) xbt_os_thread_get_extra_data();
   return self_context ? self_context : (smx_context_t) maestro_context;*/
-  return smx_current_context;
-}
-
-int smx_ctx_sysv_get_thread_id(void)
-{
-  return (int)(unsigned long)xbt_os_thread_get_extra_data();
+  return SIMIX_context_get_current();
 }