X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fa8e71be179a7a12e74bcc550fa6fe2c54b8446a..45f517dc85cc6c2ed4ebce27de4f75c00271f945:/src/simdag/sd_workstation.c

diff --git a/src/simdag/sd_workstation.c b/src/simdag/sd_workstation.c
index 829da194cd..7a163ef9e9 100644
--- a/src/simdag/sd_workstation.c
+++ b/src/simdag/sd_workstation.c
@@ -75,7 +75,7 @@ const SD_workstation_t *SD_workstation_get_list(void)
     i = 0;
     xbt_lib_foreach(host_lib, cursor, key, data) {
       if(data[SD_HOST_LEVEL])
-    	  sd_global->workstation_list[i++] = (SD_workstation_t) data[SD_HOST_LEVEL];
+        sd_global->workstation_list[i++] = (SD_workstation_t) data[SD_HOST_LEVEL];
     }
   }
   return sd_global->workstation_list;
@@ -157,6 +157,42 @@ xbt_dict_t SD_workstation_get_properties(SD_workstation_t workstation)
 
 }
 
+/** @brief Displays debugging informations about a workstation */
+void SD_workstation_dump(SD_workstation_t ws)
+{
+  xbt_dict_t props;
+  xbt_dict_cursor_t cursor=NULL;
+  char *key,*data;
+  SD_task_t task = NULL;
+  
+  XBT_INFO("Displaying workstation %s", SD_workstation_get_name(ws));
+  XBT_INFO("  - power: %.0f", SD_workstation_get_power(ws));
+  XBT_INFO("  - available power: %.2f", SD_workstation_get_available_power(ws));
+  switch (ws->access_mode){
+  case SD_WORKSTATION_SHARED_ACCESS:
+      XBT_INFO("  - access mode: Space shared");
+      break;
+  case SD_WORKSTATION_SEQUENTIAL_ACCESS:
+      XBT_INFO("  - access mode: Exclusive");
+    task = SD_workstation_get_current_task(ws);
+    if(task)
+      XBT_INFO("    current running task: %s",
+               SD_task_get_name(task));
+    else
+      XBT_INFO("    no task running");
+      break;
+  default: break;
+  }
+  props = SD_workstation_get_properties(ws);
+  
+  if (!xbt_dict_is_empty(props)){
+    XBT_INFO("  - properties:");
+
+    xbt_dict_foreach(props,cursor,key,data) {
+      XBT_INFO("    %s->%s",key,data);
+    }
+  }
+}
 
 /**
  * \brief Returns the route between two workstations
@@ -397,6 +433,10 @@ void SD_workstation_set_access_mode(SD_workstation_t workstation,
                                     e_SD_workstation_access_mode_t
                                     access_mode)
 {
+  xbt_assert(access_mode != SD_WORKSTATION_SEQUENTIAL_ACCESS ||
+             access_mode != SD_WORKSTATION_SHARED_ACCESS,
+             "Trying to set an invalid access mode");
+
   if (access_mode == workstation->access_mode) {
     return;                     // nothing is changed
   }
@@ -411,16 +451,16 @@ void SD_workstation_set_access_mode(SD_workstation_t workstation,
   }
 }
 
-/* Returns whether a task can start now on a workstation.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              *//*
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) {
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   SD_CHECK_INIT_DONE();
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   xbt_assert(workstation != NULL && task != NULL, "Invalid parameter");
+/* Returns whether a task can start now on a workstation*/
+/*
+  int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) {
+  SD_CHECK_INIT_DONE();
+  xbt_assert(workstation != NULL && task != NULL, "Invalid parameter");
 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   return !__SD_workstation_is_busy(workstation) &&
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task);
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   }
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 */
+  return !__SD_workstation_is_busy(workstation) &&
+  (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task);
+  }
+*/
 
 /* Returns whether a workstation is busy. A workstation is busy is it is
  * in sequential mode and a task is running on it or the fifo is not empty.