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
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
*
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
*
#endif
}
+
/** @brief Immediately resumes the execution of all processes within the given VM.
* @ingroup msg_VMs
*
#endif
}
- /** @brief Immediately kills all processes within the given VM. Any memory that they allocated will be leaked.
- * @ingroup msg_VMs
- *
- * No extra delay occurs. If you want to simulate this too, you want to
- * use a #MSG_process_sleep() or something. I'm not quite sure.
- */
+
void MSG_vm_shutdown(msg_vm_t vm)
{
- msg_process_t process;
- XBT_DEBUG("%lu processes in the VM", xbt_dynar_length(vm->processes));
- while (xbt_dynar_length(vm->processes) > 0) {
- process = xbt_dynar_get_as(vm->processes,0,msg_process_t);
- MSG_process_kill(process);
+ /* msg_vm_t equals to msg_host_t */
+ char *name = simcall_host_get_name(vm);
+ smx_host_t smx_host = xbt_lib_get_or_null(host_lib, name, SIMIX_HOST_LEVEL);
+ smx_process_t smx_process, smx_process_next;
+
+ XBT_DEBUG("%lu processes in the VM", xbt_swag_size(SIMIX_host_priv(smx_host)->process_list));
+
+ xbt_swag_foreach_safe(smx_process, SIMIX_host_priv(smx_host)->process_list) {
+ XBT_DEBUG("kill %s", SIMIX_host_get_name(smx_host));
+ simcall_process_kill(smx_process);
}
+ /* taka: not yet confirmed */
#ifdef HAVE_TRACING
TRACE_msg_vm_kill(vm);
#endif
+
+ /* TODO: update the state of vm */
+
+ #if 0
+ while (xbt_dynar_length(vm->processes) > 0) {
+ process = xbt_dynar_get_as(vm->processes,0,msg_process_t);
+ }
+ #endif
}
+
+
/**
* \ingroup msg_VMs
* \brief Reboot the VM, restarting all the processes in it.
xbt_dynar_free(&new_processes);
}
+
/** @brief Destroy a msg_vm_t.
* @ingroup msg_VMs
*/
#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.
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.
*
* \param h the host to destroy (a smx_host_t)
*/
- void SIMIX_host_destroy(void *h)
+ void SIMIX_vm_host_destroy(void *h)
{
smx_host_priv_t host = (smx_host_priv_t) h;
+ smx_host_t
+ xbt_lib_(host_lib,name,SIMIX_HOST_LEVEL,smx_host);
+
+ /* jump to vm_ws_destroy() */
+ surf_vm_workstation_model->extension.vm_workstation.destroy(name);
+
xbt_assert((host != NULL), "Invalid parameters");
/* Clean Simulator data */
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)
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,
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);
-// 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);
-
-
+ workstation_VM2013_t vm_ws = xbt_new0(s_workstation_VM2013_t, 1);
- // TODO Implement the surf vm workstation model
++// TODO Complete the surf vm workstation model
+ 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);
}
-
+ /*
+ * A physical host does not disapper in the current SimGrid code, but a VM may
+ * disapper during a simulation.
+ */
+ static void vm_ws_destroy(const char *name)
+ {
+ workstation_VM2013_t workstation = xbt_lib_get_or_null(host_lib, name, SURF_WKS_LEVEL);
+ xbt_assert(workstation);
+ xbt_assert(workstation->generic_resource.model == surf_vm_workstation_model);
+
+ xbt_free(workstation->generic_resource.name);
+
+ /* not defined yet, but we should have */
+ // xbt_lib_unset(host_lib, name, SURF_WKS_LEVEL);
+
+ xbt_free(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;
-}
-
-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 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 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 int vm_ws_get_state(void *vm_ws){
+ return ((workstation_VM2013_t)vm_ws)->current_state;
}
-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 void vm_ws_set_state(void *vm_ws, int state){
+ ((workstation_VM2013_t)vm_ws)->current_state=state;
}
-
-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;
+ surf_vm_workstation_model->extension.vm_workstation.destroy = vm_ws_destroy;
}
-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();