Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Move surf_action related function to a specific file
[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 static double NOW = 0;
110
111 xbt_dynar_t model_list = NULL;
112 tmgr_history_t history = NULL;
113 lmm_system_t maxmin_system = NULL;
114 xbt_dynar_t surf_path = NULL;
115
116 /* Don't forget to update the option description in smx_config when you change this */
117 s_surf_model_description_t surf_network_model_description[] = {
118   {"Constant", NULL, surf_network_model_init_Constant},
119   {"CM02", NULL, surf_network_model_init_CM02},
120   {"LegrandVelho", NULL, surf_network_model_init_LegrandVelho},
121 #ifdef HAVE_GTNETS
122   {"GTNets", NULL, surf_network_model_init_GTNETS},
123 #endif
124 #ifdef HAVE_SDP
125   {"SDP", NULL, surf_network_model_init_SDP},
126 #endif
127   {"Reno", NULL, surf_network_model_init_Reno},
128   {"Reno2", NULL, surf_network_model_init_Reno2},
129   {"Vegas", NULL, surf_network_model_init_Vegas},
130   {NULL, NULL, NULL}            /* this array must be NULL terminated */
131 };
132
133 s_surf_model_description_t surf_cpu_model_description[] = {
134   {"Cas01", NULL, surf_cpu_model_init_Cas01},
135   {NULL, NULL, NULL}            /* this array must be NULL terminated */
136 };
137
138 s_surf_model_description_t surf_workstation_model_description[] = {
139   {"CLM03", NULL, surf_workstation_model_init_CLM03, create_workstations},
140   {"compound", NULL, surf_workstation_model_init_compound,
141    create_workstations},
142   {"ptask_L07", NULL, surf_workstation_model_init_ptask_L07, NULL},
143   {NULL, NULL, NULL}            /* this array must be NULL terminated */
144 };
145
146 void update_model_description(s_surf_model_description_t * table,
147                               const char *name, surf_model_t model)
148 {
149   int i = find_model_description(table, name);
150   table[i].model = model;
151 }
152
153 int find_model_description(s_surf_model_description_t * table,
154                            const char *name)
155 {
156   int i;
157   char *name_list = NULL;
158
159   for (i = 0; table[i].name; i++)
160     if (!strcmp(name, table[i].name)) {
161       return i;
162     }
163   name_list = strdup(table[0].name);
164   for (i = 1; table[i].name; i++) {
165     name_list =
166       xbt_realloc(name_list, strlen(name_list) + strlen(table[i].name) + 2);
167     strcat(name_list, ", ");
168     strcat(name_list, table[i].name);
169   }
170   xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.", name,
171               name_list);
172 }
173
174 double generic_maxmin_share_resources(xbt_swag_t running_actions,
175                                       size_t offset,
176                                       lmm_system_t sys,
177                                       void (*solve) (lmm_system_t))
178 {
179   surf_action_t action = NULL;
180   double min = -1;
181   double value = -1;
182 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset))))
183
184   xbt_assert0(solve, "Give me a real solver function!");
185   solve(sys);
186
187   xbt_swag_foreach(action, running_actions) {
188     value = lmm_variable_getvalue(VARIABLE(action));
189     if ((value > 0) || (action->max_duration >= 0))
190       break;
191   }
192
193   if (!action)
194     return -1.0;
195
196   if (value > 0) {
197     if (action->remains > 0)
198       min = action->remains / value;
199     else
200       min = 0.0;
201     if ((action->max_duration >= 0) && (action->max_duration < min))
202       min = action->max_duration;
203   } else
204     min = action->max_duration;
205
206
207   for (action = xbt_swag_getNext(action, running_actions->offset);
208        action; action = xbt_swag_getNext(action, running_actions->offset)) {
209     value = lmm_variable_getvalue(VARIABLE(action));
210     if (value > 0) {
211       if (action->remains > 0)
212         value = action->remains / value;
213       else
214         value = 0.0;
215       if (value < min) {
216         min = value;
217         DEBUG2("Updating min (value) with %p: %f", action, min);
218       }
219     }
220     if ((action->max_duration >= 0) && (action->max_duration < min)) {
221       min = action->max_duration;
222       DEBUG2("Updating min (duration) with %p: %f", action, min);
223     }
224   }
225   DEBUG1("min value : %f", min);
226
227 #undef VARIABLE
228   return min;
229 }
230
231
232 XBT_LOG_EXTERNAL_CATEGORY(surf_cpu);
233 XBT_LOG_EXTERNAL_CATEGORY(surf_kernel);
234 XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange);
235 XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange_dichotomy);
236 XBT_LOG_EXTERNAL_CATEGORY(surf_maxmin);
237 XBT_LOG_EXTERNAL_CATEGORY(surf_network);
238 XBT_LOG_EXTERNAL_CATEGORY(surf_parse);
239 XBT_LOG_EXTERNAL_CATEGORY(surf_timer);
240 XBT_LOG_EXTERNAL_CATEGORY(surf_workstation);
241 XBT_LOG_EXTERNAL_CATEGORY(surf_config);
242
243
244 #ifdef HAVE_SDP
245 XBT_LOG_EXTERNAL_CATEGORY(surf_sdp_out);
246 XBT_LOG_EXTERNAL_CATEGORY(surf_sdp);
247 #endif
248 #ifdef HAVE_GTNETS
249 XBT_LOG_EXTERNAL_CATEGORY(surf_network_gtnets);
250 #endif
251
252 void surf_init(int *argc, char **argv)
253 {
254   /* Connect our log channels: that must be done manually under windows */
255   XBT_LOG_CONNECT(surf_cpu, surf);
256   XBT_LOG_CONNECT(surf_kernel, surf);
257   XBT_LOG_CONNECT(surf_lagrange, surf);
258   XBT_LOG_CONNECT(surf_lagrange_dichotomy, surf_lagrange);
259   XBT_LOG_CONNECT(surf_maxmin, surf);
260   XBT_LOG_CONNECT(surf_network, surf);
261   XBT_LOG_CONNECT(surf_parse, surf);
262   XBT_LOG_CONNECT(surf_timer, surf);
263   XBT_LOG_CONNECT(surf_workstation, surf);
264   XBT_LOG_CONNECT(surf_config, surf);
265
266 #ifdef HAVE_SDP
267   XBT_LOG_CONNECT(surf_sdp_out, surf);
268   XBT_LOG_CONNECT(surf_sdp, surf);
269 #endif
270 #ifdef HAVE_GTNETS
271   XBT_LOG_CONNECT(surf_network_gtnets, surf);
272 #endif
273
274   xbt_init(argc, argv);
275   if (!model_list)
276     model_list = xbt_dynar_new(sizeof(surf_model_private_t), NULL);
277   if (!history)
278     history = tmgr_history_new();
279
280   surf_config_init(argc, argv);
281 }
282
283 static char *path_name = NULL;
284 FILE *surf_fopen(const char *name, const char *mode)
285 {
286   unsigned int iter;
287   char *path = NULL;
288   FILE *file = NULL;
289   unsigned int path_name_len = 0;       /* don't count '\0' */
290
291   xbt_assert0(name, "Need a non-NULL file name");
292
293   xbt_assert0(surf_path,
294               "surf_init has to be called before using surf_fopen");
295
296   if (__surf_is_absolute_file_path(name)) {     /* don't mess with absolute file names */
297     return fopen(name, mode);
298
299   } else {                      /* search relative files in the path */
300
301     if (!path_name) {
302       path_name_len = strlen(name);
303       path_name = xbt_new0(char, path_name_len + 1);
304     }
305
306     xbt_dynar_foreach(surf_path, iter, path) {
307       if (path_name_len < strlen(path) + strlen(name) + 1) {
308         path_name_len = strlen(path) + strlen(name) + 1;        /* plus '/' */
309         path_name = xbt_realloc(path_name, path_name_len + 1);
310       }
311 #ifdef WIN32
312       sprintf(path_name, "%s\\%s", path, name);
313 #else
314       sprintf(path_name, "%s/%s", path, name);
315 #endif
316       file = fopen(path_name, mode);
317       if (file)
318         return file;
319     }
320   }
321   return file;
322 }
323
324 void surf_exit(void)
325 {
326   unsigned int iter;
327   surf_model_t model = NULL;
328
329   surf_config_finalize();
330
331   xbt_dynar_foreach(model_list, iter, model) {
332     model->model_private->finalize();
333   }
334
335   if (maxmin_system) {
336     lmm_system_free(maxmin_system);
337     maxmin_system = NULL;
338   }
339   if (history) {
340     tmgr_history_free(history);
341     history = NULL;
342   }
343   if (model_list)
344     xbt_dynar_free(&model_list);
345
346   if (surf_path)
347     xbt_dynar_free(&surf_path);
348
349   tmgr_finalize();
350   surf_parse_lex_destroy();
351   if (path_name) {
352     free(path_name);
353     path_name = NULL;
354   }
355   surf_parse_free_callbacks();
356   xbt_dict_free(&route_table);
357   NOW = 0;                      /* Just in case the user plans to restart the simulation afterward */
358   xbt_exit();
359 }
360
361 void surf_presolve(void)
362 {
363   double next_event_date = -1.0;
364   tmgr_trace_event_t event = NULL;
365   double value = -1.0;
366   surf_resource_t resource = NULL;
367   surf_model_t model = NULL;
368   unsigned int iter;
369
370   DEBUG0
371     ("First Run! Let's \"purge\" events and put models in the right state");
372   while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
373     if (next_event_date > NOW)
374       break;
375     while ((event =
376             tmgr_history_get_next_event_leq(history, next_event_date,
377                                             &value, (void **) &resource))) {
378       resource->model->model_private->update_resource_state(resource,
379                                                             event, value,
380                                                             NOW);
381     }
382   }
383   xbt_dynar_foreach(model_list, iter, model) {
384     model->model_private->update_actions_state(NOW, 0.0);
385   }
386 }
387
388 double surf_solve(void)
389 {
390   double min = -1.0;
391   double next_event_date = -1.0;
392   double model_next_action_end = -1.0;
393   double value = -1.0;
394   surf_resource_t resource = NULL;
395   surf_model_t model = NULL;
396   tmgr_trace_event_t event = NULL;
397   unsigned int iter;
398
399   min = -1.0;
400
401   DEBUG0("Looking for next action end");
402   xbt_dynar_foreach(model_list, iter, model) {
403     DEBUG1("Running for Resource [%s]", model->name);
404     model_next_action_end = model->model_private->share_resources(NOW);
405     DEBUG2("Resource [%s] : next action end = %f",
406            model->name, model_next_action_end);
407     if (((min < 0.0) || (model_next_action_end < min))
408         && (model_next_action_end >= 0.0))
409       min = model_next_action_end;
410   }
411   DEBUG1("Next action end : %f", min);
412
413   if (min < 0.0)
414     return -1.0;
415
416   DEBUG0("Looking for next event");
417   while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
418     DEBUG1("Next event : %f", next_event_date);
419     if (next_event_date > NOW + min)
420       break;
421     DEBUG0("Updating models");
422     while ((event =
423             tmgr_history_get_next_event_leq(history, next_event_date,
424                                             &value, (void **) &resource))) {
425       if (resource->model->model_private->resource_used(resource)) {
426         min = next_event_date - NOW;
427         DEBUG1
428           ("This event will modify model state. Next event set to %f", min);
429       }
430       /* update state of model_obj according to new value. Does not touch lmm.
431          It will be modified if needed when updating actions */
432       resource->model->model_private->update_resource_state(resource,
433                                                             event, value,
434                                                             NOW + min);
435     }
436   }
437
438   DEBUG1("Duration set to %f", min);
439
440   NOW = NOW + min;
441
442   xbt_dynar_foreach(model_list, iter, model) {
443     model->model_private->update_actions_state(NOW, min);
444   }
445
446   return min;
447 }
448
449 double surf_get_clock(void)
450 {
451   return NOW;
452 }