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