Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
update the double extern declaration bis
[simgrid.git] / src / simix / smx_process.c
1 /*      $Id$     */
2
3 /* Copyright (c) 2002,2003,2004 Arnaud Legrand. All rights reserved.        */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "private.h"
9 #include "xbt/sysdep.h"
10 #include "xbt/log.h"
11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix,
12                                 "Logging specific to SIMIX (process)");
13 /** \defgroup m_process_management Management Functions of Agents
14  *  \brief This section describes the agent structure of MSG
15  *  (#m_process_t) and the functions for managing it.
16  *    \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Agents" --> \endhtmlonly
17  * 
18  *  We need to simulate many independent scheduling decisions, so
19  *  the concept of <em>process</em> is at the heart of the
20  *  simulator. A process may be defined as a <em>code</em>, with
21  *  some <em>private data</em>, executing in a <em>location</em>.
22  *  \see m_process_t
23  */
24
25 /******************************** Process ************************************/
26 /** \ingroup m_process_management
27  * \brief Creates and runs a new #m_process_t.
28  *
29  * Does exactly the same as #MSG_process_create_with_arguments but without 
30    providing standard arguments (\a argc, \a argv, \a start_time, \a kill_time).
31  * \sa MSG_process_create_with_arguments
32  */
33 smx_process_t SIMIX_process_create(const char *name,
34                                smx_process_code_t code, void *data,
35                                smx_host_t host)
36 {
37   return SIMIX_process_create_with_arguments(name, code, data, host, -1, NULL);
38 }
39
40 static void SIMIX_process_cleanup(void *arg)
41 {
42   xbt_swag_remove(arg, simix_global->process_list);
43   xbt_swag_remove(arg, simix_global->process_to_run);
44   xbt_swag_remove(arg, ((smx_process_t) arg)->simdata->host->simdata->process_list);
45   free(((smx_process_t) arg)->name);
46   ((smx_process_t) arg)->name = NULL;
47   free(((smx_process_t) arg)->simdata);
48   ((smx_process_t) arg)->simdata = NULL;
49   free(arg);
50 }
51
52 /** \ingroup m_process_management
53  * \brief Creates and runs a new #m_process_t.
54
55  * A constructor for #m_process_t taking four arguments and returning the 
56  * corresponding object. The structure (and the corresponding thread) is
57  * created, and put in the list of ready process.
58  * \param name a name for the object. It is for user-level information
59    and can be NULL.
60  * \param code is a function describing the behavior of the agent. It
61    should then only use functions described in \ref
62    m_process_management (to create a new #m_process_t for example),
63    in \ref m_host_management (only the read-only functions i.e. whose
64    name contains the word get), in \ref m_task_management (to create
65    or destroy some #m_task_t for example) and in \ref
66    msg_gos_functions (to handle file transfers and task processing).
67  * \param data a pointer to any data one may want to attach to the new
68    object.  It is for user-level information and can be NULL. It can
69    be retrieved with the function \ref MSG_process_get_data.
70  * \param host the location where the new agent is executed.
71  * \param argc first argument passed to \a code
72  * \param argv second argument passed to \a code
73  * \see m_process_t
74  * \return The new corresponding object.
75  */
76 smx_process_t SIMIX_process_create_with_arguments(const char *name,
77                                               smx_process_code_t code, void *data,
78                                               smx_host_t host, int argc, char **argv)
79 {
80   simdata_process_t simdata = xbt_new0(s_simdata_process_t,1);
81   smx_process_t process = xbt_new0(s_smx_process_t,1);
82   smx_process_t self = NULL;
83
84   xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters");
85   /* Simulator Data */
86
87   simdata->host = host;
88   simdata->argc = argc;
89   simdata->argv = argv;
90   simdata->context = xbt_context_new(code, NULL, NULL, 
91                                      SIMIX_process_cleanup, process, 
92                                      simdata->argc, simdata->argv);
93
94   simdata->last_errno=SIMIX_OK;
95
96
97   /* Process structure */
98   process->name = xbt_strdup(name);
99   process->simdata = simdata;
100   process->data = data;
101
102   xbt_swag_insert_at_head(process, host->simdata->process_list);
103
104   /* *************** FIX du current_process !!! *************** */
105   self = simix_global->current_process;
106   xbt_context_start(process->simdata->context);
107   simix_global->current_process = self;
108
109   xbt_swag_insert_at_head(process,simix_global->process_list);
110   DEBUG2("Inserting %s(%s) in the to_run list",process->name,
111          host->name);
112   xbt_swag_insert_at_head(process,simix_global->process_to_run);
113
114   return process;
115 }
116
117 /** \ingroup m_process_management
118  * \param process poor victim
119  *
120  * This function simply kills a \a process... scarry isn't it ? :)
121  */
122 void SIMIX_process_kill(smx_process_t process)
123 {
124   //int i;
125   simdata_process_t p_simdata = process->simdata;
126   //simdata_host_t h_simdata= p_simdata->host->simdata;
127   //int _cursor;
128   //smx_process_t proc = NULL;
129
130   DEBUG2("Killing %s on %s",process->name, p_simdata->host->name);
131   
132   /*
133   
134   if(p_simdata->waiting_task) {
135     xbt_dynar_foreach(p_simdata->waiting_task->simdata->sleeping,_cursor,proc) {
136       if(proc==process) 
137         xbt_dynar_remove_at(p_simdata->waiting_task->simdata->sleeping,_cursor,&proc);
138     }
139     if(p_simdata->waiting_task->simdata->compute)
140       surf_workstation_resource->common_public->
141         action_free(p_simdata->waiting_task->simdata->compute);
142     else if (p_simdata->waiting_task->simdata->comm) {
143       surf_workstation_resource->common_public->
144         action_change_state(p_simdata->waiting_task->simdata->comm,SURF_ACTION_FAILED);
145       surf_workstation_resource->common_public->
146         action_free(p_simdata->waiting_task->simdata->comm);
147     } else {
148       xbt_die("UNKNOWN STATUS. Please report this bug.");
149     }
150   }
151
152   if ((i==msg_global->max_channel) && (process!=MSG_process_self()) && 
153       (!p_simdata->waiting_task)) {
154     xbt_die("UNKNOWN STATUS. Please report this bug.");
155   }
156 */
157   xbt_swag_remove(process,simix_global->process_to_run);
158   xbt_swag_remove(process,simix_global->process_list);
159   xbt_context_free(process->simdata->context);
160
161   if(process==SIMIX_process_self()) {
162     /* I just killed myself */
163     xbt_context_yield();
164   }
165 }
166
167 /** \ingroup m_process_management
168  * \brief Migrates an agent to another location.
169  *
170  * This functions checks whether \a process and \a host are valid pointers
171    and change the value of the #m_host_t on which \a process is running.
172  */
173 SIMIX_error_t SIMIX_process_change_host(smx_process_t process, smx_host_t host)
174 {
175   simdata_process_t simdata = NULL;
176
177   /* Sanity check */
178
179   xbt_assert0(((process) && (process->simdata)
180           && (host)), "Invalid parameters");
181   simdata = process->simdata;
182
183   xbt_swag_remove(process,simdata->host->simdata->process_list);
184   simdata->host = host;
185   xbt_swag_insert_at_head(process,host->simdata->process_list);
186
187   return SIMIX_OK;
188 }
189
190 /** \ingroup m_process_management
191  * \brief Return the user data of a #m_process_t.
192  *
193  * This functions checks whether \a process is a valid pointer or not 
194    and return the user data associated to \a process if it is possible.
195  */
196 void *SIMIX_process_get_data(smx_process_t process)
197 {
198   xbt_assert0((process != NULL), "Invalid parameters");
199
200   return (process->data);
201 }
202
203 /** \ingroup m_process_management
204  * \brief Set the user data of a #m_process_t.
205  *
206  * This functions checks whether \a process is a valid pointer or not 
207    and set the user data associated to \a process if it is possible.
208  */
209 SIMIX_error_t SIMIX_process_set_data(smx_process_t process,void *data)
210 {
211   xbt_assert0((process != NULL), "Invalid parameters");
212   xbt_assert0((process->data == NULL), "Data already set");
213   
214   process->data = data;
215    
216   return SIMIX_OK;
217 }
218
219 /** \ingroup m_process_management
220  * \brief Return the location on which an agent is running.
221  *
222  * This functions checks whether \a process is a valid pointer or not 
223    and return the m_host_t corresponding to the location on which \a 
224    process is running.
225  */
226 smx_host_t SIMIX_process_get_host(smx_process_t process)
227 {
228   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
229
230   return (((simdata_process_t) process->simdata)->host);
231 }
232
233 /** \ingroup m_process_management
234  * \brief Return the name of an agent.
235  *
236  * This functions checks whether \a process is a valid pointer or not 
237    and return its name.
238  */
239 const char *SIMIX_process_get_name(smx_process_t process)
240 {
241   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
242
243   return (process->name);
244 }
245
246 /** \ingroup m_process_management
247  * \brief Return the current agent.
248  *
249  * This functions returns the currently running #m_process_t.
250  */
251 smx_process_t SIMIX_process_self(void)
252 {
253   return simix_global ? simix_global->current_process : NULL;
254 }
255
256 /** \ingroup m_process_management
257  * \brief Suspend the process.
258  *
259  * This functions suspend the process by suspending the task on which
260  * it was waiting for the completion.
261  */
262 SIMIX_error_t SIMIX_process_suspend(smx_process_t process)
263 {
264 /*
265   simdata_process_t simdata = NULL;
266   simdata_task_t simdata_task = NULL;
267
268   XBT_IN2("(%p(%s))", process, process->name);
269
270   xbt_assert0(((process) && (process->simdata)), "Invalid parameters");
271
272   PAJE_PROCESS_PUSH_STATE(process,"S",NULL);
273
274   if(process!=SIMIX_process_self()) {
275     simdata = process->simdata;
276     
277     xbt_assert0(simdata->waiting_task,"Process not waiting for anything else. Weird !");
278
279     simdata_task = simdata->waiting_task->simdata;
280
281     simdata->suspended = 1;
282     if(simdata->blocked) {
283       XBT_OUT;
284       return SIMIX_OK;
285     }
286
287     xbt_assert0(((simdata_task->compute)||(simdata_task->comm))&&
288                 !((simdata_task->compute)&&(simdata_task->comm)),
289                 "Got a problem in deciding which action to choose !");
290     simdata->suspended = 1;
291     if(simdata_task->compute) 
292       surf_workstation_resource->common_public->suspend(simdata_task->compute);
293     else
294       surf_workstation_resource->common_public->suspend(simdata_task->comm);
295   } else {
296     m_task_t dummy = MSG_TASK_UNINITIALIZED;
297     dummy = MSG_task_create("suspended", 0.0, 0, NULL);
298
299     simdata = process->simdata;
300     simdata->suspended = 1;
301     __MSG_task_execute(process,dummy);
302     surf_workstation_resource->common_public->suspend(dummy->simdata->compute);
303     __MSG_wait_for_computation(process,dummy);
304     simdata->suspended = 0;
305
306     MSG_task_destroy(dummy);
307   }
308   XBT_OUT;
309   */
310   return SIMIX_OK;
311 }
312
313 /** \ingroup m_process_management
314  * \brief Resume a suspended process.
315  *
316  * This functions resume a suspended process by resuming the task on
317  * which it was waiting for the completion.
318  */
319 SIMIX_error_t SIMIX_process_resume(smx_process_t process)
320 {
321 /*
322   simdata_process_t simdata = NULL;
323   simdata_task_t simdata_task = NULL;
324
325   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
326   CHECK_HOST();
327
328   XBT_IN2("(%p(%s))", process, process->name);
329
330   if(process == SIMIX_process_self()) {
331     XBT_OUT;
332     SIMIX_RETURN(SIMIX_OK);
333   }
334
335   simdata = process->simdata;
336
337   if(simdata->blocked) {
338     PAJE_PROCESS_POP_STATE(process);
339
340     simdata->suspended = 0; *//* He'll wake up by itself */
341     /*XBT_OUT;
342     SIMIX_RETURN(SIMIX_OK);
343   }
344
345   if(!(simdata->waiting_task)) {
346     xbt_assert0(0,"Process not waiting for anything else. Weird !");
347     XBT_OUT;
348     return SIMIX_WARNING;
349   }
350   simdata_task = simdata->waiting_task->simdata;
351
352
353   if(simdata_task->compute) {
354     surf_workstation_resource->common_public->resume(simdata_task->compute);
355     PAJE_PROCESS_POP_STATE(process);
356   }
357   else {
358     PAJE_PROCESS_POP_STATE(process);
359     surf_workstation_resource->common_public->resume(simdata_task->comm);
360   }
361
362   XBT_OUT;
363   */
364   SIMIX_RETURN(SIMIX_OK);
365 }
366
367 /** \ingroup m_process_management
368  * \brief Returns true if the process is suspended .
369  *
370  * This checks whether a process is suspended or not by inspecting the
371  * task on which it was waiting for the completion.
372  */
373 int SIMIX_process_is_suspended(smx_process_t process)
374 {
375   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
376
377   return (process->simdata->suspended);
378 }
379
380 int __SIMIX_process_block(double max_duration, const char *info)
381 {
382 /*
383   smx_process_t process = SIMIX_process_self();
384   m_task_t dummy = SIMIX_TASK_UNINITIALIZED;
385   char blocked_name[512];
386   snprintf(blocked_name,512,"blocked [%s] (%s:%s)",
387           info, process->name, process->simdata->host->name);
388
389   XBT_IN1(": max_duration=%g",max_duration);
390
391   dummy = MSG_task_create(blocked_name, 0.0, 0, NULL);
392   
393   PAJE_PROCESS_PUSH_STATE(process,"B",NULL);
394
395   process->simdata->blocked=1;
396   __MSG_task_execute(process,dummy);
397   surf_workstation_resource->common_public->suspend(dummy->simdata->compute);
398   if(max_duration>=0)
399     surf_workstation_resource->common_public->set_max_duration(dummy->simdata->compute, 
400                                                                max_duration);
401   __MSG_wait_for_computation(process,dummy);
402   MSG_task_destroy(dummy);
403   process->simdata->blocked=0;
404
405   if(process->simdata->suspended) {
406     DEBUG0("I've been suspended in the meantime");    
407     SIMIX_process_suspend(process);
408     DEBUG0("I've been resumed, let's keep going");    
409   }
410
411   PAJE_PROCESS_POP_STATE(process);
412
413   XBT_OUT;
414   */
415   return 1;
416 }
417
418 SIMIX_error_t __SIMIX_process_unblock(smx_process_t process)
419 {
420 /*
421   simdata_process_t simdata = NULL;
422   simdata_task_t simdata_task = NULL;
423
424   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
425   CHECK_HOST();
426
427   XBT_IN2(": %s unblocking %s", SIMIX_process_self()->name,process->name);
428
429   simdata = process->simdata;
430   if(!(simdata->waiting_task)) {
431     xbt_assert0(0,"Process not waiting for anything else. Weird !");
432     XBT_OUT;
433     return SIMIX_WARNING;
434   }
435   simdata_task = simdata->waiting_task->simdata;
436
437   xbt_assert0(simdata->blocked,"Process not blocked");
438
439   surf_workstation_resource->common_public->resume(simdata_task->compute);
440
441   XBT_OUT;
442 */
443   SIMIX_RETURN(SIMIX_OK);
444 }
445
446 int __SIMIX_process_isBlocked(smx_process_t process)
447 {
448   xbt_assert0(((process != NULL) && (process->simdata)), "Invalid parameters");
449
450   return (process->simdata->blocked);
451 }