if (not simgrid::vm::VmDirtyPageTrackingExt::EXTENSION_ID.valid()) {
simgrid::vm::VmDirtyPageTrackingExt::EXTENSION_ID =
simgrid::vm::VirtualMachineImpl::extension_create<simgrid::vm::VmDirtyPageTrackingExt>();
- simgrid::vm::VirtualMachineImpl::onVmCreation.connect(&onVirtualMachineCreation);
+ simgrid::vm::VirtualMachineImpl::on_creation.connect(&onVirtualMachineCreation);
simgrid::kernel::activity::ExecImpl::onCreation.connect(&onExecCreation);
simgrid::kernel::activity::ExecImpl::onCompletion.connect(&onExecCompletion);
}
}
}
-
+namespace simgrid {
+namespace vm {
/*************
* Callbacks *
*************/
-
-simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> simgrid::vm::VirtualMachineImpl::onVmCreation;
-simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> simgrid::vm::VirtualMachineImpl::onVmDestruction;
-simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> simgrid::vm::VirtualMachineImpl::onVmStateChange;
-
-namespace simgrid {
-namespace vm {
+simgrid::xbt::signal<void(VirtualMachineImpl*)> VirtualMachineImpl::on_creation;
+simgrid::xbt::signal<void(VirtualMachineImpl*)> VirtualMachineImpl::on_destruction;
+simgrid::xbt::signal<void(VirtualMachineImpl*)> VirtualMachineImpl::on_state_change;
/*********
* Model *
*********/
vm->shutdown();
}
}
+
VMModel::VMModel()
{
s4u::Host::on_state_change.connect(hostStateChange);
************/
VirtualMachineImpl::VirtualMachineImpl(simgrid::s4u::VirtualMachine* piface, simgrid::s4u::Host* host_PM,
- int coreAmount, size_t ramsize)
- : HostImpl(piface), hostPM_(host_PM), coreAmount_(coreAmount), ramsize_(ramsize)
+ int core_amount, size_t ramsize)
+ : HostImpl(piface), physical_host_(host_PM), core_amount_(core_amount), ramsize_(ramsize)
{
/* Register this VM to the list of all VMs */
allVms_.push_back(piface);
/* We create cpu_action corresponding to a VM process on the host operating system. */
/* TODO: we have to periodically input GUESTOS_NOISE to the system? how ? */
- action_ = host_PM->pimpl_cpu->execution_start(0, coreAmount);
+ action_ = host_PM->pimpl_cpu->execution_start(0, core_amount);
- XBT_VERB("Create VM(%s)@PM(%s)", piface->get_cname(), hostPM_->get_cname());
- onVmCreation(this);
+ XBT_VERB("Create VM(%s)@PM(%s)", piface->get_cname(), physical_host_->get_cname());
+ on_creation(this);
}
/** @brief A physical host does not disappear in the current SimGrid code, but a VM may disappear during a simulation */
VirtualMachineImpl::~VirtualMachineImpl()
{
- onVmDestruction(this);
+ on_destruction(this);
/* I was already removed from the allVms set if the VM was destroyed cleanly */
auto iter = find(allVms_.begin(), allVms_.end(), piface_);
if (iter != allVms_.end())
xbt_assert(ret == 1, "Bug: some resource still remains");
}
-e_surf_vm_state_t VirtualMachineImpl::getState()
-{
- return vmState_;
-}
-
-void VirtualMachineImpl::setState(e_surf_vm_state_t state)
-{
- vmState_ = state;
-}
-
void VirtualMachineImpl::suspend(smx_actor_t issuer)
{
- if (getState() != SURF_VM_STATE_RUNNING)
+ if (get_state() != SURF_VM_STATE_RUNNING)
THROWF(vm_error, 0, "Cannot suspend VM %s: it is not running.", piface_->get_cname());
if (issuer->host == piface_)
THROWF(vm_error, 0, "Actor %s cannot suspend the VM %s in which it runs", issuer->get_cname(),
XBT_DEBUG("suspend all processes on the VM done done");
- vmState_ = SURF_VM_STATE_SUSPENDED;
+ vm_state_ = SURF_VM_STATE_SUSPENDED;
}
void VirtualMachineImpl::resume()
{
- if (getState() != SURF_VM_STATE_SUSPENDED)
+ if (get_state() != SURF_VM_STATE_SUSPENDED)
THROWF(vm_error, 0, "Cannot resume VM %s: it was not suspended", piface_->get_cname());
auto& process_list = piface_->extension<simgrid::simix::Host>()->process_list;
smx_process.resume();
}
- vmState_ = SURF_VM_STATE_RUNNING;
+ vm_state_ = SURF_VM_STATE_RUNNING;
}
/** @brief Power off a VM.
*/
void VirtualMachineImpl::shutdown(smx_actor_t issuer)
{
- if (getState() != SURF_VM_STATE_RUNNING) {
+ if (get_state() != SURF_VM_STATE_RUNNING) {
const char* stateName = "(unknown state)";
- switch (getState()) {
+ switch (get_state()) {
case SURF_VM_STATE_CREATED:
stateName = "created, but not yet started";
break;
SIMIX_process_kill(&smx_process, issuer);
}
- setState(SURF_VM_STATE_DESTROYED);
+ set_state(SURF_VM_STATE_DESTROYED);
/* FIXME: we may have to do something at the surf layer, e.g., vcpu action */
}
-/** @brief returns the physical machine on which the VM is running **/
-s4u::Host* VirtualMachineImpl::getPm()
-{
- return hostPM_;
-}
-
/** @brief Change the physical host on which the given VM is running
*
* This is an instantaneous migration.
*/
-void VirtualMachineImpl::setPm(s4u::Host* destination)
+void VirtualMachineImpl::set_physical_host(s4u::Host* destination)
{
const char* vm_name = piface_->get_cname();
- const char* pm_name_src = hostPM_->get_cname();
+ const char* pm_name_src = physical_host_->get_cname();
const char* pm_name_dst = destination->get_cname();
/* update net_elm with that of the destination physical host */
piface_->pimpl_netpoint = destination->pimpl_netpoint;
- hostPM_ = destination;
+ physical_host_ = destination;
/* Update vcpu's action for the new pm */
/* create a cpu action bound to the pm model at the destination. */
surf::CpuAction* new_cpu_action =
- static_cast<surf::CpuAction*>(destination->pimpl_cpu->execution_start(0, this->coreAmount_));
+ static_cast<surf::CpuAction*>(destination->pimpl_cpu->execution_start(0, this->core_amount_));
if (action_->get_remains_no_update() > 0)
XBT_CRITICAL("FIXME: need copy the state(?), %f", action_->get_remains_no_update());
new_cpu_action->set_bound(old_bound);
}
- XBT_ATTRIB_UNUSED int ret = action_->unref();
- xbt_assert(ret == 1, "Bug: some resource still remains");
+ xbt_assert(action_->unref() == 1, "Bug: some resource still remains");
action_ = new_cpu_action;
XBT_DEBUG("migrate VM(%s): change PM (%s to %s)", vm_name, pm_name_src, pm_name_dst);
}
-void VirtualMachineImpl::setBound(double bound)
+void VirtualMachineImpl::set_bound(double bound)
{
action_->set_bound(bound);
}
friend simgrid::s4u::VirtualMachine;
public:
- explicit VirtualMachineImpl(s4u::VirtualMachine * piface, s4u::Host * host, int coreAmount, size_t ramsize);
+ explicit VirtualMachineImpl(s4u::VirtualMachine* piface, s4u::Host* host, int core_amount, size_t ramsize);
~VirtualMachineImpl();
- /** @brief Suspend the VM */
- virtual void suspend(simgrid::kernel::actor::ActorImpl* issuer);
+ /** @brief Callbacks fired after VM creation. Signature: `void(VirtualMachineImpl*)` */
+ static xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> on_creation;
+ /** @brief Callbacks fired after VM destruction. Signature: `void(VirtualMachineImpl*)` */
+ static xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> on_destruction;
+ /** @brief Callbacks after VM State changes. Signature: `void(VirtualMachineImpl*)` */
+ static xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> on_state_change;
- /** @brief Resume the VM */
+ virtual void suspend(kernel::actor::ActorImpl* issuer);
virtual void resume();
-
- /** @brief Shutdown the VM */
- virtual void shutdown(simgrid::kernel::actor::ActorImpl* issuer);
+ virtual void shutdown(kernel::actor::ActorImpl* issuer);
/** @brief Change the physical host on which the given VM is running */
- virtual void setPm(s4u::Host* dest);
+ virtual void set_physical_host(s4u::Host* dest);
+ /** @brief Get the physical host on which the given VM is running */
+ s4u::Host* get_physical_host() { return physical_host_; }
+
+ sg_size_t get_ramsize() { return ramsize_; }
+ void set_ramsize(sg_size_t ramsize) { ramsize_ = ramsize; }
- /** @brief Get the physical machine hosting the VM */
- s4u::Host* getPm();
+ e_surf_vm_state_t get_state() { return vm_state_; }
+ void set_state(e_surf_vm_state_t state) { vm_state_ = state; }
- sg_size_t getRamsize() { return ramsize_; }
- void setRamsize(sg_size_t ramsize) { ramsize_ = ramsize; }
+ int get_core_amount() { return core_amount_; }
- virtual void setBound(double bound);
+ virtual void set_bound(double bound);
/* The vm object of the lower layer */
kernel::resource::Action* action_ = nullptr;
-
- e_surf_vm_state_t getState();
- void setState(e_surf_vm_state_t state);
static std::deque<s4u::VirtualMachine*> allVms_;
- int coreAmount() { return coreAmount_; }
-
- bool isMigrating = false;
- /*************
- * Callbacks *
- *************/
- /** @ingroup SURF_callbacks
- * @brief Callbacks fired after VM creation. Signature: `void(VirtualMachine*)`
- */
- static simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> onVmCreation;
-
- /** @ingroup SURF_callbacks
- * @brief Callbacks fired after VM destruction. Signature: `void(VirtualMachine*)`
- */
- static simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> onVmDestruction;
-
- /** @ingroup SURF_callbacks
- * @brief Callbacks after VM State changes. Signature: `void(VirtualMachine*)`
- */
- static simgrid::xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> onVmStateChange;
+ bool is_migrating_ = false;
private:
- simgrid::s4u::Host* hostPM_;
- int coreAmount_;
+ s4u::Host* physical_host_;
+ int core_amount_;
size_t ramsize_ = 0;
- e_surf_vm_state_t vmState_ = SURF_VM_STATE_CREATED;
+ e_surf_vm_state_t vm_state_ = SURF_VM_STATE_CREATED;
};
/*********
vm_->resume();
// Now the VM is running on the new host (the migration is completed) (even if the SRC crash)
- vm_->getImpl()->isMigrating = false;
+ vm_->getImpl()->is_migrating_ = false;
XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", vm_->get_cname(), src_pm_->get_cname(), dst_pm_->get_cname());
if (TRACE_vm_is_enabled()) {
static void onVirtualMachineShutdown(simgrid::s4u::VirtualMachine& vm)
{
- if (vm.getImpl()->isMigrating) {
+ if (vm.getImpl()->is_migrating_) {
vm.extension<simgrid::vm::VmMigrationExt>()->rx_->kill();
vm.extension<simgrid::vm::VmMigrationExt>()->tx_->kill();
vm.extension<simgrid::vm::VmMigrationExt>()->issuer_->kill();
- vm.getImpl()->isMigrating = false;
+ vm.getImpl()->is_migrating_ = false;
}
}
int sg_vm_is_migrating(simgrid::s4u::VirtualMachine* vm)
{
- return vm->getImpl()->isMigrating;
+ return vm->getImpl()->is_migrating_;
}
void sg_vm_migrate(simgrid::s4u::VirtualMachine* vm, simgrid::s4u::Host* dst_pm)
THROWF(vm_error, 0, "Cannot migrate VM '%s' to host '%s', which is offline.", vm->get_cname(), dst_pm->get_cname());
if (vm->getState() != SURF_VM_STATE_RUNNING)
THROWF(vm_error, 0, "Cannot migrate VM '%s' that is not running yet.", vm->get_cname());
- if (vm->getImpl()->isMigrating)
+ if (vm->getImpl()->is_migrating_)
THROWF(vm_error, 0, "Cannot migrate VM '%s' that is already migrating.", vm->get_cname());
- vm->getImpl()->isMigrating = true;
+ vm->getImpl()->is_migrating_ = true;
std::string rx_name =
std::string("__pr_mig_rx:") + vm->get_cname() + "(" + src_pm->get_cname() + "-" + dst_pm->get_cname() + ")";
tx->join();
rx->join();
- vm->getImpl()->isMigrating = false;
+ vm->getImpl()->is_migrating_ = false;
}
simgrid::simix::simcall([this]() {
simgrid::vm::VmHostExt::ensureVmExtInstalled();
- simgrid::s4u::Host* pm = this->pimpl_vm_->getPm();
+ simgrid::s4u::Host* pm = this->pimpl_vm_->get_physical_host();
if (pm->extension<simgrid::vm::VmHostExt>() == nullptr)
pm->extension_set(new simgrid::vm::VmHostExt());
}
}
- this->pimpl_vm_->setState(SURF_VM_STATE_RUNNING);
+ this->pimpl_vm_->set_state(SURF_VM_STATE_RUNNING);
});
on_started(*this);
simgrid::s4u::Host* VirtualMachine::getPm()
{
- return pimpl_vm_->getPm();
+ return pimpl_vm_->get_physical_host();
}
void VirtualMachine::setPm(simgrid::s4u::Host* pm)
{
- simgrid::simix::simcall([this, pm]() { pimpl_vm_->setPm(pm); });
+ simgrid::simix::simcall([this, pm]() { pimpl_vm_->set_physical_host(pm); });
}
e_surf_vm_state_t VirtualMachine::getState()
{
- return simgrid::simix::simcall([this]() { return pimpl_vm_->getState(); });
+ return simgrid::simix::simcall([this]() { return pimpl_vm_->get_state(); });
}
size_t VirtualMachine::getRamsize()
{
- return pimpl_vm_->getRamsize();
+ return pimpl_vm_->get_ramsize();
}
void VirtualMachine::setRamsize(size_t ramsize)
{
- pimpl_vm_->setRamsize(ramsize);
+ pimpl_vm_->set_ramsize(ramsize);
}
/** @brief Set a CPU bound for a given VM.
* @ingroup msg_VMs
*/
void VirtualMachine::setBound(double bound)
{
- simgrid::simix::simcall([this, bound]() { pimpl_vm_->setBound(bound); });
+ simgrid::simix::simcall([this, bound]() { pimpl_vm_->set_bound(bound); });
}
} // namespace simgrid
int active_tasks = cpu->get_constraint()->get_variable_amount();
/* The impact of the VM over its PM is the min between its vCPU amount and the amount of tasks it contains */
- int impact = std::min(active_tasks, ws_vm->getImpl()->coreAmount());
+ int impact = std::min(active_tasks, ws_vm->getImpl()->get_core_amount());
XBT_DEBUG("set the weight of the dummy CPU action of VM%p on PM to %d (#tasks: %d)", ws_vm, impact, active_tasks);
if (impact > 0)
