Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
avoid any name clashes with msg/private.h so that the java interface can do crude...
[simgrid.git] / src / simix / smx_global.c
index cbf10cc..b84d48d 100644 (file)
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_kernel, simix,
                                "Logging specific to SIMIX (kernel)");
 
-
 SIMIX_Global_t simix_global = NULL;
 
-
-/** \defgroup simix_simulation   SIMIX simulation Functions
- *  \brief This section describes the functions you need to know to
- *  set up a simulation. You should have a look at \ref SIMIX_examples 
- *  to have an overview of their usage.
- *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Simulation functions" --> \endhtmlonly
- */
-
 /********************************* SIMIX **************************************/
 
-/** \ingroup simix_simulation
- * \brief Initialize some SIMIX internal data.
- */
-void SIMIX_global_init_args(int *argc, char **argv)
-{
-  SIMIX_global_init(argc,argv);
-}
-
-/** \ingroup simix_simulation
+/**
  * \brief Initialize some SIMIX internal data.
+ *
+ * \param argc Argc
+ * \param argv Argv
  */
 void SIMIX_global_init(int *argc, char **argv)
 {
@@ -51,6 +37,9 @@ void SIMIX_global_init(int *argc, char **argv)
                simix_global->process_list = xbt_swag_new(xbt_swag_offset(proc,process_hookup));
                simix_global->current_process = NULL;
                simix_global->registered_functions = xbt_dict_new();
+
+               simix_global->create_process_function = NULL;
+               simix_global->kill_process_function = NULL;
        }
 }
 
@@ -62,31 +51,36 @@ void __SIMIX_display_process_status(void)
         smx_action_t act;
    int nbprocess=xbt_swag_size(simix_global->process_list);
    
-   INFO1("SIMIX: %d processes are still running, waiting for something.",
+   INFO1("%d processes are still running, waiting for something.",
         nbprocess);
    /*  List the process and their state */
-   INFO0("SIMIX: <process> on <host>: <status>.");
+   INFO0("Legend of the following listing: \"<process> on <host>: <status>.\"");
    xbt_swag_foreach(process, simix_global->process_list) {
       smx_simdata_process_t p_simdata = (smx_simdata_process_t) process->simdata;
      // simdata_host_t h_simdata=(simdata_host_t)p_simdata->host->simdata;
-      char *who;
+      char *who, *who2;
        
-      asprintf(&who,"SIMIX:  %s on %s: %s",
+      asprintf(&who,"%s on %s: %s",
               process->name,
-                               p_simdata->host->name,
+              p_simdata->host->name,
               (process->simdata->blocked)?"[BLOCKED] "
               :((process->simdata->suspended)?"[SUSPENDED] ":""));
-                       if (p_simdata->mutex) {
-                               DEBUG1("Block on a mutex: %s", who);                    
-                       }
-                       else if (p_simdata->cond) {
-                               DEBUG1("Block on a condition: %s", who);
-                               DEBUG0("Waiting actions:");
-                               xbt_fifo_foreach(p_simdata->cond->actions,item, act, smx_action_t) {
-                                       DEBUG1("\t %s", act->name);
-                               }
-                       }
-                       else DEBUG1("Unknown block status: %s", who);
+      
+      if (p_simdata->mutex) {
+        who2=bprintf("%s Blocked on mutex %p",who,p_simdata->mutex);
+        free(who); who=who2;
+      } else if (p_simdata->cond) {
+        who2=bprintf("%s Blocked on condition %p; Waiting for the following actions:",who,p_simdata->cond);
+        free(who); who=who2;
+        xbt_fifo_foreach(p_simdata->cond->actions,item, act, smx_action_t) {
+           who2=bprintf("%s '%s'",who,act->name);
+           free(who); who=who2;
+        }
+      } else {
+        who2=bprintf("%s Blocked in an unknown status (please report this bug)",who);
+        free(who); who=who2;
+      }
+      INFO1("%s.",who);
       free(who);
    }
 }
@@ -101,8 +95,8 @@ static void _XBT_CALL inthandler(int ignored)
    exit(1);
 }
 
-/** \ingroup msg_simulation
- * \brief Launch the SIMIX simulation
+/**
+ * \brief Launch the SIMIX simulation, debug purpose
  */
 void __SIMIX_main(void)
 {
@@ -158,12 +152,9 @@ void __SIMIX_main(void)
        return;
 }
 
-/** \ingroup msg_simulation
+/**
  * \brief Kill all running process
-
- * \param reset_PIDs should we reset the PID numbers. A negative
- *   number means no reset and a positive number will be used to set the PID
- *   of the next newly created process.
+ *
  */
 void SIMIX_process_killall()
 {
@@ -183,8 +174,10 @@ void SIMIX_process_killall()
   return;
 }
 
-/** \ingroup msg_simulation
+/** 
  * \brief Clean the SIMIX simulation
+ *
+ * This functions remove all memories needed to the SIMIX execution
  */
 void SIMIX_clean(void)
 {
@@ -212,30 +205,41 @@ void SIMIX_clean(void)
 }
 
 
-/** \ingroup msg_easier_life
+/**
  * \brief A clock (in second).
+ *
+ * \return Return the clock.
  */
 double SIMIX_get_clock(void)
 {
   return surf_get_clock();
 }
 
+/**
+ *     \brief Does a turn of the simulation
+ *
+ *     Executes a step in the surf simulation, adding to the two lists all the actions that finished on this turn. Schedules all processus in the process_to_run list.         
+ *     \param actions_done List of actions done
+ *     \param actions_failed List of actions failed
+ *     \return The time spent to execute the simulation or -1 if the simulation ended
+ */
 double SIMIX_solve(xbt_fifo_t actions_done, xbt_fifo_t actions_failed) 
 {
 
        smx_process_t process = NULL;
        int i;
        double elapsed_time = 0.0;
-       int state_modifications = 0;
-
-
-       //surf_solve(); /* Takes traces into account. Returns 0.0  I don't know what to do with this*/
+       static int state_modifications = 1;
+       static int first = 1;
 
        xbt_context_empty_trash();
        if(xbt_swag_size(simix_global->process_to_run) && (elapsed_time>0)) {
                DEBUG0("**************************************************");
        }
-
+       if (first) {
+               surf_solve();/* Takes traces into account. Returns 0.0 */
+               first=0;
+       }
        while ((process = xbt_swag_extract(simix_global->process_to_run))) {
                DEBUG2("Scheduling %s on %s",        
                                process->name,
@@ -256,8 +260,9 @@ double SIMIX_solve(xbt_fifo_t actions_done, xbt_fifo_t actions_failed)
 
                xbt_dynar_foreach(resource_list, i, resource) {
                        if(xbt_swag_size(resource->common_public->states.failed_action_set) ||
-                                       xbt_swag_size(resource->common_public->states.done_action_set))
+                                       xbt_swag_size(resource->common_public->states.done_action_set)) {
                                state_modifications = 1;
+                               }
                }
 
                if(!state_modifications) {
@@ -268,12 +273,12 @@ double SIMIX_solve(xbt_fifo_t actions_done, xbt_fifo_t actions_failed)
 
                while (surf_timer_resource->extension_public->get(&fun,(void*)&arg)) {
                        DEBUG2("got %p %p", fun, arg);
-                       if(fun==SIMIX_process_create_with_arguments) {
-                               process_arg_t args = arg;
-                               DEBUG2("Launching %s on %s", args->name, args->host->name);
-                               process = SIMIX_process_create_with_arguments(args->name, args->code, 
-                                               args->data, args->host,
-                                               args->argc,args->argv);
+                       if(fun==SIMIX_process_create) {
+                               smx_process_arg_t args = arg;
+                               DEBUG2("Launching %s on %s", args->name, args->hostname);
+                               process = SIMIX_process_create(args->name, args->code, 
+                                               args->data, args->hostname,
+                                               args->argc,args->argv,NULL);
                                if(args->kill_time > SIMIX_get_clock()) {
                                        surf_timer_resource->extension_public->set(args->kill_time, 
                                                        (void*) &SIMIX_process_kill,
@@ -305,10 +310,11 @@ double SIMIX_solve(xbt_fifo_t actions_done, xbt_fifo_t actions_failed)
                        }
                }
        }
+       state_modifications = 0;
 
        if (elapsed_time == -1) {
                if (xbt_swag_size(simix_global->process_list) == 0) {
-                       INFO0("Congratulations ! Simulation terminated : all processes are over");
+/*                     INFO0("Congratulations ! Simulation terminated : all processes are over"); */
                } else {
                        INFO0("Oops ! Deadlock or code not perfectly clean.");
                        __SIMIX_display_process_status();
@@ -323,7 +329,15 @@ double SIMIX_solve(xbt_fifo_t actions_done, xbt_fifo_t actions_failed)
        return elapsed_time;
 }
 
-
+/**
+ *     \brief Set the date to execute a function
+ *
+ * Set the date to execute the function on the surf.
+ *     \param date Date to execute function
+ *     \param function Function to be executed
+ *     \param arg Parameters of the function
+ *
+ */
 void SIMIX_timer_set (double date, void *function, void *arg)
 {
        surf_timer_resource->extension_public->set(date, function, arg);
@@ -333,3 +347,37 @@ int SIMIX_timer_get(void **function, void **arg)
 {
        return surf_timer_resource->extension_public->get(function, arg);
 }
+
+/**
+ *     \brief Registers a function to create a process.
+ *
+ *     This function registers an user function to be called when a new process is created. The user function have to call the SIMIX_create_process function.
+ *     \param function Create process function
+ *
+ */
+void SIMIX_function_register_process_create(void * function)
+{
+  xbt_assert0((simix_global->create_process_function == NULL), "Data already set");
+
+  /* Assign create process */
+  simix_global->create_process_function = function;
+
+  return ;
+}
+
+/**
+ *     \brief Registers a function to kill a process.
+ *
+ *     This function registers an user function to be called when a new process is killed. The user function have to call the SIMIX_kill_process function.
+ *     \param function Kill process function
+ *
+ */
+void SIMIX_function_register_process_kill(void * function)
+{
+  xbt_assert0((simix_global->kill_process_function == NULL), "Data already set");
+
+  /* Assign kill process */
+  simix_global->kill_process_function = function;
+
+  return ;
+}