Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
112b2b18a017568144c02ee069a4ffe1108ee867
[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 {
29         "A:\\",
30         "B:\\",
31         "C:\\",
32         "D:\\",
33         "E:\\",
34         "F:\\",
35         "G:\\",
36         "H:\\",
37         "I:\\",
38         "J:\\",
39         "K:\\",
40         "L:\\",
41         "M:\\",
42         "N:\\",
43         "O:\\",
44         "P:\\",
45         "Q:\\",
46         "R:\\",
47         "S:\\",
48         "T:\\",
49         "U:\\",
50         "V:\\",
51         "W:\\",
52         "X:\\",
53         "Y:\\",
54         "Z:\\"
55 };
56 #endif /* #ifdef _WIN32 */
57
58 /*
59  * Returns the initial path. On Windows the initial path is
60  * the current directory for the current process in the other
61  * case the function returns "./" that represents the current
62  * directory on Unix/Linux platforms.
63  */
64                         
65 const char* __surf_get_initial_path(void)
66 {
67
68         #ifdef _WIN32
69         unsigned i;
70         char current_directory[MAX_PATH + 1] = {0};
71         unsigned int len = GetCurrentDirectory(MAX_PATH + 1,current_directory);
72         char root[4] = {0};
73
74         if(!len)
75                 return NULL;
76
77         strncpy(root,current_directory,3);
78
79         for(i = 0; i<MAX_DRIVE;i++)
80         {
81                 if(toupper(root[0]) == disk_drives_letter_table[i][0])
82                         return disk_drives_letter_table[i];
83         }
84
85         return NULL;
86         #else
87         return "./";
88         #endif
89 }
90
91 /* The __surf_is_absolute_file_path() returns 1 if
92  * file_path is a absolute file path, in the other
93  * case the function returns 0.
94  */
95 int __surf_is_absolute_file_path(const char* file_path)
96 {
97         #ifdef _WIN32
98         WIN32_FIND_DATA wfd ={0};
99         HANDLE hFile = FindFirstFile(file_path,&wfd);
100
101         if(INVALID_HANDLE_VALUE == hFile)
102                 return 0;
103
104         FindClose(hFile);
105         return 1;
106         #else
107         return (file_path[0] == '/');
108         #endif
109 }
110
111 typedef struct surf_resource_object {
112   surf_resource_t resource;
113 } s_surf_resource_object_t, *surf_resource_object_t;
114
115 static double NOW = 0;
116
117 xbt_dynar_t resource_list = NULL;
118 tmgr_history_t history = NULL;
119 lmm_system_t maxmin_system = NULL;
120 xbt_dynar_t surf_path = NULL;
121 const char *surf_action_state_names[6] = {
122   "SURF_ACTION_READY", 
123   "SURF_ACTION_RUNNING", 
124   "SURF_ACTION_FAILED", 
125   "SURF_ACTION_DONE", 
126   "SURF_ACTION_TO_FREE", 
127   "SURF_ACTION_NOT_IN_THE_SYSTEM"
128 };
129
130 int surf_network_resource_description_size=3
131   #ifdef HAVE_GTNETS
132      +1
133   #endif
134   #ifdef HAVE_SDP
135      +1
136   #endif
137 ;
138 s_surf_resource_description_t surf_network_resource_description[]=
139   {
140     {"CM02",NULL,surf_network_resource_init_CM02},
141 #ifdef HAVE_GTNETS
142     {"GTNets",NULL,surf_network_resource_init_GTNETS},
143 #endif
144 #ifdef HAVE_SDP
145     {"SDP",NULL,surf_network_resource_init_SDP},
146 #endif
147     {"Reno",NULL,surf_network_resource_init_Reno},
148     {"Vegas",NULL,surf_network_resource_init_Vegas}
149   };
150
151 int surf_cpu_resource_description_size=1;
152 s_surf_resource_description_t surf_cpu_resource_description[]=
153   {
154     {"Cas01",NULL,surf_cpu_resource_init_Cas01},
155   };
156
157 int surf_workstation_resource_description_size=4;
158 s_surf_resource_description_t surf_workstation_resource_description[]=
159   {
160     {"CLM03",NULL,surf_workstation_resource_init_CLM03},
161     {"KCCFLN05",NULL,surf_workstation_resource_init_KCCFLN05},
162     {"compound",NULL,surf_workstation_resource_init_compound},
163     {"ptask_L07",NULL,surf_workstation_resource_init_ptask_L07}
164   };
165
166 void update_resource_description(s_surf_resource_description_t *table,
167                                  int table_size,
168                                  const char* name, 
169                                  surf_resource_t resource
170                                  ) 
171 {
172   int i = find_resource_description(table, table_size, name);
173   table[i].resource=resource;
174 }
175
176 int find_resource_description(s_surf_resource_description_t *table,
177                                int table_size,
178                                const char* name)
179 {
180   int i;
181   char *name_list=NULL;
182
183   for(i=0;i<table_size;i++)
184     if(!strcmp(name,table[i].name)) {
185       return i;
186     }
187   name_list=strdup(table[0].name);
188   for(i=1;i<table_size;i++) {
189     name_list = xbt_realloc(name_list,strlen(name_list)+strlen(table[i].name)+2);
190     strcat(name_list,", ");
191     strcat(name_list,table[i].name);
192   }
193   xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.",name,name_list);
194 }
195
196 double generic_maxmin_share_resources(xbt_swag_t running_actions,
197                                        size_t offset)
198 {
199   return  generic_maxmin_share_resources2(running_actions, offset,
200                                           maxmin_system, lmm_solve);
201 }
202
203 double generic_maxmin_share_resources2(xbt_swag_t running_actions,
204                                        size_t offset,
205                                        lmm_system_t sys,
206                                        void (*solve)(lmm_system_t))
207 {
208   surf_action_t action = NULL;
209   double min = -1;
210   double value = -1;
211 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset))))
212
213   xbt_assert0(solve,"Give me a real solver function!");
214   solve(sys);
215
216   xbt_swag_foreach(action, running_actions) {
217     value = lmm_variable_getvalue(VARIABLE(action));
218     if ((value > 0) || (action->max_duration >= 0))
219       break;
220   }
221
222   if (!action)
223     return -1.0;
224
225   if (value > 0) {
226     min = action->remains / value;
227     if ((action->max_duration >= 0) && (action->max_duration < min))
228       min = action->max_duration;
229   } else
230     min = action->max_duration;
231
232   DEBUG5("Found action (%p: duration = %f, remains = %f, value = %f) ! %f",action, action->max_duration, action->remains, value, min); 
233
234   for (action = xbt_swag_getNext(action, running_actions->offset);
235        action;
236        action = xbt_swag_getNext(action, running_actions->offset)) {
237     value = lmm_variable_getvalue(VARIABLE(action));
238     if (value > 0) {
239       value = action->remains / value;
240       if (value < min) {
241         min = value;
242         DEBUG2("Updating min (value) with %p: %f",action, min);
243       }
244     }
245     if ((action->max_duration >= 0) && (action->max_duration < min)) {
246       min = action->max_duration;
247       DEBUG2("Updating min (duration) with %p: %f",action, min);
248     }
249   }
250   DEBUG1("min value : %f",min);
251
252 #undef VARIABLE
253   return min;
254 }
255
256 e_surf_action_state_t surf_action_get_state(surf_action_t action)
257 {
258   surf_action_state_t action_state =
259       &(action->resource_type->common_public->states);
260
261   if (action->state_set == action_state->ready_action_set)
262     return SURF_ACTION_READY;
263   if (action->state_set == action_state->running_action_set)
264     return SURF_ACTION_RUNNING;
265   if (action->state_set == action_state->failed_action_set)
266     return SURF_ACTION_FAILED;
267   if (action->state_set == action_state->done_action_set)
268     return SURF_ACTION_DONE;
269   return SURF_ACTION_NOT_IN_THE_SYSTEM;
270 }
271
272 double surf_action_get_start_time(surf_action_t action) {
273   return action->start;
274 }
275
276 double surf_action_get_finish_time(surf_action_t action) {
277   return action->finish;
278 }
279
280 void surf_action_free(surf_action_t * action)
281 {
282   (*action)->resource_type->common_public->action_cancel(*action);
283   free(*action);
284   *action = NULL;
285 }
286
287 void surf_action_change_state(surf_action_t action,
288                               e_surf_action_state_t state)
289 {
290   surf_action_state_t action_state =
291       &(action->resource_type->common_public->states);
292   XBT_IN2("(%p,%s)", action, surf_action_state_names[state]);
293   xbt_swag_remove(action, action->state_set);
294
295   if (state == SURF_ACTION_READY)
296     action->state_set = action_state->ready_action_set;
297   else if (state == SURF_ACTION_RUNNING)
298     action->state_set = action_state->running_action_set;
299   else if (state == SURF_ACTION_FAILED)
300     action->state_set = action_state->failed_action_set;
301   else if (state == SURF_ACTION_DONE)
302     action->state_set = action_state->done_action_set;
303   else
304     action->state_set = NULL;
305
306   if (action->state_set)
307     xbt_swag_insert(action, action->state_set);
308   XBT_OUT;
309 }
310
311 void surf_action_set_data(surf_action_t action,
312                           void *data)
313 {
314   action->data=data;
315 }
316
317 void surf_init(int *argc, char **argv)
318 {
319   int i,j;
320   char *opt;
321   
322   const char* initial_path;
323
324   xbt_init(argc, argv);
325   if (!surf_path) {
326     
327     /* retrieves the current directory of the current process*/
328     initial_path = __surf_get_initial_path();
329                 
330         xbt_assert0((initial_path), "__surf_get_initial_path() failed! Can't resolves current Windows directory");
331     
332     surf_path = xbt_dynar_new(sizeof(char*), NULL);
333     xbt_dynar_push(surf_path,&initial_path);
334
335     for (i=1; i<*argc; i++) {
336       if (!strncmp(argv[i],"--surf-path=",strlen("--surf-path="))) {
337         opt=strchr(argv[i],'=');
338         opt++;
339         xbt_dynar_push(surf_path,&opt);
340         /*remove this from argv*/
341         for (j=i+1; j<*argc; j++) {
342           argv[j-1] = argv[j];
343         } 
344         argv[j-1] = NULL;
345         (*argc)--;
346         i--; /* compensate effect of next loop incrementation */
347       }
348     }
349   }
350   if (!resource_list)
351     resource_list = xbt_dynar_new(sizeof(surf_resource_private_t), NULL);
352   if (!history)
353     history = tmgr_history_new();
354   if (!maxmin_system)
355     maxmin_system = lmm_system_new();
356 }
357
358 static char* path_name = NULL;
359 FILE *surf_fopen(const char *name, const char *mode)
360 {
361   int i; 
362   char* path = NULL;
363   FILE *file = NULL;
364   int path_name_len = 0; /* don't count '\0' */
365
366   xbt_assert0(name, "Need a non-NULL file name");
367
368   xbt_assert0(surf_path,"surf_init has to be called before using surf_fopen");
369    
370   if (__surf_is_absolute_file_path(name)) { /* don't mess with absolute file names */
371     return fopen(name,mode);
372      
373   } else { /* search relative files in the path */
374    
375     if(!path_name) {
376        path_name_len = strlen(name);
377        path_name=xbt_new0(char,path_name_len+1);
378     }
379
380     xbt_dynar_foreach(surf_path,i,path) {
381       if(path_name_len < strlen(path)+strlen(name)+1) {
382          path_name_len = strlen(path)+strlen(name)+1; /* plus '/' */
383          path_name=xbt_realloc(path_name,path_name_len+1);
384       }
385       sprintf(path_name,"%s/%s",path, name);
386       file = fopen(path_name,mode);
387       if (file) return file;
388     }
389   }
390   return file;
391 }
392
393 void surf_exit(void)
394 {
395   int i;
396   surf_resource_t resource = NULL;
397
398   xbt_dynar_foreach(resource_list, i, resource) {
399     resource->common_private->finalize();
400   }
401
402   if (maxmin_system) {
403     lmm_system_free(maxmin_system);
404     maxmin_system = NULL;
405   }
406   if (history) {
407     tmgr_history_free(history);
408     history = NULL;
409   }
410   if (resource_list)
411     xbt_dynar_free(&resource_list);
412
413   if(surf_path) 
414     xbt_dynar_free(&surf_path);
415
416   tmgr_finalize();
417   surf_parse_lex_destroy();
418   if(path_name) {
419     free(path_name);
420     path_name = NULL;
421   }
422   xbt_exit();
423 }
424
425 double surf_solve(void)
426 {
427   static int first_run = 1;
428
429   double min = -1.0;
430   double next_event_date = -1.0;
431   double resource_next_action_end = -1.0;
432   double value = -1.0;
433   surf_resource_object_t resource_obj = NULL;
434   surf_resource_t resource = NULL;
435   tmgr_trace_event_t event = NULL;
436   int i;
437
438   if (first_run) {
439     DEBUG0("First Run! Let's \"purge\" events and put resources in the right state");
440     while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
441       if (next_event_date > NOW)
442         break;
443       while ((event =
444               tmgr_history_get_next_event_leq(history, next_event_date,
445                                               &value,
446                                               (void **) &resource_obj))) {
447         resource_obj->resource->common_private->
448             update_resource_state(resource_obj, event, value);
449       }
450     }
451     xbt_dynar_foreach(resource_list, i, resource) {
452       resource->common_private->update_actions_state(NOW, 0.0);
453     }
454     first_run = 0;
455     return 0.0;
456   }
457
458   min = -1.0;
459
460   DEBUG0("Looking for next action end");
461   xbt_dynar_foreach(resource_list, i, resource) {
462     DEBUG1("Running for Resource [%s]",resource->common_public->name);
463     resource_next_action_end =
464         resource->common_private->share_resources(NOW);
465     DEBUG2("Resource [%s] : next action end = %f",resource->common_public->name,
466            resource_next_action_end);
467     if (((min < 0.0) || (resource_next_action_end < min))
468         && (resource_next_action_end >= 0.0))
469       min = resource_next_action_end;
470   }
471   DEBUG1("Next action end : %f", min);
472
473   if (min < 0.0)
474     return -1.0;
475
476   DEBUG0("Looking for next event");
477   while ((next_event_date = tmgr_history_next_date(history)) != -1.0) {
478     DEBUG1("Next event : %f",next_event_date);
479     if (next_event_date > NOW + min)
480       break;
481     DEBUG0("Updating resources");
482     while ((event =
483             tmgr_history_get_next_event_leq(history, next_event_date,
484                                             &value,
485                                             (void **) &resource_obj))) {
486       if (resource_obj->resource->common_private->
487           resource_used(resource_obj)) {
488         min = next_event_date - NOW;
489         DEBUG1("This event will modify resource state. Next event set to %f", min);
490       }
491       /* update state of resource_obj according to new value. Does not touch lmm.
492          It will be modified if needed when updating actions */
493       resource_obj->resource->common_private->
494           update_resource_state(resource_obj, event, value);
495     }
496   }
497
498   DEBUG1("Duration set to %f", min);
499
500   NOW = NOW + min;
501
502   xbt_dynar_foreach(resource_list, i, resource) {
503     resource->common_private->update_actions_state(NOW, min);
504   }
505
506   return min;
507 }
508
509 double surf_get_clock(void)
510 {
511   return NOW;
512 }