/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "host_interface.hpp"
+
#include "simix/smx_private.h"
-#include "workstation_interface.hpp"
-#include "vm_workstation_interface.hpp"
#include "cpu_cas01.hpp"
#include "simgrid/sg_config.h"
#include "network_interface.hpp"
+#include "vm_interface.hpp"
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_workstation, surf,
- "Logging specific to the SURF workstation module");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_host, surf,
+ "Logging specific to the SURF host module");
-WorkstationModelPtr surf_workstation_model = NULL;
+HostModelPtr surf_host_model = NULL;
/*************
* Callbacks *
*************/
-surf_callback(void, WorkstationPtr) workstationCreatedCallbacks;
-surf_callback(void, WorkstationPtr) workstationDestructedCallbacks;
-surf_callback(void, WorkstationPtr, e_surf_resource_state_t, e_surf_resource_state_t) workstationStateChangedCallbacks;
-surf_callback(void, WorkstationActionPtr, e_surf_action_state_t, e_surf_action_state_t) workstationActionStateChangedCallbacks;
+surf_callback(void, HostPtr) hostCreatedCallbacks;
+surf_callback(void, HostPtr) hostDestructedCallbacks;
+surf_callback(void, HostPtr, e_surf_resource_state_t, e_surf_resource_state_t) hostStateChangedCallbacks;
+surf_callback(void, HostActionPtr, e_surf_action_state_t, e_surf_action_state_t) hostActionStateChangedCallbacks;
-void workstation_parse_init(sg_platf_host_cbarg_t host)
+void host_parse_init(sg_platf_host_cbarg_t host)
{
- surf_workstation_model->createWorkstation(host->id);
+ surf_host_model->createHost(host->id);
}
-void workstation_add_traces(){
- surf_workstation_model->addTraces();
+void host_add_traces(){
+ surf_host_model->addTraces();
}
/*********
* Model *
*********/
-WorkstationModel::WorkstationModel(const char *name)
+HostModel::HostModel(const char *name)
: Model(name)
{
p_cpuModel = surf_cpu_model_pm;
}
-WorkstationModel::WorkstationModel()
-: Model("Workstation") {
+HostModel::HostModel()
+: Model("Host") {
p_cpuModel = surf_cpu_model_pm;
}
-WorkstationModel::~WorkstationModel() {
+HostModel::~HostModel() {
}
/* Each VM has a dummy CPU action on the PM layer. This CPU action works as the
* constraint (capacity) of the VM in the PM layer. If the VM does not have any
* active task, the dummy CPU action must be deactivated, so that the VM does
* not get any CPU share in the PM layer. */
-void WorkstationModel::adjustWeightOfDummyCpuActions()
+void HostModel::adjustWeightOfDummyCpuActions()
{
/* iterate for all virtual machines */
- for (WorkstationVMModel::vm_list_t::iterator iter =
- WorkstationVMModel::ws_vms.begin();
- iter != WorkstationVMModel::ws_vms.end(); ++iter) {
+ for (VMModel::vm_list_t::iterator iter =
+ VMModel::ws_vms.begin();
+ iter != VMModel::ws_vms.end(); ++iter) {
- WorkstationVMPtr ws_vm = &*iter;
+ VMPtr ws_vm = &*iter;
CpuCas01Ptr cpu_cas01 = static_cast<CpuCas01Ptr>(ws_vm->p_cpu);
- xbt_assert(cpu_cas01, "cpu-less workstation");
+ xbt_assert(cpu_cas01, "cpu-less host");
int is_active = lmm_constraint_used(cpu_cas01->getModel()->getMaxminSystem(), cpu_cas01->getConstraint());
// int is_active_old = constraint_is_active(cpu_cas01);
/************
* Resource *
************/
-Workstation::Workstation()
+Host::Host()
{
- surf_callback_emit(workstationCreatedCallbacks, this);
+ surf_callback_emit(hostCreatedCallbacks, this);
}
-Workstation::Workstation(ModelPtr model, const char *name, xbt_dict_t props,
+Host::Host(ModelPtr model, const char *name, xbt_dict_t props,
xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu)
: Resource(model, name, props)
, p_storage(storage), p_netElm(netElm), p_cpu(cpu)
{
p_params.ramsize = 0;
- surf_callback_emit(workstationCreatedCallbacks, this);
+ surf_callback_emit(hostCreatedCallbacks, this);
}
-Workstation::Workstation(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint,
+Host::Host(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint,
xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu)
: Resource(model, name, props, constraint)
, p_storage(storage), p_netElm(netElm), p_cpu(cpu)
{
p_params.ramsize = 0;
- surf_callback_emit(workstationCreatedCallbacks, this);
+ surf_callback_emit(hostCreatedCallbacks, this);
}
-Workstation::~Workstation(){
- surf_callback_emit(workstationDestructedCallbacks, this);
+Host::~Host(){
+ surf_callback_emit(hostDestructedCallbacks, this);
}
-void Workstation::setState(e_surf_resource_state_t state){
+void Host::setState(e_surf_resource_state_t state){
e_surf_resource_state_t old = Resource::getState();
Resource::setState(state);
- surf_callback_emit(workstationStateChangedCallbacks, this, old, state);
+ surf_callback_emit(hostStateChangedCallbacks, this, old, state);
p_cpu->setState(state);
}
-int Workstation::getCore(){
+int Host::getCore(){
return p_cpu->getCore();
}
-double Workstation::getSpeed(double load){
+double Host::getSpeed(double load){
return p_cpu->getSpeed(load);
}
-double Workstation::getAvailableSpeed(){
+double Host::getAvailableSpeed(){
return p_cpu->getAvailableSpeed();
}
-double Workstation::getCurrentPowerPeak()
+double Host::getCurrentPowerPeak()
{
return p_cpu->getCurrentPowerPeak();
}
-double Workstation::getPowerPeakAt(int pstate_index)
+double Host::getPowerPeakAt(int pstate_index)
{
return p_cpu->getPowerPeakAt(pstate_index);
}
-int Workstation::getNbPstates()
+int Host::getNbPstates()
{
return p_cpu->getNbPstates();
}
-void Workstation::setPstate(int pstate_index)
+void Host::setPstate(int pstate_index)
{
p_cpu->setPstate(pstate_index);
}
-int Workstation::getPstate()
+int Host::getPstate()
{
return p_cpu->getPstate();
}
-xbt_dict_t Workstation::getProperties()
+xbt_dict_t Host::getProperties()
{
return p_cpu->getProperties();
}
-StoragePtr Workstation::findStorageOnMountList(const char* mount)
+StoragePtr Host::findStorageOnMountList(const char* mount)
{
StoragePtr st = NULL;
s_mount_t mnt;
return st;
}
-xbt_dict_t Workstation::getMountedStorageList()
+xbt_dict_t Host::getMountedStorageList()
{
s_mount_t mnt;
unsigned int i;
return storage_list;
}
-xbt_dynar_t Workstation::getAttachedStorageList()
+xbt_dynar_t Host::getAttachedStorageList()
{
xbt_lib_cursor_t cursor;
char *key;
return result;
}
-ActionPtr Workstation::open(const char* fullpath) {
+ActionPtr Host::open(const char* fullpath) {
StoragePtr st = NULL;
s_mount_t mnt;
return action;
}
-ActionPtr Workstation::close(surf_file_t fd) {
+ActionPtr Host::close(surf_file_t fd) {
StoragePtr st = findStorageOnMountList(fd->mount);
XBT_DEBUG("CLOSE %s on disk '%s'",fd->name, st->getName());
return st->close(fd);
}
-ActionPtr Workstation::read(surf_file_t fd, sg_size_t size) {
+ActionPtr Host::read(surf_file_t fd, sg_size_t size) {
StoragePtr st = findStorageOnMountList(fd->mount);
XBT_DEBUG("READ %s on disk '%s'",fd->name, st->getName());
return st->read(fd, size);
}
-ActionPtr Workstation::write(surf_file_t fd, sg_size_t size) {
+ActionPtr Host::write(surf_file_t fd, sg_size_t size) {
StoragePtr st = findStorageOnMountList(fd->mount);
XBT_DEBUG("WRITE %s on disk '%s'",fd->name, st->getName());
return st->write(fd, size);
}
-int Workstation::unlink(surf_file_t fd) {
+int Host::unlink(surf_file_t fd) {
if (!fd){
XBT_WARN("No such file descriptor. Impossible to unlink");
return -1;
}
}
-sg_size_t Workstation::getSize(surf_file_t fd){
+sg_size_t Host::getSize(surf_file_t fd){
return fd->size;
}
-xbt_dynar_t Workstation::getInfo( surf_file_t fd)
+xbt_dynar_t Host::getInfo( surf_file_t fd)
{
StoragePtr st = findStorageOnMountList(fd->mount);
sg_size_t *psize = xbt_new(sg_size_t, 1);
return info;
}
-sg_size_t Workstation::fileTell(surf_file_t fd){
+sg_size_t Host::fileTell(surf_file_t fd){
return fd->current_position;
}
-int Workstation::fileSeek(surf_file_t fd, sg_offset_t offset, int origin){
+int Host::fileSeek(surf_file_t fd, sg_offset_t offset, int origin){
switch (origin) {
case SEEK_SET:
}
}
-int Workstation::fileMove(surf_file_t fd, const char* fullpath){
+int Host::fileMove(surf_file_t fd, const char* fullpath){
/* Check if the new full path is on the same mount point */
if(!strncmp((const char*)fd->mount, fullpath, strlen(fd->mount))) {
sg_size_t *psize, *new_psize;
}
}
-xbt_dynar_t Workstation::getVms()
+xbt_dynar_t Host::getVms()
{
- xbt_dynar_t dyn = xbt_dynar_new(sizeof(WorkstationVMPtr), NULL);
+ xbt_dynar_t dyn = xbt_dynar_new(sizeof(VMPtr), NULL);
/* iterate for all virtual machines */
- for (WorkstationVMModel::vm_list_t::iterator iter =
- WorkstationVMModel::ws_vms.begin();
- iter != WorkstationVMModel::ws_vms.end(); ++iter) {
+ for (VMModel::vm_list_t::iterator iter =
+ VMModel::ws_vms.begin();
+ iter != VMModel::ws_vms.end(); ++iter) {
- WorkstationVMPtr ws_vm = &*iter;
+ VMPtr ws_vm = &*iter;
if (this == ws_vm->p_subWs)
xbt_dynar_push(dyn, &ws_vm);
}
return dyn;
}
-void Workstation::getParams(ws_params_t params)
+void Host::getParams(ws_params_t params)
{
*params = p_params;
}
-void Workstation::setParams(ws_params_t params)
+void Host::setParams(ws_params_t params)
{
/* may check something here. */
p_params = *params;
* Action *
**********/
-void WorkstationAction::setState(e_surf_action_state_t state){
+void HostAction::setState(e_surf_action_state_t state){
e_surf_action_state_t old = getState();
Action::setState(state);
- surf_callback_emit(workstationActionStateChangedCallbacks, this, old, state);
+ surf_callback_emit(hostActionStateChangedCallbacks, this, old, state);
}
