X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f82324570da0d9e5ada9db953e969b760e9b7016..908c7a9f9135f982b3cbc232d45170e450682d39:/src/simix/smx_private.h

diff --git a/src/simix/smx_private.h b/src/simix/smx_private.h
index b2e5375f4a..9576a92e2b 100644
--- a/src/simix/smx_private.h
+++ b/src/simix/smx_private.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team.
+/* Copyright (c) 2007-2010, 2012-2015. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -22,16 +22,16 @@
 #include "smx_host_private.h"
 #include "smx_io_private.h"
 #include "smx_network_private.h"
-#include "smx_smurf_private.h"
+#include "popping_private.h"
 #include "smx_synchro_private.h"
-/* ****************************************************************************************** */
-/* TUTORIAL: New API                                                                        */
-/* ****************************************************************************************** */
-#include "smx_new_api_private.h"
+
+SG_BEGIN_DECL()
 
 /* Define only for SimGrid benchmarking purposes */
-//#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). */
+//#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). */
+//#define ADAPTIVE_THRESHOLD    /* this is to enable the adaptive threshold algorithm in raw contexts*/
+//#define TIME_BENCH_ENTIRE_SRS /* more general benchmark than TIME_BENCH_PER_SR. It aims to measure the total time spent in a whole scheduling round (including synchro costs)*/
 
 #ifdef TIME_BENCH_PER_SR
 void smx_ctx_raw_new_sr(void);
@@ -47,8 +47,9 @@ typedef struct s_smx_global {
   xbt_dict_t registered_functions;
   smx_creation_func_t create_process_function;
   void_pfn_smxprocess_t_smxprocess_t kill_process_function;
+  /** Callback used when killing a SMX_process */
   void_pfn_smxprocess_t cleanup_process_function;
-  xbt_mallocator_t action_mallocator;
+  xbt_mallocator_t synchro_mallocator;
   void_pfn_smxhost_t autorestart;
 
 #ifdef TIME_BENCH_AMDAHL
@@ -57,25 +58,19 @@ typedef struct s_smx_global {
 #endif
 } s_smx_global_t, *smx_global_t;
 
-extern smx_global_t simix_global;
+XBT_PUBLIC_DATA(smx_global_t) simix_global;
 extern unsigned long simix_process_maxpid;
 
 extern xbt_dict_t watched_hosts_lib;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 XBT_PUBLIC(void) SIMIX_clean(void);
-#ifdef __cplusplus
-}
-#endif
 
 /******************************** Exceptions *********************************/
-
-#define SMX_EXCEPTION(issuer, c, v, m)                                  \
+/** @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)
 
@@ -96,21 +91,17 @@ typedef struct s_smx_timer {
   void* args;
 } s_smx_timer_t;
 
-/********************************* Action *************************************/
+/********************************* synchro *************************************/
 
 typedef enum {
-  SIMIX_ACTION_EXECUTE,
-  SIMIX_ACTION_PARALLEL_EXECUTE,
-  SIMIX_ACTION_COMMUNICATE,
-  SIMIX_ACTION_JOIN,
-  SIMIX_ACTION_SLEEP,
-  SIMIX_ACTION_SYNCHRO,
-  SIMIX_ACTION_IO,
-  /* ****************************************************************************************** */
-  /* TUTORIAL: New API                                                                        */
-  /* ****************************************************************************************** */
-  SIMIX_ACTION_NEW_API
-} e_smx_action_type_t;
+  SIMIX_SYNC_EXECUTE,
+  SIMIX_SYNC_PARALLEL_EXECUTE,
+  SIMIX_SYNC_COMMUNICATE,
+  SIMIX_SYNC_JOIN,
+  SIMIX_SYNC_SLEEP,
+  SIMIX_SYNC_SYNCHRO,
+  SIMIX_SYNC_IO,
+} e_smx_synchro_type_t;
 
 typedef enum {
   SIMIX_COMM_SEND,
@@ -126,15 +117,15 @@ typedef enum {
   SIMIX_IO_STAT
 } e_smx_io_type_t;
 
-/** @brief Action datatype */
-typedef struct s_smx_action {
+/** @brief synchro datatype */
+typedef struct s_smx_synchro {
 
-  e_smx_action_type_t type;          /* Type of SIMIX action*/
-  e_smx_state_t state;               /* State of the action */
-  char *name;                        /* Action name if any */
-  xbt_fifo_t simcalls;               /* List of simcalls waiting for this action */
+  e_smx_synchro_type_t type;          /* Type of SIMIX synchro */
+  e_smx_state_t state;               /* State of the synchro */
+  char *name;                        /* synchro name if any */
+  xbt_fifo_t simcalls;               /* List of simcalls waiting for this synchro */
 
-  /* Data specific to each action type */
+  /* Data specific to each synchro type */
   union {
 
     struct {
@@ -155,10 +146,10 @@ typedef struct s_smx_action {
       int detached;                   /* If detached or not */
 
       void (*clean_fun)(void*);       /* Function to clean the detached src_buf if something goes wrong */
-      int (*match_fun)(void*,void*,smx_action_t);  /* Filter function used by the other side. It is used when
+      int (*match_fun)(void*,void*,smx_synchro_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);
+      void (*copy_data_fun) (smx_synchro_t, void*, size_t);
 
       /* Surf action data */
       surf_action_t surf_comm;        /* The Surf communication action encapsulated */
@@ -193,23 +184,14 @@ typedef struct s_smx_action {
       smx_host_t host;
       surf_action_t surf_io;
     } io;
-
-    /* ****************************************************************************************** */
-    /* TUTORIAL: New API                                                                        */
-    /* ****************************************************************************************** */
-    struct {
-      surf_action_t surf_new_api;
-    } new_api;
   };
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
   int latency_limited;
 #endif
 
-#ifdef HAVE_TRACING
   char *category;                     /* simix action category for instrumentation */
-#endif
-} s_smx_action_t;
+} s_smx_synchro_t;
 
 void SIMIX_context_mod_init(void);
 void SIMIX_context_mod_exit(void);
@@ -239,6 +221,7 @@ smx_context_t SIMIX_context_get_current(void);
 void SIMIX_ctx_thread_factory_init(smx_context_factory_t *factory);
 void SIMIX_ctx_sysv_factory_init(smx_context_factory_t *factory);
 void SIMIX_ctx_raw_factory_init(smx_context_factory_t *factory);
+void SIMIX_ctx_boost_factory_init(smx_context_factory_t *factory);
 
 /* ****************************** */
 /* context manipulation functions */
@@ -346,4 +329,6 @@ XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);
 
 void SIMIX_post_create_environment(void);
 
+SG_END_DECL()
+
 #endif