Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
a6fcd8db71af1463562c66fd34fd5b45406f4a77
[simgrid.git] / src / surf / surf.c
1 /*      $Id$     */
2
3 /* Copyright (c) 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 <ctype.h>
9
10 #include "surf_private.h"
11 #include "xbt/module.h"
12
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
14                                 "Logging specific to SURF (kernel)");
15
16 int use_sdp_solver = 0;
17 int use_lagrange_solver = 0;
18
19 /* Additional declarations for Windows potability. */
20
21 #ifndef MAX_DRIVE
22 #define MAX_DRIVE 26
23 #endif
24
25 #ifdef _WIN32
26 #include <windows.h>
27 static const char *disk_drives_letter_table[MAX_DRIVE] = {
28   "A:\\",
29   "B:\\",
30   "C:\\",
31   "D:\\",
32   "E:\\",
33   "F:\\",
34   "G:\\",
35   "H:\\",
36   "I:\\",
37   "J:\\",
38   "K:\\",
39   "L:\\",
40   "M:\\",
41   "N:\\",
42   "O:\\",
43   "P:\\",
44   "Q:\\",
45   "R:\\",
46   "S:\\",
47   "T:\\",
48   "U:\\",
49   "V:\\",
50   "W:\\",
51   "X:\\",
52   "Y:\\",
53   "Z:\\"
54 };
55 #endif /* #ifdef _WIN32 */
56
57 /*
58  * Returns the initial path. On Windows the initial path is
59  * the current directory for the current process in the other
60  * case the function returns "./" that represents the current
61  * directory on Unix/Linux platforms.
62  */
63
64 const char *__surf_get_initial_path(void)
65 {
66
67 #ifdef _WIN32
68   unsigned i;
69   char current_directory[MAX_PATH + 1] = { 0 };
70   unsigned int len = GetCurrentDirectory(MAX_PATH + 1, current_directory);
71   char root[4] = { 0 };
72
73   if (!len)
74     return NULL;
75
76   strncpy(root, current_directory, 3);
77
78   for (i = 0; i < MAX_DRIVE; i++) {
79     if (toupper(root[0]) == disk_drives_letter_table[i][0])
80       return disk_drives_letter_table[i];
81   }
82
83   return NULL;
84 #else
85   return "./";
86 #endif
87 }
88
89 /* The __surf_is_absolute_file_path() returns 1 if
90  * file_path is a absolute file path, in the other
91  * case the function returns 0.
92  */
93 int __surf_is_absolute_file_path(const char *file_path)
94 {
95 #ifdef _WIN32
96   WIN32_FIND_DATA wfd = { 0 };
97   HANDLE hFile = FindFirstFile(file_path, &wfd);
98
99   if (INVALID_HANDLE_VALUE == hFile)
100     return 0;
101
102   FindClose(hFile);
103   return 1;
104 #else
105   return (file_path[0] == '/');
106 #endif
107 }
108
109 typedef struct surf_model_object {
110   surf_model_t model;
111 } s_surf_model_object_t, *surf_model_object_t;
112
113 static double NOW = 0;
114
115 xbt_dynar_t model_list = NULL;
116 tmgr_history_t history = NULL;
117 lmm_system_t maxmin_system = NULL;
118 xbt_dynar_t surf_path = NULL;
119 const char *surf_action_state_names[6] = {
120   "SURF_ACTION_READY",
121   "SURF_ACTION_RUNNING",
122   "SURF_ACTION_FAILED",
123   "SURF_ACTION_DONE",
124   "SURF_ACTION_TO_FREE",
125   "SURF_ACTION_NOT_IN_THE_SYSTEM"
126 };
127
128 /* Don't forget to update the option description in smx_config when you change this */
129 s_surf_model_description_t surf_network_model_description[] = {
130   {"Constant", NULL, surf_network_model_init_Constant},
131   {"CM02", NULL, surf_network_model_init_CM02},
132   {"LegrandVelho", NULL, surf_network_model_init_LegrandVelho},
133 #ifdef HAVE_GTNETS
134   {"GTNets", NULL, surf_network_model_init_GTNETS},
135 #endif
136 #ifdef HAVE_SDP
137   {"SDP", NULL, surf_network_model_init_SDP},
138 #endif
139   {"Reno", NULL, surf_network_model_init_Reno},
140   {"Reno2", NULL, surf_network_model_init_Reno2},
141   {"Vegas", NULL, surf_network_model_init_Vegas},
142   {NULL, NULL, NULL}            /* this array must be NULL terminated */
143 };
144
145 s_surf_model_description_t surf_cpu_model_description[] = {
146   {"Cas01", NULL, surf_cpu_model_init_Cas01},
147   {NULL, NULL, NULL}            /* this array must be NULL terminated */
148 };
149
150 s_surf_model_description_t surf_workstation_model_description[] = {
151   {"CLM03", NULL, surf_workstation_model_init_CLM03, create_workstations},
152   {"compound", NULL, surf_workstation_model_init_compound,
153    create_workstations},
154   {"ptask_L07", NULL, surf_workstation_model_init_ptask_L07, NULL},
155   {NULL, NULL, NULL}            /* this array must be NULL terminated */
156 };
157
158 void update_model_description(s_surf_model_description_t * table,
159                               const char *name, surf_model_t model)
160 {
161   int i = find_model_description(table, name);
162   table[i].model = model;
163 }
164
165 int find_model_description(s_surf_model_description_t * table,
166                            const char *name)
167 {
168   int i;
169   char *name_list = NULL;
170
171   for (i = 0; table[i].name; i++)
172     if (!strcmp(name, table[i].name)) {
173       return i;
174     }
175   name_list = strdup(table[0].name);
176   for (i = 1; table[i].name; i++) {
177     name_list =
178       xbt_realloc(name_list, strlen(name_list) + strlen(table[i].name) + 2);
179     strcat(name_list, ", ");
180     strcat(name_list, table[i].name);
181   }
182   xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.", name,
183               name_list);
184 }
185
186 double generic_maxmin_share_resources(xbt_swag_t running_actions,
187                                       size_t offset,
188                                       lmm_system_t sys,
189                                       void (*solve) (lmm_system_t))
190 {
191   surf_action_t action = NULL;
192   double min = -1;
193   double value = -1;
194 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset))))
195
196   xbt_assert0(solve, "Give me a real solver function!");
197   solve(sys);
198
199   xbt_swag_foreach(action, running_actions) {
200     value = lmm_variable_getvalue(VARIABLE(action));
201     if ((value > 0) || (action->max_duration >= 0))
202       break;
203   }
204
205   if (!action)
206     return -1.0;
207
208   if (value > 0) {
209     if (action->remains > 0)
210       min = action->remains / value;
211     else
212       min = 0.0;
213     if ((action->max_duration >= 0) && (action->max_duration < min))
214       min = action->max_duration;
215   } else
216     min = action->max_duration;
217
218
219   for (action = xbt_swag_getNext(action, running_actions->offset);
220        action; action = xbt_swag_getNext(action, running_actions->offset)) {
221     value = lmm_variable_getvalue(VARIABLE(action));
222     if (value > 0) {
223       if (action->remains > 0)
224         value = action->remains / value;
225       else
226         value = 0.0;
227       if (value < min) {
228         min = value;
229         DEBUG2("Updating min (value) with %p: %f", action, min);
230       }
231     }
232     if ((action->max_duration >= 0) && (action->max_duration < min)) {
233       min = action->max_duration;
234       DEBUG2("Updating min (duration) with %p: %f", action, min);
235     }
236   }
237   DEBUG1("min value : %f", min);
238
239 #undef VARIABLE
240   return min;
241 }
242
243 e_surf_action_state_t surf_action_get_state(surf_action_t action)
244 {
245   surf_action_state_t action_state =
246     &(action->model_type->common_public->states);
247
248   if (action->state_set == action_state->ready_action_set)
249     return SURF_ACTION_READY;
250   if (action->state_set == action_state->running_action_set)
251     return SURF_ACTION_RUNNING;
252   if (action->state_set == action_state->failed_action_set)
253     return SURF_ACTION_FAILED;
254   if (action->state_set == action_state->done_action_set)
255     return SURF_ACTION_DONE;
256   return SURF_ACTION_NOT_IN_THE_SYSTEM;
257 }
258
259 double surf_action_get_start_time(surf_action_t action)
260 {
261   return action->start;
262 }
263
264 double surf_action_get_finish_time(surf_action_t action)
265 {
266   return action->finish;
267 }
268
269 void surf_action_free(surf_action_t * action)
270 {
271   (*action)->model_type->common_public->action_cancel(*action);
272   free(*action);
273   *action = NULL;
274 }
275
276 void surf_action_change_state(surf_action_t action,
277                               e_surf_action_state_t state)
278 {
279   surf_action_state_t action_state =
280     &(action->model_type->common_public->states);
281   XBT_IN2("(%p,%s)", action, surf_action_state_names[state]);
282   xbt_swag_remove(action, action->state_set);
283
284   if (state == SURF_ACTION_READY)
285     action->state_set = action_state->ready_action_set;
286   else if (state == SURF_ACTION_RUNNING)
287     action->state_set = action_state->running_action_set;
288   else if (state == SURF_ACTION_FAILED)
289     action->state_set = action_state->failed_action_set;
290   else if (state == SURF_ACTION_DONE)
291     action->state_set = action_state->done_action_set;
292   else
293     action->state_set = NULL;
294
295   if (action->state_set)
296     xbt_swag_insert(action, action->state_set);
297   XBT_OUT;
298 }
299
300 void surf_action_set_data(surf_action_t action, void *data)
301 {
302   action->data = data;
303 }
304
305 XBT_LOG_EXTERNAL_CATEGORY(surf_cpu);
306 XBT_LOG_EXTERNAL_CATEGORY(surf_kernel);
307 XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange);
308 XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange_dichotomy);
309 XBT_LOG_EXTERNAL_CATEGORY(surf_maxmin);
310 XBT_LOG_EXTERNAL_CATEGORY(surf_network);
311 XBT_LOG_EXTERNAL_CATEGORY(surf_parse);
312 XBT_LOG_EXTERNAL_CATEGORY(surf_timer);
313 XBT_LOG_EXTERNAL_CATEGORY(surf_workstation);
314 XBT_LOG_EXTERNAL_CATEGORY(surf_config);
315
316
317 #ifdef HAVE_SDP
318 XBT_LOG_EXTERNAL_CATEGORY(surf_sdp_out);
319 XBT_LOG_EXTERNAL_CATEGORY(surf_sdp);
320 #endif
321 #ifdef HAVE_GTNETS
322 XBT_LOG_EXTERNAL_CATEGORY(surf_network_gtnets);
323 #endif
324
325 void surf_init(int *argc, char **argv)
326 {
327   int i, j;
328   char *opt;
329
330   const char *initial_path;
331
332   /* Connect our log channels: that must be done manually under windows */
333   XBT_LOG_CONNECT(surf_cpu, surf);
334   XBT_LOG_CONNECT(surf_kernel, surf);
335   XBT_LOG_CONNECT(surf_lagrange, surf);
336   XBT_LOG_CONNECT(surf_lagrange_dichotomy, surf_lagrange);
337   XBT_LOG_CONNECT(surf_maxmin, surf);
338   XBT_LOG_CONNECT(surf_network, surf);
339   XBT_LOG_CONNECT(surf_parse, surf);
340   XBT_LOG_CONNECT(surf_timer, surf);
341   XBT_LOG_CONNECT(surf_workstation, surf);
342   XBT_LOG_CONNECT(surf_config, surf);
343
344 #ifdef HAVE_SDP
345   XBT_LOG_CONNECT(surf_sdp_out, surf);
346   XBT_LOG_CONNECT(surf_sdp, surf);
347 #endif
348 #ifdef HAVE_GTNETS
349   XBT_LOG_CONNECT(surf_network_gtnets, surf);
350 #endif
351
352   xbt_init(argc, argv);
353   if (!surf_path) {
354
355     /* retrieves the current directory of the current process */
356     initial_path = __surf_get_initial_path();
357
358     xbt_assert0((initial_path),
359                 "__surf_get_initial_path() failed! Can't resolves current Windows directory");
360
361     surf_path = xbt_dynar_new(sizeof(char *), NULL);
362     xbt_dynar_push(surf_path, &initial_path);
363
364     for (i = 1; i < *argc; i++) {
365       if (!strncmp(argv[i], "--surf-path=", strlen("--surf-path="))) {
366         opt = strchr(argv[i], '=');
367         opt++;
368         xbt_dynar_push(surf_path, &opt);
369         /*remove this from argv */
370         for (j = i + 1; j < *argc; j++) {
371           argv[j - 1] = argv[j];
372         }
373         argv[j - 1] = NULL;
374         (*argc)--;
375         i--;                    /* compensate effect of next loop incrementation */
376       }
377     }
378   }
379   if (!model_list)
380     model_list = xbt_dynar_new(sizeof(surf_model_private_t), NULL);
381   if (!history)
382     history = tmgr_history_new();
383
384   surf_config_init(argc,argv);
385 }
386
387 static char *path_name = NULL;
388 FILE *surf_fopen(const char *name, const char *mode)
389 {
390   unsigned int iter;
391   char *path = NULL;
392   FILE *file = NULL;
393   unsigned int path_name_len = 0;       /* don't count '\0' */
394
395   xbt_assert0(name, "Need a non-NULL file name");
396
397   xbt_assert0(surf_path,
398               "surf_init has to be called before using surf_fopen");
399
400   if (__surf_is_absolute_file_path(name)) {     /* don't mess with absolute file names */
401     return fopen(name, mode);
402
403   } else {                      /* search relative files in the path */
404
405     if (!path_name) {
406       path_name_len = strlen(name);
407       path_name = xbt_new0(char, path_name_len + 1);
408     }
409
410     xbt_dynar_foreach(surf_path, iter, path) {
411       if (path_name_len < strlen(path) + strlen(name) + 1) {
412         path_name_len = strlen(path) + strlen(name) + 1;        /* plus '/' */
413         path_name = xbt_realloc(path_name, path_name_len + 1);
414       }
415 #ifdef WIN32
416       sprintf(path_name, "%s\\%s", path, name);
417 #else
418       sprintf(path_name, "%s/%s", path, name);
419 #endif
420       file = fopen(path_name, mode);
421       if (file)
422         return file;
423     }
424   }
425   return file;
426 }
427
428 void surf_exit(void)
429 {
430   unsigned int iter;
431   surf_model_t model = NULL;
432
433   surf_config_finalize();
434
435   xbt_dynar_foreach(model_list, iter, model) {
436     model->common_private->finalize();
437   }
438
439   if (maxmin_system) {
440     lmm_system_free(maxmin_system);
441     maxmin_system = NULL;
442   }
443   if (history) {
444     tmgr_history_free(history);
445     history = NULL;
446   }
447   if (model_list)
448     xbt_dynar_free(&model_list);
449
450   if (surf_path)
451     xbt_dynar_free(&surf_path);
452
453   tmgr_finalize();
454   surf_parse_lex_destroy();
455   if (path_name) {
456     free(path_name);
457     path_name = NULL;
458   }
459   surf_parse_free_callbacks();
460   xbt_dict_free(&route_table);
461   NOW = 0;                      /* Just in case the user plans to restart the simulation afterward */
462   xbt_exit();
463 }
464
465 void surf_presolve(void)
466 {
467   double next_event_date = -1.0;
468   tmgr_trace_event_t event = NULL;
469   double value = -1.0;
470   surf_model_object_t model_obj = NULL;
471   surf_model_t model = NULL;
472   unsigned int iter;
473
474   DEBUG0
475     ("First Run! Let's \"purge\" events and put models in the right state");
476   while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
477     if (next_event_date > NOW)
478       break;
479     while ((event =
480             tmgr_history_get_next_event_leq(history, next_event_date,
481                                             &value, (void **) &model_obj))) {
482       model_obj->model->common_private->update_resource_state(model_obj,
483                                                               event, value,
484                                                               NOW);
485     }
486   }
487   xbt_dynar_foreach(model_list, iter, model) {
488     model->common_private->update_actions_state(NOW, 0.0);
489   }
490 }
491
492 double surf_solve(void)
493 {
494   double min = -1.0;
495   double next_event_date = -1.0;
496   double model_next_action_end = -1.0;
497   double value = -1.0;
498   surf_model_object_t model_obj = NULL;
499   surf_model_t model = NULL;
500   tmgr_trace_event_t event = NULL;
501   unsigned int iter;
502
503   min = -1.0;
504
505   DEBUG0("Looking for next action end");
506   xbt_dynar_foreach(model_list, iter, model) {
507     DEBUG1("Running for Resource [%s]", model->common_public->name);
508     model_next_action_end = model->common_private->share_resources(NOW);
509     DEBUG2("Resource [%s] : next action end = %f",
510            model->common_public->name, model_next_action_end);
511     if (((min < 0.0) || (model_next_action_end < min))
512         && (model_next_action_end >= 0.0))
513       min = model_next_action_end;
514   }
515   DEBUG1("Next action end : %f", min);
516
517   if (min < 0.0)
518     return -1.0;
519
520   DEBUG0("Looking for next event");
521   while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
522     DEBUG1("Next event : %f", next_event_date);
523     if (next_event_date > NOW + min)
524       break;
525     DEBUG0("Updating models");
526     while ((event =
527             tmgr_history_get_next_event_leq(history, next_event_date,
528                                             &value, (void **) &model_obj))) {
529       if (model_obj->model->common_private->resource_used(model_obj)) {
530         min = next_event_date - NOW;
531         DEBUG1
532           ("This event will modify model state. Next event set to %f", min);
533       }
534       /* update state of model_obj according to new value. Does not touch lmm.
535          It will be modified if needed when updating actions */
536       model_obj->model->common_private->update_resource_state(model_obj,
537                                                               event, value,
538                                                               NOW + min);
539     }
540   }
541
542   DEBUG1("Duration set to %f", min);
543
544   NOW = NOW + min;
545
546   xbt_dynar_foreach(model_list, iter, model) {
547     model->common_private->update_actions_state(NOW, min);
548   }
549
550   return min;
551 }
552
553 double surf_get_clock(void)
554 {
555   return NOW;
556 }