/** \ingroup msg_host_management * \brief Return the content of mounted storages on an host. * \param host a host * \return a dict containing content (as a dict) of all storages mounted on the host */ xbt_dict_t MSG_host_get_storage_content(msg_host_t host) { xbt_assert((host != NULL), "Invalid parameters"); xbt_dict_t contents = xbt_dict_new_homogeneous(NULL); msg_storage_t storage; char* storage_name; char* mount_name; xbt_dict_cursor_t cursor = NULL; xbt_dict_t storage_list = simcall_host_get_mounted_storage_list(host); xbt_dict_foreach(storage_list,cursor,mount_name,storage_name){ storage = (msg_storage_t)xbt_lib_get_elm_or_null(storage_lib,storage_name); xbt_dict_t content = simcall_storage_get_content(storage); xbt_dict_set(contents,mount_name, content,NULL); }
/* Creates a workstation and registers it in SD. */ SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) { SD_workstation_priv_t workstation; const char *name; workstation = xbt_new(s_SD_workstation_priv_t, 1); workstation->data = data; /* user data */ workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS; /* default mode is shared */ workstation->task_fifo = NULL; workstation->current_task = NULL; name = surf_resource_name(surf_workstation); xbt_lib_set(host_lib,name,SD_HOST_LEVEL,workstation); return xbt_lib_get_elm_or_null(host_lib,name); }
/** \ingroup msg_file_management * \brief Write into a file (local or remote) * * \param size of the file to write * \param fd is a the file descriptor * \return the number of bytes successfully write or -1 if an error occurred */ sg_size_t MSG_file_write(msg_file_t fd, sg_size_t size) { msg_file_priv_t file_priv = MSG_file_priv(fd); sg_size_t write_size, offset; /* Find the host where the file is physically located (remote or local)*/ msg_storage_t storage_src =(msg_storage_t) xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId); msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src); msg_host_t attached_host = MSG_get_host_by_name(storage_priv_src->hostname); if(strcmp(storage_priv_src->hostname, MSG_host_get_name(MSG_host_self()))){ /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */ XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", storage_priv_src->hostname, size); msg_host_t *m_host_list = NULL; m_host_list = calloc(2, sizeof(msg_host_t)); m_host_list[0] = MSG_host_self(); m_host_list[1] = attached_host; double flops_amount[] = { 0, 0 }; double bytes_amount[] = { 0, (double)size, 0, 0 }; msg_task_t task = MSG_parallel_task_create("file transfer for write", 2, m_host_list, flops_amount, bytes_amount, NULL); msg_error_t transfer = MSG_parallel_task_execute(task); MSG_task_destroy(task); free(m_host_list); if(transfer != MSG_OK){ if (transfer == MSG_HOST_FAILURE) XBT_WARN("Transfer error, %s remote host just turned off!", MSG_host_get_name(attached_host)); if (transfer == MSG_TASK_CANCELED) XBT_WARN("Transfer error, task has been canceled!"); return -1; } } /* Write file on local or remote host */ offset = simcall_file_tell(file_priv->simdata->smx_file); write_size = simcall_file_write(file_priv->simdata->smx_file, size, attached_host); file_priv->size = offset+write_size; return write_size; }
/** * \brief Returns a workstation given its name * * If there is no such workstation, the function returns \c NULL. * * \param name workstation name * \return the workstation, or \c NULL if there is no such workstation */ SD_workstation_t SD_workstation_get_by_name(const char *name) { return xbt_lib_get_elm_or_null(host_lib, name); }
/* * A surf level object will be useless in the upper layer. Returing the * dict_elm of the host. **/ surf_resource_t VM::getPm() { return xbt_lib_get_elm_or_null(host_lib, p_subWs->getName()); }
/** \ingroup msg_host_management * \brief Finds a msg_host_t using its name. * * This is a name directory service * \param name the name of an host. * \return the corresponding host */ msg_host_t MSG_get_host_by_name(const char *name) { return (msg_host_t) xbt_lib_get_elm_or_null(host_lib,name); }
double VMHL13Model::shareResources(double now) { /* TODO: udpate action's cost with the total cost of processes on the VM. */ /* 0. Make sure that we already calculated the resource share at the physical * machine layer. */ { _XBT_GNUC_UNUSED ModelPtr ws_model = surf_host_model; _XBT_GNUC_UNUSED ModelPtr vm_ws_model = surf_vm_model; _XBT_GNUC_UNUSED unsigned int index_of_pm_ws_model = xbt_dynar_search(model_list_invoke, &ws_model); _XBT_GNUC_UNUSED unsigned int index_of_vm_ws_model = xbt_dynar_search(model_list_invoke, &vm_ws_model); xbt_assert((index_of_pm_ws_model < index_of_vm_ws_model), "Cannot assume surf_host_model comes before"); /* Another option is that we call sub_ws->share_resource() here. The * share_resource() function has no side-effect. We can call it here to * ensure that. */ } /* 1. Now we know how many resource should be assigned to each virtual * machine. We update constraints of the virtual machine layer. * * * If we have two virtual machine (VM1 and VM2) on a physical machine (PM1). * X1 + X2 = C (Equation 1) * where * the resource share of VM1: X1 * the resource share of VM2: X2 * the capacity of PM1: C * * Then, if we have two process (P1 and P2) on VM1. * X1_1 + X1_2 = X1 (Equation 2) * where * the resource share of P1: X1_1 * the resource share of P2: X1_2 * the capacity of VM1: X1 * * Equation 1 was solved in the physical machine layer. * Equation 2 is solved in the virtual machine layer (here). * X1 must be passed to the virtual machine laye as a constraint value. * **/ /* iterate for all virtual machines */ for (VMModel::vm_list_t::iterator iter = VMModel::ws_vms.begin(); iter != VMModel::ws_vms.end(); ++iter) { VMPtr ws_vm = &*iter; CpuPtr cpu = ws_vm->p_cpu; xbt_assert(cpu, "cpu-less host"); double solved_value = get_solved_value(ws_vm->p_action); XBT_DEBUG("assign %f to vm %s @ pm %s", solved_value, ws_vm->getName(), ws_vm->p_subWs->getName()); // TODO: check lmm_update_constraint_bound() works fine instead of the below manual substitution. // cpu_cas01->constraint->bound = solved_value; xbt_assert(cpu->getModel() == surf_cpu_model_vm); lmm_system_t vcpu_system = cpu->getModel()->getMaxminSystem(); lmm_update_constraint_bound(vcpu_system, cpu->getConstraint(), virt_overhead * solved_value); } /* 2. Calculate resource share at the virtual machine layer. */ adjustWeightOfDummyCpuActions(); double min_by_cpu = p_cpuModel->shareResources(now); double min_by_net = (strcmp(surf_network_model->getName(), "network NS3")) ? surf_network_model->shareResources(now) : -1; double min_by_sto = -1; if (p_cpuModel == surf_cpu_model_pm) min_by_sto = surf_storage_model->shareResources(now); XBT_DEBUG("model %p, %s min_by_cpu %f, %s min_by_net %f, %s min_by_sto %f", this, surf_cpu_model_pm->getName(), min_by_cpu, surf_network_model->getName(), min_by_net, surf_storage_model->getName(), min_by_sto); double ret = max(max(min_by_cpu, min_by_net), min_by_sto); if (min_by_cpu >= 0.0 && min_by_cpu < ret) ret = min_by_cpu; if (min_by_net >= 0.0 && min_by_net < ret) ret = min_by_net; if (min_by_sto >= 0.0 && min_by_sto < ret) ret = min_by_sto; /* FIXME: 3. do we have to re-initialize our cpu_action object? */ #if 0 /* iterate for all virtual machines */ for (VMModel::vm_list_t::iterator iter = VMModel::ws_vms.begin(); iter != VMModel::ws_vms.end(); ++iter) { { #if 0 VM2013Ptr ws_vm2013 = static_cast<VM2013Ptr>(&*iter); XBT_INFO("cost %f remains %f start %f finish %f", ws_vm2013->cpu_action->cost, ws_vm2013->cpu_action->remains, ws_vm2013->cpu_action->start, ws_vm2013->cpu_action->finish ); #endif #if 0 void *ind_sub_host = xbt_lib_get_elm_or_null(host_lib, ws_vm2013->sub_ws->generic_resource.getName); surf_cpu_model_pm->action_unref(ws_vm2013->cpu_action); /* FIXME: this means busy loop? */ // ws_vm2013->cpu_action = surf_cpu_model_pm->extension.cpu.execute(ind_sub_host, GUESTOS_NOISE); ws_vm2013->cpu_action = surf_cpu_model_pm->extension.cpu.execute(ind_sub_host, 0); #endif } } #endif return ret; }