Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Forgot to remove some debug information
[simgrid.git] / src / simdag / sd_global.c
1 #include "private.h"
2 #include "xbt/sysdep.h"
3 #include "xbt/dynar.h"
4 #include "surf/surf.h"
5
6 XBT_LOG_NEW_CATEGORY(sd,"Logging specific to SimDag");
7 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_kernel,sd,
8                                 "Logging specific to SimDag (kernel)");
9
10 SD_global_t sd_global = NULL;
11
12 /**
13  * \brief Initialises SD internal data
14  *
15  * This function must be called before any other SD function. Then you
16  * should call SD_create_environment().
17  *
18  * \param argc argument number
19  * \param argv argument list
20  * \see SD_create_environment(), SD_exit()
21  */
22 void SD_init(int *argc, char **argv) {
23   xbt_assert0(sd_global == NULL, "SD_init already called");
24
25   sd_global = xbt_new0(s_SD_global_t, 1);
26   sd_global->workstations = xbt_dict_new();
27   sd_global->workstation_count = 0;
28   sd_global->links = xbt_dict_new();
29   sd_global->watch_point_reached = 0;
30
31   s_SD_task_t task;
32   sd_global->not_scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
33   sd_global->scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
34   sd_global->ready_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
35   sd_global->running_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
36   sd_global->done_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
37   sd_global->failed_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));
38
39   surf_init(argc, argv);
40 }
41
42 /**
43  * \brief Creates the environment
44  *
45  * The environment (i.e. the \ref SD_workstation_management "workstations" and the
46  * \ref SD_link_management "links") is created with the data stored in the given XML
47  * platform file.
48  *
49  * \param platform_file name of an XML file describing the environment to create
50  * \see SD_workstation_management, SD_link_management
51  *
52  * The XML file follows this DTD:
53  *
54  *     \include surfxml.dtd
55  *
56  * Here is a small example of such a platform: 
57  *
58  *     \include small_platform.xml
59  */
60 void SD_create_environment(const char *platform_file) {
61   xbt_dict_cursor_t cursor = NULL;
62   char *name = NULL;
63   void *surf_workstation = NULL;
64   void *surf_link = NULL;
65
66   SD_CHECK_INIT_DONE();
67
68   surf_timer_resource_init(platform_file);  /* tell Surf to create the environnement */
69
70   
71   /*printf("surf_workstation_resource = %p, workstation_set = %p\n", surf_workstation_resource, workstation_set);
72     printf("surf_network_resource = %p, network_link_set = %p\n", surf_network_resource, network_link_set);*/
73
74   /*surf_workstation_resource_init_KCCFLN05(platform_file);*/
75   surf_workstation_resource_init_CLM03(platform_file);
76
77   /*printf("surf_workstation_resource = %p, workstation_set = %p\n", surf_workstation_resource, workstation_set);
78     printf("surf_network_resource = %p, network_link_set = %p\n", surf_network_resource, network_link_set);*/
79
80
81   /* now let's create the SD wrappers for workstations and links */
82   xbt_dict_foreach(workstation_set, cursor, name, surf_workstation) {
83     __SD_workstation_create(surf_workstation, NULL);
84   }
85
86   xbt_dict_foreach(network_link_set, cursor, name, surf_link) {
87     __SD_link_create(surf_link, NULL);
88   }
89 }
90
91 /**
92  * \brief Launches the simulation.
93  *
94  * The function will execute the \ref SD_READY ready tasks.
95  * The simulation will be stopped when its time reaches \a how_long,
96  * when a watch point is reached, or when no more task can be executed.
97  * Then you can call SD_simulate() again.
98  * 
99  * \param how_long maximum duration of the simulation
100  * \return a NULL-terminated array of \ref SD_task_t whose state has changed.
101  * \see SD_task_schedule(), SD_task_watch()
102  */
103 SD_task_t* SD_simulate(double how_long)
104 {
105   double total_time = 0.0; /* we stop the simulation when total_time >= how_long */
106   double elapsed_time = 0.0;
107   SD_task_t task, dst;
108   SD_dependency_t dependency;
109   surf_action_t action;
110   SD_task_t *changed_tasks = NULL;
111   int changed_task_number = 0;
112   int changed_task_capacity = 16; /* will be increased if necessary */
113   int i;
114   static int first_time = 1;
115
116   INFO0("Starting simulation...");
117
118   /* create the array that will be returned */
119   changed_tasks = xbt_new0(SD_task_t, changed_task_capacity);
120   changed_tasks[0] = NULL;
121
122   if (first_time) {
123     surf_solve(); /* Takes traces into account. Returns 0.0 */
124     first_time = 0;
125   }
126
127   sd_global->watch_point_reached = 0;
128
129   /* explore the ready tasks */
130   xbt_swag_foreach(task, sd_global->ready_task_set) {
131     INFO1("Executing task '%s'", SD_task_get_name(task));
132     action = __SD_task_run(task);
133     surf_workstation_resource->common_public->action_set_data(action, task);
134     task->state_changed = 1;
135     
136     changed_tasks[changed_task_number++] = task; /* replace NULL by the task */
137     if (changed_task_number == changed_task_capacity) {
138       changed_task_capacity *= 2;
139       changed_tasks = xbt_realloc(changed_tasks, sizeof(SD_task_t) * changed_task_capacity);
140     }
141     changed_tasks[changed_task_number] = NULL;
142   }
143
144   /* main loop */
145   elapsed_time = 0.0;
146   while (elapsed_time >= 0.0 && total_time < how_long && !sd_global->watch_point_reached) {
147
148     elapsed_time = surf_solve();
149     if (elapsed_time > 0.0)
150       total_time += elapsed_time;
151
152     /* let's see which tasks are done */
153     while ((action = xbt_swag_extract(surf_workstation_resource->common_public->states.done_action_set))) {
154       task = action->data;
155       INFO1("Task '%s' done", SD_task_get_name(task));
156       __SD_task_set_state(task, SD_DONE);
157
158       /* the state has changed */
159       if (!task->state_changed) {
160         task->state_changed = 1;
161         changed_tasks[changed_task_number++] = task;
162         if (changed_task_number == changed_task_capacity) {
163           changed_task_capacity *= 2;
164           changed_tasks = xbt_realloc(changed_tasks, sizeof(SD_task_t) * changed_task_capacity);
165         }
166         changed_tasks[changed_task_number] = NULL;
167       }
168
169       /* remove the dependencies after this task */
170       while (xbt_dynar_length(task->tasks_after) > 0) {
171         xbt_dynar_get_cpy(task->tasks_after, 0, &dependency);
172         dst = dependency->dst;
173         SD_task_dependency_remove(task, dst);
174         
175         /* is dst ready now? */
176         if (__SD_task_is_ready(dst) && !sd_global->watch_point_reached) {
177           INFO1("Executing task '%s'", SD_task_get_name(dst));
178           action = __SD_task_run(dst);
179           surf_workstation_resource->common_public->action_set_data(action, dst);
180           dst->state_changed = 1;
181           
182           changed_tasks[changed_task_number++] = dst;
183           if (changed_task_number == changed_task_capacity) {
184             changed_task_capacity *= 2;
185             changed_tasks = xbt_realloc(changed_tasks, sizeof(SD_task_t) * changed_task_capacity);
186           }
187           changed_tasks[changed_task_number] = NULL;
188         }
189       }
190     }
191
192     /* let's see which tasks have just failed */
193     while ((action = xbt_swag_extract(surf_workstation_resource->common_public->states.failed_action_set))) {
194       task = action->data;
195       INFO1("Task '%s' failed", SD_task_get_name(task));
196       __SD_task_set_state(task, SD_FAILED);
197       if (!task->state_changed) {
198         task->state_changed = 1;
199         changed_tasks[changed_task_number++] = task;
200         if (changed_task_number == changed_task_capacity) {
201           changed_task_capacity *= 2;
202           changed_tasks = xbt_realloc(changed_tasks, sizeof(SD_task_t) * changed_task_capacity);
203         }
204         changed_tasks[changed_task_number] = NULL;
205       }
206     }
207   }
208
209   /* we must reset every task->state_changed */
210   i = 0;
211   while (changed_tasks[i] != NULL) {
212     changed_tasks[i]->state_changed = 0;
213     i++;
214   }
215
216   INFO0("Simulation finished");
217   /*  printf("elapsed_time = %f, total_time = %f, watch_point_reached = %d\n", elapsed_time, total_time, sd_global->watch_point_reached);*/
218
219   return changed_tasks;
220 }
221
222 /**
223  * \brief Destroys all SD internal data.
224  *
225  * This function should be called when the simulation is over. Don't forget also to destroy
226  * the tasks.
227  *
228  * \see SD_init(), SD_task_destroy()
229  */
230 void SD_exit(void) {
231   if (sd_global != NULL) {
232     xbt_dict_free(&sd_global->workstations);
233     xbt_dict_free(&sd_global->links);
234     xbt_free(sd_global);
235
236     xbt_swag_free(sd_global->not_scheduled_task_set);
237     xbt_swag_free(sd_global->scheduled_task_set);
238     xbt_swag_free(sd_global->ready_task_set);
239     xbt_swag_free(sd_global->running_task_set);
240     xbt_swag_free(sd_global->done_task_set);
241     xbt_swag_free(sd_global->failed_task_set);
242
243     surf_exit();
244   }
245 }