Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
329b1bd76c583e37986276a2178f477d048b2a2a
[simgrid.git] / src / msg / global.c
1 /*     $Id$      */
2
3 /* Copyright (c) 2002-2007 Arnaud Legrand.                                  */
4 /* Copyright (c) 2007 Bruno Donassolo.                                      */
5 /* All rights reserved.                                                     */
6
7 /* This program is free software; you can redistribute it and/or modify it
8  * under the terms of the license (GNU LGPL) which comes with this package. */
9
10 #include "msg/private.h"
11 #include "xbt/sysdep.h"
12 #include "xbt/log.h"
13 #include "xbt/virtu.h"
14 #include "xbt/ex.h"             /* ex_backtrace_display */
15 #include "mailbox.h"
16
17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_kernel, msg,
18                                 "Logging specific to MSG (kernel)");
19
20 MSG_Global_t msg_global = NULL;
21
22
23 /** \defgroup msg_simulation   MSG simulation Functions
24  *  \brief This section describes the functions you need to know to
25  *  set up a simulation. You should have a look at \ref MSG_examples
26  *  to have an overview of their usage.
27  */
28 /** @addtogroup msg_simulation
29  *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Simulation functions" --> \endhtmlonly
30  */
31
32 /********************************* MSG **************************************/
33
34 /** \ingroup msg_simulation
35  * \brief Initialize some MSG internal data.
36  */
37 void MSG_global_init_args(int *argc, char **argv)
38 {
39   MSG_global_init(argc, argv);
40 }
41
42
43 XBT_LOG_EXTERNAL_CATEGORY(msg_gos);
44 XBT_LOG_EXTERNAL_CATEGORY(msg_kernel);
45 XBT_LOG_EXTERNAL_CATEGORY(msg_mailbox);
46 XBT_LOG_EXTERNAL_CATEGORY(msg_process);
47
48 /** \ingroup msg_simulation
49  * \brief Initialize some MSG internal data.
50  */
51 void MSG_global_init(int *argc, char **argv)
52 {
53   xbt_getpid = MSG_process_self_PID;
54   if (!msg_global) {
55     /* Connect our log channels: that must be done manually under windows */
56     XBT_LOG_CONNECT(msg_gos, msg);
57     XBT_LOG_CONNECT(msg_kernel, msg);
58     XBT_LOG_CONNECT(msg_mailbox, msg);
59     XBT_LOG_CONNECT(msg_process, msg);
60
61     SIMIX_global_init(argc, argv);
62
63     msg_global = xbt_new0(s_MSG_Global_t, 1);
64
65     msg_global->host = xbt_fifo_new();
66     msg_global->process_list = xbt_fifo_new();
67     msg_global->max_channel = 0;
68     msg_global->PID = 1;
69     msg_global->sent_msg = 0;
70
71         /* initialization of the mailbox module */
72         MSG_mailbox_mod_init();
73
74         /* initialization of the action module */
75         _MSG_action_init();
76
77     SIMIX_function_register_process_create(_MSG_process_create_from_SIMIX);
78     SIMIX_function_register_process_cleanup(__MSG_process_cleanup);
79     SIMIX_function_register_process_kill(_MSG_process_kill_from_SIMIX);
80   }
81   return;
82 }
83
84 /** \ingroup msg_easier_life
85  * \brief Traces MSG events in the Paje format.
86  */
87
88 void MSG_paje_output(const char *filename)
89 {
90 }
91
92 /** \defgroup m_channel_management    Understanding channels
93  *  \brief This section briefly describes the channel notion of MSG
94  *  (#m_channel_t).
95  */
96 /** @addtogroup m_channel_management
97  *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Channels" --> \endhtmlonly
98  *
99  *
100  *  For convenience, the simulator provides the notion of channel
101  *  that is close to the tag notion in MPI. A channel is not a
102  *  socket. It doesn't need to be opened neither closed. It rather
103  *  corresponds to the ports opened on the different machines.
104  */
105
106
107 /** \ingroup m_channel_management
108  * \brief Set the number of channel in the simulation.
109  *
110  * This function has to be called to fix the number of channel in the
111    simulation before creating any host. Indeed, each channel is
112    represented by a different mailbox on each #m_host_t. This
113    function can then be called only once. This function takes only one
114    parameter.
115  * \param number the number of channel in the simulation. It has to be >0
116  */
117 MSG_error_t MSG_set_channel_number(int number)
118 {
119   xbt_assert0((msg_global)
120               && (msg_global->max_channel == 0),
121               "Channel number already set!");
122
123   msg_global->max_channel = number;
124
125   return MSG_OK;
126 }
127
128 /** \ingroup m_channel_management
129  * \brief Return the number of channel in the simulation.
130  *
131  * This function has to be called once the number of channel is fixed. I can't
132    figure out a reason why anyone would like to call this function but nevermind.
133  * \return the number of channel in the simulation.
134  */
135 int MSG_get_channel_number(void)
136 {
137   xbt_assert0((msg_global)
138               && (msg_global->max_channel != 0),
139               "Channel number not set yet!");
140
141   return msg_global->max_channel;
142 }
143
144 void __MSG_display_process_status(void)
145 {
146 }
147
148
149 /* FIXME: Yeah, I'll do it in a portable maner one day [Mt] */
150 #include <signal.h>
151
152 static void _XBT_CALL inthandler(int ignored)
153 {
154   INFO0("CTRL-C pressed. Displaying status and bailing out");
155   __MSG_display_process_status();
156   exit(1);
157 }
158
159 /** \ingroup msg_simulation
160  * \brief Launch the MSG simulation
161  */
162 MSG_error_t MSG_main(void)
163 {
164   smx_cond_t cond = NULL;
165   smx_action_t smx_action;
166   xbt_fifo_t actions_done = xbt_fifo_new();
167   xbt_fifo_t actions_failed = xbt_fifo_new();
168
169   /* Prepare to display some more info when dying on Ctrl-C pressing */
170   signal(SIGINT, inthandler);
171
172   /* Clean IO before the run */
173   fflush(stdout);
174   fflush(stderr);
175   SIMIX_init();
176
177   //surf_solve(); /* Takes traces into account. Returns 0.0 */
178   /* xbt_fifo_size(msg_global->process_to_run) */
179
180   while (SIMIX_solve(actions_done, actions_failed) != -1.0) {
181
182     while ((smx_action = xbt_fifo_pop(actions_failed))) {
183
184
185       DEBUG1("** %s failed **", smx_action->name);
186       while ((cond = xbt_fifo_pop(smx_action->cond_list))) {
187         SIMIX_cond_broadcast(cond);
188       }
189     }
190
191     while ((smx_action = xbt_fifo_pop(actions_done))) {
192
193       DEBUG1("** %s done **", smx_action->name);
194       while ((cond = xbt_fifo_pop(smx_action->cond_list))) {
195         SIMIX_cond_broadcast(cond);
196       }
197     }
198   }
199   xbt_fifo_free(actions_failed);
200   xbt_fifo_free(actions_done);
201   return MSG_OK;
202 }
203
204 /** \ingroup msg_simulation
205  * \brief Kill all running process
206
207  * \param reset_PIDs should we reset the PID numbers. A negative
208  *   number means no reset and a positive number will be used to set the PID
209  *   of the next newly created process.
210  */
211 int MSG_process_killall(int reset_PIDs)
212 {
213   m_process_t p = NULL;
214   m_process_t self = MSG_process_self();
215
216   while ((p = xbt_fifo_pop(msg_global->process_list))) {
217     if (p != self)
218       MSG_process_kill(p);
219   }
220
221   if (reset_PIDs > 0) {
222     msg_global->PID = reset_PIDs;
223     msg_global->session++;
224   }
225
226   return msg_global->PID;
227
228 }
229
230 /** \ingroup msg_simulation
231  * \brief Clean the MSG simulation
232  */
233 MSG_error_t MSG_clean(void)
234 {
235   xbt_fifo_item_t i = NULL;
236   m_host_t h = NULL;
237   m_process_t p = NULL;
238
239
240   while ((p = xbt_fifo_pop(msg_global->process_list))) {
241     MSG_process_kill(p);
242   }
243
244   xbt_fifo_foreach(msg_global->host, i, h, m_host_t) {
245     __MSG_host_destroy(h);
246   }
247   xbt_fifo_free(msg_global->host);
248   xbt_fifo_free(msg_global->process_list);
249
250   free(msg_global);
251   msg_global = NULL;
252
253   /* cleanup all resources in the mailbox module */
254   MSG_mailbox_mod_exit();
255
256   SIMIX_clean();
257
258
259
260   return MSG_OK;
261 }
262
263
264 /** \ingroup msg_easier_life
265  * \brief A clock (in second).
266  */
267 double MSG_get_clock(void)
268 {
269   return SIMIX_get_clock();
270 }
271
272 unsigned long int MSG_get_sent_msg() {
273   return msg_global->sent_msg;
274 }