Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Reindent!
[simgrid.git] / src / simix / smx_synchro.c
1 /*      $Id$     */
2
3 /* Copyright (c) 2007 Arnaud Legrand, Bruno Donnassolo.
4    All rights reserved.                                          */
5
6 /* This program is free software; you can redistribute it and/or modify it
7  * under the terms of the license (GNU LGPL) which comes with this package. */
8
9 #include "private.h"
10 #include "xbt/log.h"
11
12
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_synchro, simix,
14                                 "Logging specific to SIMIX (synchronization)");
15
16
17 /****************************** Synchronization *******************************/
18
19 /*********************************** Mutex ************************************/
20
21 /**
22  * \brief Initialize a mutex.
23  *
24  * Allocs and creates the data for the mutex. It have to be called before the utilisation of the mutex.
25  * \return A mutex
26  */
27 smx_mutex_t SIMIX_mutex_init()
28 {
29   smx_mutex_t m = xbt_new0(s_smx_mutex_t, 1);
30   s_smx_process_t p;            /* useful to initialize sleeping swag */
31   /* structures initialization */
32   m->using = 0;
33   m->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
34   return m;
35 }
36
37 /**
38  * \brief Locks a mutex.
39  *
40  * Tries to lock a mutex, if the mutex isn't used yet, the process can continue its execution, else it'll be blocked here. You have to call #SIMIX_mutex_unlock to free the mutex.
41  * \param mutex The mutex
42  */
43 void SIMIX_mutex_lock(smx_mutex_t mutex)
44 {
45   smx_process_t self = SIMIX_process_self();
46   xbt_assert0((mutex != NULL), "Invalid parameters");
47
48
49   if (mutex->using) {
50     /* somebody using the mutex, block */
51     xbt_swag_insert(self, mutex->sleeping);
52     self->simdata->mutex = mutex;
53     /* wait for some process make the unlock and wake up me from mutex->sleeping */
54     xbt_context_yield();
55     self->simdata->mutex = NULL;
56
57     /* verify if the process was suspended */
58     while (self->simdata->suspended) {
59       xbt_context_yield();
60     }
61
62     mutex->using = 1;
63   } else {
64     /* mutex free */
65     mutex->using = 1;
66   }
67   return;
68 }
69
70 /**
71  * \brief Tries to lock a mutex.
72  *
73  * Tries to lock a mutex, return 1 if the mutex is free, 0 else. This function does not block the process if the mutex is used.
74  * \param mutex The mutex
75  * \return 1 - mutex free, 0 - mutex used
76  */
77 int SIMIX_mutex_trylock(smx_mutex_t mutex)
78 {
79   xbt_assert0((mutex != NULL), "Invalid parameters");
80
81   if (mutex->using)
82     return 0;
83   else {
84     mutex->using = 1;
85     return 1;
86   }
87 }
88
89 /**
90  * \brief Unlocks a mutex.
91  *
92  * Unlocks the mutex and wakes up a process blocked on it. If there are no process sleeping, only sets the mutex as free.
93  * \param mutex The mutex
94  */
95 void SIMIX_mutex_unlock(smx_mutex_t mutex)
96 {
97   smx_process_t p;              /*process to wake up */
98
99   xbt_assert0((mutex != NULL), "Invalid parameters");
100
101   if (xbt_swag_size(mutex->sleeping) > 0) {
102     p = xbt_swag_extract(mutex->sleeping);
103     mutex->using = 0;
104     xbt_swag_insert(p, simix_global->process_to_run);
105   } else {
106     /* nobody to wake up */
107     mutex->using = 0;
108   }
109   return;
110 }
111
112 /**
113  * \brief Destroys a mutex.
114  *
115  * Destroys and frees the mutex's memory. 
116  * \param mutex A mutex
117  */
118 void SIMIX_mutex_destroy(smx_mutex_t mutex)
119 {
120   if (mutex == NULL)
121     return;
122   else {
123     xbt_swag_free(mutex->sleeping);
124     xbt_free(mutex);
125     return;
126   }
127 }
128
129 /******************************** Conditional *********************************/
130
131 /**
132  * \brief Initialize a condition.
133  *
134  * Allocs and creates the data for the condition. It have to be called before the utilisation of the condition.
135  * \return A condition
136  */
137 smx_cond_t SIMIX_cond_init()
138 {
139   smx_cond_t cond = xbt_new0(s_smx_cond_t, 1);
140   s_smx_process_t p;
141
142   cond->sleeping = xbt_swag_new(xbt_swag_offset(p, synchro_hookup));
143   cond->actions = xbt_fifo_new();
144   cond->mutex = NULL;
145   return cond;
146 }
147
148 /**
149  * \brief Signalizes a condition.
150  *
151  * Signalizes a condition and wakes up a sleping process. If there are no process sleeping, no action is done.
152  * \param cond A condition
153  */
154 void SIMIX_cond_signal(smx_cond_t cond)
155 {
156   DEBUG1("Signal condition %p", cond);
157   xbt_assert0((cond != NULL), "Invalid parameters");
158   smx_process_t proc = NULL;
159
160   if (xbt_swag_size(cond->sleeping) >= 1) {
161     proc = xbt_swag_extract(cond->sleeping);
162     xbt_swag_insert(proc, simix_global->process_to_run);
163   }
164
165   return;
166 }
167
168 /**
169  * \brief Waits on a condition.
170  *
171  * Blocks a process until the signal is called. This functions frees the mutex associated and locks it after its execution.
172  * \param cond A condition
173  * \param mutex A mutex
174  */
175 void SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
176 {
177   smx_action_t act_sleep;
178   xbt_assert0((mutex != NULL), "Invalid parameters");
179
180   DEBUG1("Wait condition %p", cond);
181   cond->mutex = mutex;
182
183   SIMIX_mutex_unlock(mutex);
184   /* create an action null only if there are no actions already on the condition, usefull if the host crashs */
185   if (xbt_fifo_size(cond->actions) == 0) {
186     act_sleep = SIMIX_action_sleep(SIMIX_host_self(), -1);
187     SIMIX_register_action_to_condition(act_sleep, cond);
188     SIMIX_register_condition_to_action(act_sleep, cond);
189     __SIMIX_cond_wait(cond);
190     xbt_fifo_pop(act_sleep->cond_list);
191     SIMIX_action_destroy(act_sleep);
192   } else {
193     __SIMIX_cond_wait(cond);
194   }
195   /* get the mutex again */
196   SIMIX_mutex_lock(cond->mutex);
197
198   return;
199 }
200
201 xbt_fifo_t SIMIX_cond_get_actions(smx_cond_t cond)
202 {
203   xbt_assert0((cond != NULL), "Invalid parameters");
204   return cond->actions;
205 }
206
207 void __SIMIX_cond_wait(smx_cond_t cond)
208 {
209   smx_process_t self = SIMIX_process_self();
210   xbt_assert0((cond != NULL), "Invalid parameters");
211
212   /* process status */
213
214   self->simdata->cond = cond;
215   xbt_swag_insert(self, cond->sleeping);
216   xbt_context_yield();
217   self->simdata->cond = NULL;
218   while (self->simdata->suspended) {
219     xbt_context_yield();
220   }
221   return;
222
223 }
224
225 /**
226  * \brief Waits on a condition with timeout.
227  *
228  * Same behavior of #SIMIX_cond_wait, but waits a maximum time and throws an timeout_error if it happens.
229  * \param cond A condition
230  * \param mutex A mutex
231  * \param max_duration Timeout time
232  */
233 void SIMIX_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex,
234                              double max_duration)
235 {
236   xbt_assert0((mutex != NULL), "Invalid parameters");
237   smx_action_t act_sleep;
238
239   DEBUG1("Timed wait condition %p", cond);
240   cond->mutex = mutex;
241
242   SIMIX_mutex_unlock(mutex);
243   if (max_duration >= 0) {
244     act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration);
245     SIMIX_register_action_to_condition(act_sleep, cond);
246     SIMIX_register_condition_to_action(act_sleep, cond);
247     __SIMIX_cond_wait(cond);
248     xbt_fifo_remove(act_sleep->cond_list, cond);
249     if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
250       SIMIX_action_destroy(act_sleep);
251       THROW0(timeout_error, 0, "Condition timeout");
252     } else {
253       SIMIX_action_destroy(act_sleep);
254     }
255
256   } else
257     __SIMIX_cond_wait(cond);
258
259   /* get the mutex again */
260   SIMIX_mutex_lock(cond->mutex);
261
262   return;
263 }
264
265 /**
266  * \brief Broadcasts a condition.
267  *
268  * Signalizes a condition and wakes up ALL sleping process. If there are no process sleeping, no action is done.
269  * \param cond A condition
270  */
271 void SIMIX_cond_broadcast(smx_cond_t cond)
272 {
273   xbt_assert0((cond != NULL), "Invalid parameters");
274   smx_process_t proc = NULL;
275   smx_process_t proc_next = NULL;
276
277   DEBUG1("Broadcast condition %p", cond);
278   xbt_swag_foreach_safe(proc, proc_next, cond->sleeping) {
279     xbt_swag_remove(proc, cond->sleeping);
280     xbt_swag_insert(proc, simix_global->process_to_run);
281   }
282
283   return;
284 }
285
286 /**
287  * \brief Destroys a contidion.
288  *
289  * Destroys and frees the condition's memory. 
290  * \param cond A condition
291  */
292 void SIMIX_cond_destroy(smx_cond_t cond)
293 {
294   DEBUG1("Destroy condition %p", cond);
295   if (cond == NULL)
296     return;
297   else {
298     xbt_fifo_item_t item = NULL;
299     smx_action_t action = NULL;
300
301     xbt_assert0(xbt_swag_size(cond->sleeping) == 0,
302                 "Cannot destroy conditional since someone is still using it");
303     xbt_swag_free(cond->sleeping);
304
305     xbt_fifo_foreach(cond->actions, item, action, smx_action_t) {
306       SIMIX_unregister_condition_to_action(action, cond);
307     }
308     xbt_fifo_free(cond->actions);
309     xbt_free(cond);
310     return;
311   }
312 }
313
314 /**
315  *      \brief Set a condition to an action
316  *
317  *      Creates the "link" between an action and a condition. You have to call this function when you create an action and want to wait its ending. 
318  *      \param action SIMIX action
319  *      \param cond SIMIX cond
320  */
321 void SIMIX_register_condition_to_action(smx_action_t action,
322                                         smx_cond_t cond)
323 {
324   xbt_assert0((action != NULL) && (cond != NULL), "Invalid parameters");
325
326   DEBUG2("Register condition %p to action %p", cond, action);
327   xbt_fifo_push(action->cond_list, cond);
328 }
329
330 /**
331  *      \brief Unset a condition to an action
332  *
333  *      Destroys the "link" between an action and a condition. 
334  *      \param action SIMIX action
335  *      \param cond SIMIX cond
336  */
337 void SIMIX_unregister_condition_to_action(smx_action_t action,
338                                           smx_cond_t cond)
339 {
340   xbt_assert0((action != NULL) && (cond != NULL), "Invalid parameters");
341
342   while (xbt_fifo_remove(action->cond_list, cond)) {
343   }
344 }