Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Some progress (start, get/set state, ...) - Adrien
authoralebre <adrien.lebre@inria.fr>
Thu, 31 Jan 2013 15:59:48 +0000 (16:59 +0100)
committeralebre <adrien.lebre@inria.fr>
Thu, 31 Jan 2013 15:59:48 +0000 (16:59 +0100)
include/msg/datatypes.h
include/xbt/ex.h
src/include/surf/surf.h
src/msg/msg_vm.c
src/simix/smx_smurf_private.h
src/simix/smx_user.c
src/simix/smx_vm.c
src/surf/vm_workstation.c
src/xbt/ex.c

index 9394bf1..aeff669 100644 (file)
@@ -104,16 +104,14 @@ typedef struct msg_hypervisor {
 /* ********************************  VM ************************************* */
 typedef msg_host_t msg_vm_t;
 
-/* todo: make it clear */
 typedef enum {
 msg_vm_state_created,
-msg_vm_state_booting,
 msg_vm_state_running,
 msg_vm_state_sleeping,
 msg_vm_state_migrating,
 msg_vm_state_resuming,
-msg_vm_state_suspending,
-msg_vm_state_saving,
+msg_vm_state_suspended,
+msg_vm_state_saved,
 msg_vm_state_restoring,
 } e_msg_vm_state_t;
 
index 82573e0..b101562 100644 (file)
@@ -262,7 +262,8 @@ typedef enum {
   thread_error,                 /**< error while [un]locking */
   host_error,                   /**< host failed */
   tracing_error,                /**< error during the simulation tracing */
-  io_error                      /**< disk or file error */
+  io_error,                      /**< disk or file error */
+  vm_error                      /**< vm  error */
 } xbt_errcat_t;
 
 XBT_PUBLIC(const char *) xbt_ex_catname(xbt_errcat_t cat);
index 36c30c8..d4d9730 100644 (file)
@@ -279,6 +279,9 @@ typedef struct surf_workstation_model_extension_public {
 typedef struct surf_vm_workstation_model_extension_public {
   s_surf_model_extension_workstation_t basic;
   void* (*create) (const char *name, void *workstation); // First operation of the VM model
+  // start does not appear here as it corresponds to turn the state from created to running (see smx_vm.c)
+   int (*get_state) (void *workstation);
+  void (*set_state) (void *workstation, int state);
 } s_surf_model_extension_vm_workstation_t;
 
 /** \ingroup SURF_models
index eb2dbdc..9d0941f 100644 (file)
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_vm, msg,
                                 "Cloud-oriented parts of the MSG API");
 
-/** @brief Create a new VM (the VM is just attached to the location but it is not started yet).
- *  @ingroup msg_VMs
- */
-
-msg_vm_t MSG_vm_create(msg_host_t location, const char *name,
-                                            int core_nb, int mem_cap, int net_cap){
 
-  // Note new and vm_workstation refer to the same area (due to the lib/dict appraoch)
-  msg_vm_t new = NULL;
-  void *vm_workstation =  NULL;
-  // Ask simix to create the surf vm resource
-  vm_workstation = simcall_vm_create(name,location);
-  new = (msg_vm_t) __MSG_host_create(vm_workstation);
-
-
-  MSG_vm_set_property_value(new, "CORE_NB", bprintf("%d", core_nb), free);
-  MSG_vm_set_property_value(new, "MEM_CAP", bprintf("%d", core_nb), free);
-  MSG_vm_set_property_value(new, "NET_CAP", bprintf("%d", core_nb), free);
-
-  #ifdef HAVE_TRACING
-  TRACE_msg_vm_create(name, location);
-  #endif
-  return new;
-}
+/* **** ******** GENERAL ********* **** */
 
-/** \ingroup m_host_management
- * \brief Returns the value of a given host property
+/** \ingroup m_vm_management
+ * \brief Returns the value of a given vm property
  *
- * \param host a host
+ * \param vm a vm
  * \param name a property name
  * \return value of a property (or NULL if property not set)
  */
-const char *MSG_host_get_property_value(msg_host_t host, const char *name)
+
+const char *MSG_vm_get_property_value(msg_vm_t vm, const char *name)
 {
-  return xbt_dict_get_or_null(MSG_host_get_properties(host), name);
+  return MSG_host_get_property_value(vm, name);
 }
 
-/** \ingroup m_host_management
+/** \ingroup m_vm_management
  * \brief Returns a xbt_dict_t consisting of the list of properties assigned to this host
  *
- * \param host a host
+ * \param vm a vm
  * \return a dict containing the properties
  */
-xbt_dict_t MSG_host_get_properties(msg_host_t host)
+xbt_dict_t MSG_vm_get_properties(msg_vm_t vm)
 {
-  xbt_assert((host != NULL), "Invalid parameters (host is NULL)");
+  xbt_assert((vm != NULL), "Invalid parameters (vm is NULL)");
 
-  return (simcall_host_get_properties(host));
+  return (simcall_host_get_properties(vm));
 }
 
 /** \ingroup m_host_management
@@ -73,19 +52,22 @@ void MSG_vm_set_property_value(msg_vm_t vm, const char *name, void *value,void_f
   xbt_dict_set(MSG_host_get_properties(vm), name, value,free_ctn);
 }
 
-/** @brief Immediately suspend the execution of all processes within the given VM.
- *  @ingroup msg_VMs
- *  return wheter the VM has been correctly started (0) or not (<0)
+/** \ingroup msg_vm_management
+ * \brief Finds a msg_vm_t using its name.
+ *
+ * This is a name directory service
+ * \param name the name of a vm.
+ * \return the corresponding vm
  *
+ * Please note that a VM is a specific host. Hence, you should give a different name
+ * for each VM/PM.
  */
-int MSG_vm_start(msg_vm_t vm) {
- // TODO Please complete the code
 
-  #ifdef HAVE_TRACING
-  TRACE_msg_vm_start(vm);
-  #endif
+msg_vm_t MSG_vm_get_by_name(const char *name){
+       return MSG_get_host_by_name(name);
 }
 
+
 /** @brief Returns a newly constructed dynar containing all existing VMs in the system.
  *  @ingroup msg_VMs
  *
@@ -100,18 +82,73 @@ xbt_dynar_t MSG_vms_as_dynar(void) {
   return res;
 }
 
+/* **** ******** MSG vm actions ********* **** */
+
+/** @brief Create a new VM (the VM is just attached to the location but it is not started yet).
+ *  @ingroup msg_VMs*
+ *
+ * Please note that a VM is a specific host. Hence, you should give a different name
+ * for each VM/PM.
+ */
+msg_vm_t MSG_vm_create(msg_host_t location, const char *name,
+                                            int core_nb, int mem_cap, int net_cap){
+
+  // Note new and vm_workstation refer to the same area (due to the lib/dict appraoch)
+  msg_vm_t new = NULL;
+  void *vm_workstation =  NULL;
+  // Ask simix to create the surf vm resource
+  vm_workstation = simcall_vm_create(name,location);
+  new = (msg_vm_t) __MSG_host_create(vm_workstation);
+
+  MSG_vm_set_property_value(new, "CORE_NB", bprintf("%d", core_nb), free);
+  MSG_vm_set_property_value(new, "MEM_CAP", bprintf("%d", core_nb), free);
+  MSG_vm_set_property_value(new, "NET_CAP", bprintf("%d", core_nb), free);
+
+  // TODO check whether the vm (i.e the virtual host) has been correctly added into the list of all hosts.
+
+  #ifdef HAVE_TRACING
+  TRACE_msg_vm_create(name, location);
+  #endif
+
+  return new;
+}
+
+/** @brief Start a vm (ie. boot)
+ *  @ingroup msg_VMs
+ *
+ *  If the VM cannot be started, an exception is generated.
+ *
+ */
+void MSG_vm_start(msg_vm_t vm) {
+
+  //Please note that vm start can raise an exception if the VM cannot be started.
+  simcall_vm_start(vm);
+
+  #ifdef HAVE_TRACING
+  TRACE_msg_vm_start(vm);
+  #endif
+}
+
+/* **** Check state of a VM **** */
+int __MSG_vm_is_state(msg_vm_t vm, e_msg_vm_state_t state) {
+       return simcall_get_vm_state(vm) == state ;
+}
+
 /** @brief Returns whether the given VM is currently suspended
  *  @ingroup msg_VMs
  */
 int MSG_vm_is_suspended(msg_vm_t vm) {
-  return vm->state == msg_vm_state_suspended;
+       return __MSG_vm_is_state(msg_vm_state_suspended);
 }
 /** @brief Returns whether the given VM is currently running
  *  @ingroup msg_VMs
  */
 int MSG_vm_is_running(msg_vm_t vm) {
-  return vm->state == msg_vm_state_running;
+  return __MSG_vm_is_state(msg_vm_state_running);
 }
+
+// TODO complete the different state
+
 /** @brief Add the given process into the VM.
  *  @ingroup msg_VMs
  *
index e6fe1b0..7cf3a1a 100644 (file)
@@ -275,6 +275,10 @@ ACTION(SIMCALL_HOST_EXECUTION_GET_STATE, host_execution_get_state, WITH_ANSWER,
 ACTION(SIMCALL_HOST_EXECUTION_SET_PRIORITY, host_execution_set_priority, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t), TDOUBLE(priority)) sep \
 ACTION(SIMCALL_HOST_EXECUTION_WAIT, host_execution_wait, WITHOUT_ANSWER, TINT(result), TSPEC(execution, smx_action_t)) sep \
 ACTION(SIMCALL_VM_CREATE, vm_create, WITH_ANSWER, TPTR(result), TSTRING(name), TSPEC(phys_host, smx_host_t)) sep \
+ACTION(SIMCALL_VM_START, vm_start, WITHOUT_ANSWER, TVOID(result), TSPEC(phys_host, smx_host_t)) sep \
+ACTION(SIMCALL_VM_SET_STATE, vm_set_state, WITHOUT_ANSWER, TVOID(result), TSPEC(vm, smx_host_t)) TINT(state) sep \
+ACTION(SIMCALL_VM_GET_STATE, vm_get_state, WITH_ANSWER, TINT(result)), TSPEC(vm, smx_host_t)) sep \
+ACTION(SIMCALL_VM_START, vm_start, WITHOUT_ANSWER, TVOID(result), TSPEC(vm, smx_host_t)) sep \
 ACTION(SIMCALL_PROCESS_CREATE, process_create, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t*), TSTRING(name), TSPEC(code, xbt_main_func_t), TPTR(data), TSTRING(hostname), TDOUBLE(kill_time), TINT(argc), TSPEC(argv, char**), TSPEC(properties, xbt_dict_t), TINT(auto_restart)) sep \
 ACTION(SIMCALL_PROCESS_KILL, process_kill, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t)) sep \
 ACTION(SIMCALL_PROCESS_KILLALL, process_killall, WITH_ANSWER, TVOID(result)) sep \
index 35e2a36..0b292a1 100644 (file)
@@ -282,12 +282,17 @@ e_smx_state_t simcall_host_execution_wait(smx_action_t execution)
  * \param host A host
  * \return The properties of this host
  */
-void* simcall_vm_create(const char *name, smx_host_t host){
+void* simcall_vm_create(const char *name, smx_host_t phys_host){
 {
-  return simcall_BODY_vm_create(name, host);
+  return simcall_BODY_vm_create(name, phys_host);
 }
 
 
+void simcall_vm_start(smx_host_t vm){
+
+       simcall_BODY_set_vm_state(vm, msg_vm_state_running);
+}
+
 /**
  * \ingroup simix_process_management
  * \brief Creates and runs a new SIMIX process.
index bb3805f..9ab0802 100644 (file)
@@ -11,9 +11,8 @@
 #include "mc/mc.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_vm, simix,
-                                "Logging specific to SIMIX (hosts)");
-
-static void SIMIX_execution_finish(smx_action_t action);
+                                "Logging specific to SIMIX (vms)");
+/* **** create a VM **** */
 
 /**
  * \brief Internal function to create a SIMIX host.
@@ -37,10 +36,49 @@ smx_host_t SIMIX_vm_create(const char *name, smx_host_t phys_host)
   xbt_lib_set(host_lib,name,SIMIX_HOST_LEVEL,smx_host);
 
   /* Create surf associated resource */
-  surf_vm_workstation_model->extension.vm_workstation.create();
+  // TODO change phys_host into the right workstation surf model
+  surf_vm_workstation_model->extension.vm_workstation.create(name, phys_host);
+
   return xbt_lib_get_elm_or_null(host_lib, name);
 }
 
+smx_host_t SIMIX_pre_vm_create(smx_simcall_t simcall, const char *name, smx_host_t phys_host){
+   return SIMIX_vm_create(name, phys_host);
+}
+
+
+/* **** start a VM **** */
+int __can_be_started(smx_host_t vm){
+       // TODO add checking code related to overcommitment or not.
+       return 1;
+}
+void SIMIX_vm_start(smx_host_t vm){
+
+  //TODO only start the VM if you can
+  if (can_be_started(vm))
+         SIMIX_set_vm_state(vm, msg_vm_state_running);
+  else
+         THROWF(vm_error, 0, "The VM %s cannot be started", SIMIX_host_get_name(vm));
+}
+
+void SIMIX_pre_vm_start(smx_simcall_t simcall, smx_host_t vm){
+   SIMIX_vm_start(vm);
+}
+
+/* ***** set/get state of a VM ***** */
+void SIMIX_set_vm_state(smx_host_t vm, int state){
+
+}
+void SIMIX_prev_set_vm_state(smx_host_t vm, int state){
+       SIMIX_set_vm_state(vm, state);
+}
+
+int SIMIX_get_vm_state(smx_host_t vm){
+ return surf_vm_workstation_model->extension.vm_workstation.get_state(vm);
+}
+int SIMIX_pre_vm_state(smx_host_t vm){
+       return SIMIX_get_vm_state(vm);
+}
 /**
  * \brief Internal function to destroy a SIMIX host.
  *
@@ -75,27 +113,6 @@ void SIMIX_host_destroy(void *h)
   return;
 }
 
-///**
-// * \brief Returns a dict of all hosts.
-// *
-// * \return List of all hosts (as a #xbt_dict_t)
-// */
-//xbt_dict_t SIMIX_host_get_dict(void)
-//{
-//  xbt_dict_t host_dict = xbt_dict_new_homogeneous(NULL);
-//  xbt_lib_cursor_t cursor = NULL;
-//  char *name = NULL;
-//  void **host = NULL;
-//
-//  xbt_lib_foreach(host_lib, cursor, name, host){
-//    if(host[SIMIX_HOST_LEVEL])
-//            xbt_dict_set(host_dict,name,host[SIMIX_HOST_LEVEL], NULL);
-//  }
-//  return host_dict;
-//}
-smx_host_t SIMIX_pre_vm_create(smx_simcall_t simcall, const char *name, smx_host_t phys_host){
-   return SIMIX_vm_create(name, phys_host);
-}
 
 smx_host_t SIMIX_host_get_by_name(const char *name){
   xbt_assert(((simix_global != NULL)
index cb76055..90242e9 100644 (file)
@@ -14,6 +14,7 @@
 typedef struct workstation_VM2013 {
   s_surf_resource_t generic_resource;   /* Must remain first to add this to a trace */
   surf_resource_t physical_workstation;  // Pointer to the host OS
+  e_msg_vm_state_t current_state;           // See include/msg/datatypes.h
 } s_workstation_VM2013_t, *workstation_VM2013_t;
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_vm_workstation, surf,
@@ -21,436 +22,36 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_vm_workstation, surf,
 
 surf_model_t surf_vm_workstation_model = NULL;
 
-static void *vm_ws_create (const char *name, void *phys_workstation)
+static void vm_ws_create (const char *name, void *phys_workstation)
 {
-  workstation_VM2013_t workstation = xbt_new0(s_workstation_VM2013_t, 1);
+  workstation_VM2013_t vm_ws = xbt_new0(s_workstation_VM2013_t, 1);
 // TODO Implement the surf vm workstation model
-  workstation->generic_resource.model = surf_vm_workstation_model;
-  workstation->generic_resource.name = xbt_strdup(name);
-  workstation->physical_workstation = phys_workstation;
-  xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, workstation);
-
-}
-
-static int ws_resource_used(void *resource_id)
-{
-  THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
-  return -1;
-}
-
-static void ws_parallel_action_cancel(surf_action_t action)
-{
-  THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
-}
-
-static int ws_parallel_action_free(surf_action_t action)
-{
-  THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
-  return -1;
-}
-
-static int ws_action_unref(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    return surf_network_model->action_unref(action);
-  else if (action->model_type == surf_cpu_model)
-    return surf_cpu_model->action_unref(action);
-  else if (action->model_type == surf_workstation_model)
-    return ws_parallel_action_free(action);
-  else
-    DIE_IMPOSSIBLE;
-  return 0;
+  vm_ws->generic_resource.model = surf_vm_workstation_model;
+  vm_ws->generic_resource.name = xbt_strdup(name);
+  vm_ws->physical_workstation = phys_workstation;
+  vm_ws->current_state=msg_vm_state_created,
+  xbt_lib_set(host_lib, name, SURF_WKS_LEVEL, vm_ws);
 }
 
-static void ws_action_cancel(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->action_cancel(action);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->action_cancel(action);
-  else if (action->model_type == surf_workstation_model)
-    ws_parallel_action_cancel(action);
-  else
-    DIE_IMPOSSIBLE;
-  return;
+static int vm_ws_get_state(void *vm_ws){
+       return ((workstation_VM2013_t)vm_ws)->current_state;
 }
 
-static void ws_action_state_set(surf_action_t action,
-                                e_surf_action_state_t state)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->action_state_set(action, state);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->action_state_set(action, state);
-  else if (action->model_type == surf_workstation_model)
-    surf_action_state_set(action, state);
-  else
-    DIE_IMPOSSIBLE;
-  return;
+static void vm_ws_set_state(void *vm_ws, int state){
+        ((workstation_VM2013_t)vm_ws)->current_state=state;
 }
-
-static double ws_share_resources(double now)
-{
-  return -1.0;
-}
-
-static void ws_update_actions_state(double now, double delta)
-{
-  return;
-}
-
-static void ws_update_resource_state(void *id,
-                                     tmgr_trace_event_t event_type,
-                                     double value, double date)
-{
-  THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
-}
-
-static surf_action_t ws_execute(void *workstation, double size)
-{
-  surf_resource_t cpu = ((surf_resource_t) surf_cpu_resource_priv(workstation));
-  return cpu->model->extension.cpu.execute(workstation, size);
-}
-
-static surf_action_t ws_action_sleep(void *workstation, double duration)
-{
-  return surf_cpu_model->extension.cpu.
-      sleep(workstation, duration);
-}
-
-static void ws_action_suspend(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->suspend(action);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->suspend(action);
-  else
-    DIE_IMPOSSIBLE;
-}
-
-static void ws_action_resume(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->resume(action);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->resume(action);
-  else
-    DIE_IMPOSSIBLE;
-}
-
-static int ws_action_is_suspended(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    return surf_network_model->is_suspended(action);
-  if (action->model_type == surf_cpu_model)
-    return surf_cpu_model->is_suspended(action);
-  DIE_IMPOSSIBLE;
-  return -1;
-}
-
-static void ws_action_set_max_duration(surf_action_t action,
-                                       double duration)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->set_max_duration(action, duration);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->set_max_duration(action, duration);
-  else
-    DIE_IMPOSSIBLE;
-}
-
-static void ws_action_set_priority(surf_action_t action, double priority)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->set_priority(action, priority);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->set_priority(action, priority);
-  else
-    DIE_IMPOSSIBLE;
-}
-
-#ifdef HAVE_TRACING
-static void ws_action_set_category(surf_action_t action, const char *category)
-{
-  if (action->model_type == surf_network_model)
-    surf_network_model->set_category(action, category);
-  else if (action->model_type == surf_cpu_model)
-    surf_cpu_model->set_category(action, category);
-  else
-    DIE_IMPOSSIBLE;
-}
-#endif
-
-#ifdef HAVE_LATENCY_BOUND_TRACKING
-static int ws_get_latency_limited(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    return surf_network_model->get_latency_limited(action);
-  else
-    return 0;
-}
-#endif
-
-static double ws_action_get_remains(surf_action_t action)
-{
-  if (action->model_type == surf_network_model)
-    return surf_network_model->get_remains(action);
-  if (action->model_type == surf_cpu_model)
-    return surf_cpu_model->get_remains(action);
-  DIE_IMPOSSIBLE;
-  return -1.0;
-}
-
-static surf_action_t ws_communicate(void *workstation_src,
-                                    void *workstation_dst, double size,
-                                    double rate)
-{
-  workstation_VM2013_t src = surf_workstation_resource_priv(workstation_src);
-  workstation_VM2013_t dst = surf_workstation_resource_priv(workstation_dst);
-  return surf_network_model->extension.network.
-      communicate(src->net_elm,
-                  dst->net_elm, size, rate);
-}
-
-static e_surf_resource_state_t ws_get_state(void *workstation)
-{
-  return surf_cpu_model->extension.cpu.
-      get_state(workstation);
-}
-
-static double ws_get_speed(void *workstation, double load)
-{
-  return surf_cpu_model->extension.cpu.
-      get_speed(workstation, load);
-}
-
-static double ws_get_available_speed(void *workstation)
-{
-  return surf_cpu_model->extension.cpu.
-      get_available_speed(workstation);
-}
-
-static surf_action_t ws_execute_parallel_task(int workstation_nb,
-                                              void **workstation_list,
-                                              double *computation_amount,
-                                              double *communication_amount,
-                                              double rate)
-{
-#define cost_or_zero(array,pos) ((array)?(array)[pos]:0.0)
-  if ((workstation_nb == 1)
-      && (cost_or_zero(communication_amount, 0) == 0.0))
-    return ws_execute(workstation_list[0], computation_amount[0]);
-  else if ((workstation_nb == 1)
-           && (cost_or_zero(computation_amount, 0) == 0.0))
-    return ws_communicate(workstation_list[0], workstation_list[0],communication_amount[0], rate);
-  else if ((workstation_nb == 2)
-             && (cost_or_zero(computation_amount, 0) == 0.0)
-             && (cost_or_zero(computation_amount, 1) == 0.0)) {
-    int i,nb = 0;
-    double value = 0.0;
-
-    for (i = 0; i < workstation_nb * workstation_nb; i++) {
-      if (cost_or_zero(communication_amount, i) > 0.0) {
-        nb++;
-        value = cost_or_zero(communication_amount, i);
-      }
-    }
-    if (nb == 1)
-      return ws_communicate(workstation_list[0], workstation_list[1],value, rate);
-  }
-#undef cost_or_zero
-
-  THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
-  return NULL;
-}
-
-
-/* returns an array of network_link_CM02_t */
-static xbt_dynar_t ws_get_route(void *workstation_src, void *workstation_dst)
-{
-  XBT_DEBUG("ws_get_route");
-  workstation_VM2013_t src = surf_workstation_resource_priv(workstation_src);
-  workstation_VM2013_t dst = surf_workstation_resource_priv(workstation_dst);
-  return surf_network_model->extension.
-      network.get_route(src->net_elm,
-                  dst->net_elm);
-}
-
-static double ws_get_link_bandwidth(const void *link)
-{
-  return surf_network_model->extension.network.get_link_bandwidth(link);
-}
-
-static double ws_get_link_latency(const void *link)
-{
-  return surf_network_model->extension.network.get_link_latency(link);
-}
-
-static int ws_link_shared(const void *link)
-{
-  return surf_network_model->extension.network.link_shared(link);
-}
-
-static void ws_finalize(void)
-{
-  surf_model_exit(surf_workstation_model);
-  surf_workstation_model = NULL;
-}
-
-
-static storage_t find_storage_on_mount_list(void *workstation,const char* storage)
-{
-  storage_t st = NULL;
-  s_mount_t mnt;
-  unsigned int cursor;
-  workstation_VM2013_t ws = (workstation_VM2013_t) surf_workstation_resource_priv(workstation);
-  xbt_dynar_t storage_list = ws->storage;
-
-  XBT_DEBUG("Search for storage name '%s' on '%s'",storage,ws->generic_resource.name);
-  xbt_dynar_foreach(storage_list,cursor,mnt)
-  {
-    XBT_DEBUG("See '%s'",mnt.name);
-    if(!strcmp(storage,mnt.name)){
-      st = mnt.id;
-      break;
-    }
-  }
-  if(!st) xbt_die("Can't find mount '%s' for '%s'",storage,ws->generic_resource.name);
-  return st;
-}
-
-static surf_action_t ws_action_open(void *workstation, const char* mount, const char* path, const char* mode)
-{
-  storage_t st = find_storage_on_mount_list(workstation, mount);
-  XBT_DEBUG("OPEN on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.open(st, mount, path, mode);
-}
-
-static surf_action_t ws_action_close(void *workstation, surf_file_t fp)
-{
-  storage_t st = find_storage_on_mount_list(workstation, fp->storage);
-  XBT_DEBUG("CLOSE on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.close(st, fp);
-}
-
-static surf_action_t ws_action_read(void *workstation, void* ptr, size_t size, size_t nmemb, surf_file_t stream)
-{
-  storage_t st = find_storage_on_mount_list(workstation, stream->storage);
-  XBT_DEBUG("READ on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.read(st, ptr, (double)size, nmemb, stream);
-}
-
-static surf_action_t ws_action_write(void *workstation, const void* ptr, size_t size, size_t nmemb, surf_file_t stream)
-{
-  storage_t st = find_storage_on_mount_list(workstation, stream->storage);
-  XBT_DEBUG("WRITE on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.write(st,  ptr, size, nmemb, stream);
-}
-
-static surf_action_t ws_action_stat(void *workstation, surf_file_t stream)
-{
-  storage_t st = find_storage_on_mount_list(workstation, stream->storage);
-  XBT_DEBUG("STAT on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.stat(st,  stream);
-}
-
-static surf_action_t ws_action_unlink(void *workstation, surf_file_t stream)
-{
-  storage_t st = find_storage_on_mount_list(workstation, stream->storage);
-  XBT_DEBUG("UNLINK on disk '%s'",st->generic_resource.name);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.unlink(st,  stream);
-}
-
-static surf_action_t ws_action_ls(void *workstation, const char* mount, const char *path)
-{
-  XBT_DEBUG("LS on mount '%s' and file '%s'",mount, path);
-  storage_t st = find_storage_on_mount_list(workstation, mount);
-  surf_model_t model = st->generic_resource.model;
-  return model->extension.storage.ls(st, path);
-}
-
 static void surf_vm_workstation_model_init_internal(void)
 {
-  // TODO Adrien, who is calling surf_model_init() and Why ?
   surf_vm_workstation_model = surf_model_init();
 
   surf_vm_workstation_model->name = "Virtual Workstation";
-  surf_vm_workstation_model->action_unref = ws_action_unref;
-  surf_vm_workstation_model->action_cancel = ws_action_cancel;
-  surf_vm_workstation_model->action_state_set = ws_action_state_set;
 
-  surf_vm_workstation_model->model_private->resource_used = ws_resource_used;
-  surf_vm_workstation_model->model_private->share_resources =
-      ws_share_resources;
-  surf_vm_workstation_model->model_private->update_actions_state =
-      ws_update_actions_state;
-  surf_vm_workstation_model->model_private->update_resource_state =
-      ws_update_resource_state;
-  surf_vm_workstation_model->model_private->finalize = ws_finalize;
-
-  surf_vm_workstation_model->suspend = ws_action_suspend;
-  surf_vm_workstation_model->resume = ws_action_resume;
-  surf_vm_workstation_model->is_suspended = ws_action_is_suspended;
-  surf_vm_workstation_model->set_max_duration = ws_action_set_max_duration;
-  surf_vm_workstation_model->set_priority = ws_action_set_priority;
-#ifdef HAVE_TRACING
-  surf_vm_workstation_model->set_category = ws_action_set_category;
-#endif
-  surf_vm_workstation_model->get_remains = ws_action_get_remains;
-#ifdef HAVE_LATENCY_BOUND_TRACKING
-  surf_vm_workstation_model->get_latency_limited = ws_get_latency_limited;
-#endif
-
-  surf_vm_workstation_model->extension.workstation.execute = ws_execute;
-  surf_vm_workstation_model->extension.workstation.sleep = ws_action_sleep;
-  surf_vm_workstation_model->extension.workstation.get_state = ws_get_state;
-  surf_vm_workstation_model->extension.workstation.get_speed = ws_get_speed;
-  surf_vm_workstation_model->extension.workstation.get_available_speed =
-      ws_get_available_speed;
-
-  surf_vm_workstation_model->extension.workstation.communicate =
-      ws_communicate;
-  surf_vm_workstation_model->extension.workstation.get_route = ws_get_route;
-  surf_vm_workstation_model->extension.workstation.execute_parallel_task =
-      ws_execute_parallel_task;
-  surf_vm_workstation_model->extension.workstation.get_link_bandwidth =
-      ws_get_link_bandwidth;
-  surf_vm_workstation_model->extension.workstation.get_link_latency =
-      ws_get_link_latency;
-  surf_vm_workstation_model->extension.workstation.link_shared =
-      ws_link_shared;
-  surf_vm_workstation_model->extension.workstation.get_properties =
-      surf_resource_properties; // Generic invocations
-
-  surf_vm_workstation_model->extension.workstation.open = ws_action_open;
-  surf_vm_workstation_model->extension.workstation.close = ws_action_close;
-  surf_vm_workstation_model->extension.workstation.read = ws_action_read;
-  surf_vm_workstation_model->extension.workstation.write = ws_action_write;
-  surf_vm_workstation_model->extension.workstation.stat = ws_action_stat;
-  surf_vm_workstation_model->extension.workstation.unlink = ws_action_unlink;
-  surf_vm_workstation_model->extension.workstation.ls = ws_action_ls;
   surf_vm_workstation_model->extension.vm_workstation.create = vm_ws_create;
+  surf_vm_workstation_model->extension.vm_workstation.set_state = vm_ws_set_state;
+  surf_vm_workstation_model->extension.vm_workstation.get_state = vm_ws_get_state;
 
 }
 
-void surf_workstation_model_init_current_default(void)
-{
-  surf_workstation_model_init_internal();
-  xbt_cfg_setdefault_int(_sg_cfg_set, "network/crosstraffic", 1);
-  surf_cpu_model_init_Cas01();
-  surf_network_model_init_LegrandVelho();
-// TODO fix me
-  xbt_dynar_push(model_list, &surf_workstation_model);
-  sg_platf_host_add_cb(vm_ws_create);
-//  sg_platf_postparse_add_cb(create_workstations);
-}
-
 void surf_vm_workstation_model_init()
 {
   surf_vm_workstation_model_init_internal();
index ac2fa9b..7faa0f0 100644 (file)
@@ -222,6 +222,9 @@ const char *xbt_ex_catname(xbt_errcat_t cat)
     return "tracing error";
   case io_error:
     return "io error";
+  case vm_error:
+    return "vm error";
+
   }
   return "INVALID ERROR";
 }