Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Clean the links between action and conditions. Now there are two functions:
[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_cond_wait(cond);
189     SIMIX_unregister_action_to_condition(act_sleep, cond);
190     SIMIX_action_destroy(act_sleep);
191   } else {
192     __SIMIX_cond_wait(cond);
193   }
194   /* get the mutex again */
195   SIMIX_mutex_lock(cond->mutex);
196
197   return;
198 }
199
200 xbt_fifo_t SIMIX_cond_get_actions(smx_cond_t cond)
201 {
202   xbt_assert0((cond != NULL), "Invalid parameters");
203   return cond->actions;
204 }
205
206 void __SIMIX_cond_wait(smx_cond_t cond)
207 {
208   smx_process_t self = SIMIX_process_self();
209   xbt_assert0((cond != NULL), "Invalid parameters");
210
211   /* process status */
212
213   self->simdata->cond = cond;
214   xbt_swag_insert(self, cond->sleeping);
215   xbt_context_yield();
216   self->simdata->cond = NULL;
217   while (self->simdata->suspended) {
218     xbt_context_yield();
219   }
220   return;
221
222 }
223
224 /**
225  * \brief Waits on a condition with timeout.
226  *
227  * Same behavior of #SIMIX_cond_wait, but waits a maximum time and throws an timeout_error if it happens.
228  * \param cond A condition
229  * \param mutex A mutex
230  * \param max_duration Timeout time
231  */
232 void SIMIX_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex,
233                              double max_duration)
234 {
235   xbt_assert0((mutex != NULL), "Invalid parameters");
236   smx_action_t act_sleep;
237
238   DEBUG1("Timed wait condition %p", cond);
239   cond->mutex = mutex;
240
241   SIMIX_mutex_unlock(mutex);
242   if (max_duration >= 0) {
243     act_sleep = SIMIX_action_sleep(SIMIX_host_self(), max_duration);
244     SIMIX_register_action_to_condition(act_sleep, cond);
245     __SIMIX_cond_wait(cond);
246     SIMIX_unregister_action_to_condition(act_sleep, cond);
247     if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
248       SIMIX_action_destroy(act_sleep);
249       THROW0(timeout_error, 0, "Condition timeout");
250     } else {
251       SIMIX_action_destroy(act_sleep);
252     }
253
254   } else
255     __SIMIX_cond_wait(cond);
256
257   /* get the mutex again */
258   SIMIX_mutex_lock(cond->mutex);
259
260   return;
261 }
262
263 /**
264  * \brief Broadcasts a condition.
265  *
266  * Signalizes a condition and wakes up ALL sleping process. If there are no process sleeping, no action is done.
267  * \param cond A condition
268  */
269 void SIMIX_cond_broadcast(smx_cond_t cond)
270 {
271   xbt_assert0((cond != NULL), "Invalid parameters");
272   smx_process_t proc = NULL;
273   smx_process_t proc_next = NULL;
274
275   DEBUG1("Broadcast condition %p", cond);
276   xbt_swag_foreach_safe(proc, proc_next, cond->sleeping) {
277     xbt_swag_remove(proc, cond->sleeping);
278     xbt_swag_insert(proc, simix_global->process_to_run);
279   }
280
281   return;
282 }
283
284 /**
285  * \brief Destroys a contidion.
286  *
287  * Destroys and frees the condition's memory. 
288  * \param cond A condition
289  */
290 void SIMIX_cond_destroy(smx_cond_t cond)
291 {
292   DEBUG1("Destroy condition %p", cond);
293   if (cond == NULL)
294     return;
295   else {
296     xbt_fifo_item_t item = NULL;
297     smx_action_t action = NULL;
298
299     xbt_assert0(xbt_swag_size(cond->sleeping) == 0,
300                 "Cannot destroy conditional since someone is still using it");
301     xbt_swag_free(cond->sleeping);
302
303     DEBUG1("%d actions registered", xbt_fifo_size(cond->actions));
304     __SIMIX_cond_display_actions(cond);
305     xbt_fifo_foreach(cond->actions, item, action, smx_action_t) {
306       SIMIX_unregister_action_to_condition(action, cond);
307     }
308     __SIMIX_cond_display_actions(cond);
309
310     xbt_fifo_free(cond->actions);
311     xbt_free(cond);
312     return;
313   }
314 }