X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e694957c5830a9f1407392fa7f76796274aa4d18..194df46818e3f10278130de231015fb42a6b29f7:/src/simix/smx_private.h

diff --git a/src/simix/smx_private.h b/src/simix/smx_private.h
index b0845e6852..34cf63e69a 100644
--- a/src/simix/smx_private.h
+++ b/src/simix/smx_private.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -33,6 +33,9 @@
 //#define TIME_BENCH_PER_SR /* this aims at measuring the time spent in each scheduling round per each thread. The code is thus run in sequential to bench separately each SSR */
 //#define TIME_BENCH_AMDAHL /* this aims at measuring the porting of time that could be parallelized at maximum (to get the optimal speedup by applying the amdahl law). */
 
+#ifdef TIME_BENCH_PER_SR
+void smx_ctx_raw_new_sr(void);
+#endif
 /********************************** Simix Global ******************************/
 typedef struct s_smx_global {
   smx_context_factory_t context_factory;
@@ -59,12 +62,20 @@ extern unsigned long simix_process_maxpid;
 
 extern xbt_dict_t watched_hosts_lib;
 
-/******************************** Exceptions *********************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+XBT_PUBLIC(void) SIMIX_clean(void);
+#ifdef __cplusplus
+}
+#endif
 
-#define SMX_EXCEPTION(issuer, c, v, m)                                  \
+/******************************** Exceptions *********************************/
+/** @brief Ask to the provided simix process to raise the provided exception */
+#define SMX_EXCEPTION(issuer, cat, val, msg)                            \
   if (1) {                                                              \
-    smx_process_t _smx_throw_issuer = (issuer);                         \
-    THROW_PREPARE(_smx_throw_issuer->running_ctx, (c), (v), xbt_strdup(m)); \
+    smx_process_t _smx_throw_issuer = (issuer); /* evaluate only once */\
+    THROW_PREPARE(_smx_throw_issuer->running_ctx, (cat), (val), xbt_strdup(msg)); \
     _smx_throw_issuer->doexception = 1;                                 \
   } else ((void)0)
 
@@ -76,11 +87,6 @@ typedef struct s_smx_file {
   void* data;                   /**< @brief user data */
 } s_smx_file_t;
 
-/* ******************************** Storage ************************************/
-typedef struct s_smx_storage_priv {
-  void *data;              /**< @brief user data */
-} s_smx_storage_priv_t;
-
 /*********************************** Time ************************************/
 
 /** @brief Timer datatype */
@@ -96,6 +102,7 @@ typedef enum {
   SIMIX_ACTION_EXECUTE,
   SIMIX_ACTION_PARALLEL_EXECUTE,
   SIMIX_ACTION_COMMUNICATE,
+  SIMIX_ACTION_JOIN,
   SIMIX_ACTION_SLEEP,
   SIMIX_ACTION_SYNCHRO,
   SIMIX_ACTION_IO,
@@ -140,8 +147,8 @@ typedef struct s_smx_action {
       smx_rdv_t rdv;                  /* Rendez-vous where the comm is queued */
 
 #ifdef HAVE_MC
-      smx_rdv_t rdv_cpy;              /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR 
-                                         (comm.rdv set to NULL when the communication is removed from the mailbox 
+      smx_rdv_t rdv_cpy;              /* Copy of the rendez-vous where the comm is queued, MC needs it for DPOR
+                                         (comm.rdv set to NULL when the communication is removed from the mailbox
                                          (used as garbage collector)) */
 #endif
       int refcount;                   /* Number of processes involved in the cond */
@@ -151,6 +158,7 @@ typedef struct s_smx_action {
       int (*match_fun)(void*,void*,smx_action_t);  /* Filter function used by the other side. It is used when
                                          looking if a given communication matches my needs. For that, myself must match the
                                          expectations of the other side, too. See  */
+      void (*copy_data_fun) (smx_action_t, void*, size_t);
 
       /* Surf action data */
       surf_action_t surf_comm;        /* The Surf communication action encapsulated */
@@ -170,7 +178,7 @@ typedef struct s_smx_action {
 
       void* src_data;                 /* User data associated to communication */
       void* dst_data;
-    } comm;    
+    } comm;
 
     struct {
       smx_host_t host;                /* The host that is sleeping */
@@ -203,26 +211,26 @@ typedef struct s_smx_action {
 #endif
 } s_smx_action_t;
 
-/* FIXME: check if we can delete this function */
-static XBT_INLINE e_smx_state_t SIMIX_action_map_state(e_surf_action_state_t state)
-{
-  switch (state) {
-    case SURF_ACTION_READY:
-      return SIMIX_READY;
-    case SURF_ACTION_RUNNING:
-      return SIMIX_RUNNING;
-    case SURF_ACTION_FAILED:
-      return SIMIX_FAILED;
-    case SURF_ACTION_DONE:
-      return SIMIX_DONE;
-    default:
-      xbt_die("Unexpected SURF action state");
-  }
-}
-
 void SIMIX_context_mod_init(void);
 void SIMIX_context_mod_exit(void);
 
+#ifndef WIN32
+XBT_PUBLIC_DATA(char sigsegv_stack[SIGSTKSZ]);
+#endif
+
+/* We are using the bottom of the stack to save some information, like the
+ * valgrind_stack_id. Define smx_context_usable_stack_size to give the remaining
+ * size for the stack. */
+#ifdef HAVE_VALGRIND_VALGRIND_H
+# define smx_context_usable_stack_size                                  \
+  (smx_context_stack_size - sizeof(unsigned int)) /* for valgrind_stack_id */
+#else
+# define smx_context_usable_stack_size smx_context_stack_size
+#endif
+
+void *SIMIX_context_stack_new(void);
+void SIMIX_context_stack_delete(void *stack);
+
 void SIMIX_context_set_current(smx_context_t context);
 smx_context_t SIMIX_context_get_current(void);
 
@@ -239,12 +247,12 @@ void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory);
 /* Scenario for the end of a context:
  *
  * CASE 1: death after end of the main function
- *   the context_wrapper, called internally by the context module, calls 
- *   SIMIX_context_stop after user code stops, smx_context_stop calls user 
+ *   the context_wrapper, called internally by the context module, calls
+ *   SIMIX_context_stop after user code stops, smx_context_stop calls user
  *   cleanup_func if any (in context settings), add current process to trashbin
  *   and yields back to maestro.
  *   From time to time, maestro calls SIMIX_context_empty_trash, which destroy
- *   all the process and context data structures, and frees the memory 
+ *   all the process and context data structures, and frees the memory
  *
  * CASE 2: brutal death
  *   SIMIX_process_kill (from any process) set process->iwannadie = 1 and then
@@ -275,7 +283,7 @@ static XBT_INLINE smx_context_t SIMIX_context_new(xbt_main_func_t code,
 }
 
 /**
- * \brief destroy a context 
+ * \brief destroy a context
  * \param context the context to destroy
  * Argument must be stopped first -- runs in maestro context
  */
@@ -314,7 +322,7 @@ static XBT_INLINE void SIMIX_context_runall(void)
 }
 
 /**
- \brief returns the current running context 
+ \brief returns the current running context
  */
 static XBT_INLINE smx_context_t SIMIX_context_self(void)
 {
@@ -325,13 +333,13 @@ static XBT_INLINE smx_context_t SIMIX_context_self(void)
 }
 
 /**
- \brief returns the data associated to a context
+ \brief returns the SIMIX process associated to a context
  \param context The context
- \return The data
+ \return The SIMIX process
  */
-static XBT_INLINE void* SIMIX_context_get_data(smx_context_t context)
+static XBT_INLINE smx_process_t SIMIX_context_get_process(smx_context_t context)
 {
-  return simix_global->context_factory->get_data(context);
+  return simix_global->context_factory->get_process(context);
 }
 
 XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);