int getPstatesCount() const;
void setPstate(int pstate_index);
int getPstate();
+ std::vector<const char*> get_attached_storages();
+ // XBT_ATTRIB_DEPRECATED_v323("Please use Host::get_attached_storages() instead.")
void getAttachedStorages(std::vector<const char*> * storages);
/** Get an associative list [mount point]->[Storage] of all local mount points.
}
/* 2. Calculate resource share at the virtual machine layer. */
- ignoreEmptyVmInPmLMM();
+ ignore_empty_vm_in_pm_LMM();
/* 3. Ready. Get the next occurring event */
return surf_cpu_model_vm->next_occuring_event(now);
class XBT_PRIVATE VMModel : public surf::HostModel {
public:
VMModel();
- void ignoreEmptyVmInPmLMM() override{};
+ void ignore_empty_vm_in_pm_LMM() override{};
double next_occuring_event(double now) override;
void update_actions_state(double /*now*/, double /*delta*/) override{};
* \brief Returns the list of storages attached to an host.
* \return a vector containing all storages attached to the host
*/
+std::vector<const char*> Host::get_attached_storages()
+{
+ return simgrid::simix::kernelImmediate([this] { return this->pimpl_->get_attached_storages(); });
+}
+
void Host::getAttachedStorages(std::vector<const char*>* storages)
{
- simgrid::simix::kernelImmediate([this, storages] {
- this->pimpl_->getAttachedStorageList(storages);
- });
+ std::vector<const char*> local_storages =
+ simgrid::simix::kernelImmediate([this] { return this->pimpl_->get_attached_storages(); });
+ for (auto elm : local_storages)
+ storages->push_back(elm);
}
std::unordered_map<std::string, Storage*> const& Host::getMountedStorages()
if(task->bytes_amount)
std::copy_n(task->bytes_amount, host_nb * host_nb, bytes_amount);
- task->surf_action = surf_host_model->executeParallelTask(host_nb, hosts, flops_amount, bytes_amount, task->rate);
+ task->surf_action = surf_host_model->execute_parallel(host_nb, hosts, flops_amount, bytes_amount, task->rate);
task->surf_action->set_data(task);
/* set surf's synchro */
sg_host_t* host_list_cpy = new sg_host_t[host_nb];
std::copy_n(host_list, host_nb, host_list_cpy);
- exec->surfAction_ = surf_host_model->executeParallelTask(host_nb, host_list_cpy, flops_amount, bytes_amount, rate);
+ exec->surfAction_ = surf_host_model->execute_parallel(host_nb, host_list_cpy, flops_amount, bytes_amount, rate);
exec->surfAction_->set_data(exec.get());
if (timeout > 0) {
exec->timeoutDetector = host_list[0]->pimpl_cpu->sleep(timeout);
/* 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 HostModel::ignoreEmptyVmInPmLMM()
+void HostModel::ignore_empty_vm_in_pm_LMM()
{
/* iterate for all virtual machines */
for (s4u::VirtualMachine* const& ws_vm : vm::VirtualMachineImpl::allVms_) {
return -1.0;
}
-kernel::resource::Action* HostModel::executeParallelTask(int host_nb, s4u::Host** host_list, double* flops_amount,
- double* bytes_amount, double rate)
+kernel::resource::Action* HostModel::execute_parallel(int host_nb, s4u::Host** host_list, double* flops_amount,
+ double* bytes_amount, double rate)
{
kernel::resource::Action* action = nullptr;
if ((host_nb == 1) && (has_cost(bytes_amount, 0) <= 0)) {
piface_->pimpl_ = this;
}
-void HostImpl::getAttachedStorageList(std::vector<const char*>* storages)
+std::vector<const char*> HostImpl::get_attached_storages()
{
+ std::vector<const char*> storages;
for (auto const& s : storage_)
if (s.second->getHost() == piface_->getCname())
- storages->push_back(s.second->piface_.getCname());
+ storages.push_back(s.second->piface_.getCname());
+ return storages;
}
}
public:
HostModel() : Model() {}
- virtual void ignoreEmptyVmInPmLMM();
- virtual kernel::resource::Action* executeParallelTask(int host_nb, sg_host_t* host_list, double* flops_amount,
- double* bytes_amount, double rate);
+ virtual void ignore_empty_vm_in_pm_LMM();
+ virtual kernel::resource::Action* execute_parallel(int host_nb, sg_host_t* host_list, double* flops_amount,
+ double* bytes_amount, double rate);
};
/************
virtual ~HostImpl() = default;
/** @brief Get the vector of storages (by names) attached to the Host */
- virtual void getAttachedStorageList(std::vector<const char*>* storages);
+ virtual std::vector<const char*> get_attached_storages();
std::map<std::string, simgrid::surf::StorageImpl*> storage_;
simgrid::s4u::Host* piface_ = nullptr;
double HostCLM03Model::next_occuring_event(double now)
{
- ignoreEmptyVmInPmLMM();
+ ignore_empty_vm_in_pm_LMM();
double min_by_cpu = surf_cpu_model_pm->next_occuring_event(now);
double min_by_net =
}
}
-kernel::resource::Action* HostL07Model::executeParallelTask(int host_nb, sg_host_t* host_list, double* flops_amount,
- double* bytes_amount, double rate)
+kernel::resource::Action* HostL07Model::execute_parallel(int host_nb, sg_host_t* host_list, double* flops_amount,
+ double* bytes_amount, double rate)
{
return new L07Action(this, host_nb, host_list, flops_amount, bytes_amount, rate);
}
host_list[1] = dst;
bytes_amount[1] = size;
- return hostModel_->executeParallelTask(2, host_list, flops_amount, bytes_amount, rate);
+ return hostModel_->execute_parallel(2, host_list, flops_amount, bytes_amount, rate);
}
Cpu *CpuL07Model::createCpu(simgrid::s4u::Host *host, std::vector<double> *speedPerPstate, int core)
host_list[0] = getHost();
flops_amount[0] = size;
- return static_cast<CpuL07Model*>(model())->hostModel_->executeParallelTask(1, host_list, flops_amount, nullptr, -1);
+ return static_cast<CpuL07Model*>(model())->hostModel_->execute_parallel(1, host_list, flops_amount, nullptr, -1);
}
kernel::resource::Action* CpuL07::sleep(double duration)
double next_occuring_event(double now) override;
void update_actions_state(double now, double delta) override;
- kernel::resource::Action* executeParallelTask(int host_nb, sg_host_t* host_list, double* flops_amount,
- double* bytes_amount, double rate) override;
+ kernel::resource::Action* execute_parallel(int host_nb, sg_host_t* host_list, double* flops_amount,
+ double* bytes_amount, double rate) override;
};
class CpuL07Model : public CpuModel {
class L07Action : public CpuAction {
friend Action *CpuL07::execution_start(double size);
friend Action *CpuL07::sleep(double duration);
- friend Action *HostL07Model::executeParallelTask(int host_nb, sg_host_t*host_list,
- double *flops_amount, double *bytes_amount, double rate);
+ friend Action* HostL07Model::execute_parallel(int host_nb, sg_host_t* host_list, double* flops_amount,
+ double* bytes_amount, double rate);
+
public:
L07Action(kernel::resource::Model* model, int host_nb, sg_host_t* host_list, double* flops_amount,
double* bytes_amount, double rate);