X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/84402e8e2ee2a2d0bef25fdceb0a263ed8b471f6..978c69bf0a49adab13df9ba6dabcd0998485030b:/include/simgrid/s4u/VirtualMachine.hpp diff --git a/include/simgrid/s4u/VirtualMachine.hpp b/include/simgrid/s4u/VirtualMachine.hpp index 0bbc6ae4bf..b26902226d 100644 --- a/include/simgrid/s4u/VirtualMachine.hpp +++ b/include/simgrid/s4u/VirtualMachine.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2015-2023. The SimGrid Team. All rights reserved. */ /* 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. */ @@ -8,9 +8,19 @@ #include #include +#include -namespace simgrid { -namespace s4u { +namespace simgrid::s4u { + +/** @brief Host extension for the VMs */ +class VmHostExt { +public: + static xbt::Extension EXTENSION_ID; + + sg_size_t ramsize = 0; /* available ramsize (0= not taken into account) */ + bool overcommit = true; /* Whether the host allows overcommiting more VM than the avail ramsize allows */ + static void ensureVmExtInstalled(); +}; /** @ingroup s4u_api * @@ -21,25 +31,49 @@ namespace s4u { * */ class XBT_PUBLIC VirtualMachine : public s4u::Host { - vm::VirtualMachineImpl* const pimpl_vm_; - virtual ~VirtualMachine(); + kernel::resource::VirtualMachineImpl* const pimpl_vm_; -public: - explicit VirtualMachine(const std::string& name, Host* physical_host, int core_amount); - explicit VirtualMachine(const std::string& name, Host* physical_host, int core_amount, size_t ramsize); + /* Signals about the life cycle of the VM */ + static xbt::signal on_vm_creation; + static xbt::signal on_start; + xbt::signal on_this_start; + static xbt::signal on_started; + xbt::signal on_this_started; + static xbt::signal on_shutdown; + xbt::signal on_this_shutdown; + static xbt::signal on_suspend; + xbt::signal on_this_suspend; + static xbt::signal on_resume; + xbt::signal on_this_resume; + static xbt::signal on_migration_start; + xbt::signal on_this_migration_start; + static xbt::signal on_migration_end; + xbt::signal on_this_migration_end; + static xbt::signal on_vm_destruction; + xbt::signal on_this_vm_destruction; +#ifndef DOXYGEN + friend kernel::resource::VirtualMachineImpl; // calls signals from Impl + friend kernel::resource::HostImpl; // call private constructor + explicit VirtualMachine(kernel::resource::VirtualMachineImpl* impl); +#endif + +public: +#ifndef DOXYGEN // No copy/move VirtualMachine(VirtualMachine const&) = delete; VirtualMachine& operator=(VirtualMachine const&) = delete; +#endif - enum class state { + // enum class State { ... } + XBT_DECLARE_ENUM_CLASS(State, CREATED, /**< created, but not yet started */ RUNNING, SUSPENDED, /**< Suspend/resume does not involve disk I/O, so we assume there is no transition states. */ DESTROYED - }; + ); - vm::VirtualMachineImpl* get_impl() const { return pimpl_vm_; } + kernel::resource::VirtualMachineImpl* get_vm_impl() const { return pimpl_vm_; } void start(); void suspend(); void resume(); @@ -47,21 +81,81 @@ public: void destroy() override; Host* get_pm() const; - void set_pm(Host* pm); + VirtualMachine* set_pm(Host* pm); size_t get_ramsize() const; - void set_ramsize(size_t ramsize); - void set_bound(double bound); + VirtualMachine* set_ramsize(size_t ramsize); + VirtualMachine* set_bound(double bound); + void start_migration() const; + void end_migration() const; - VirtualMachine::state get_state(); - static xbt::signal on_start; - static xbt::signal on_started; - static xbt::signal on_shutdown; - static xbt::signal on_suspend; - static xbt::signal on_resume; - static xbt::signal on_migration_start; - static xbt::signal on_migration_end; + State get_state() const; + + /* Callbacks on signals */ + /*! \static Add a callback fired when any VM is created */ + static void on_creation_cb(const std::function& cb) { on_vm_creation.connect(cb); } + /*! \static Add a callback fired when any VM starts */ + static void on_start_cb(const std::function& cb) { on_start.connect(cb); } + /*! Add a callback fired when this specific VM starts */ + void on_this_start_cb(const std::function& cb) + { + on_this_start.connect(cb); + } + /*! \static Add a callback fired when any VM is actually started */ + static void on_started_cb(const std::function& cb) { on_started.connect(cb); } + /*! Add a callback fired when this specific VM is actually started */ + void on_this_started_cb(const std::function& cb) + { + on_this_started.connect(cb); + } + /*! \static Add a callback fired when any VM is shut down */ + static void on_shutdown_cb(const std::function& cb) { on_shutdown.connect(cb); } + /*! Add a callback fired when this specific VM is shut down */ + void on_this_shutdown_cb(const std::function& cb) + { + on_this_shutdown.connect(cb); + } + /*! \static Add a callback fired when any VM is suspended*/ + static void on_suspend_cb(const std::function& cb) { on_suspend.connect(cb); } + /*! Add a callback fired when this specific VM is suspended*/ + void on_this_suspend_cb(const std::function& cb) + { + on_this_suspend.connect(cb); + } + /*! \static Add a callback fired when any VM is resumed*/ + static void on_resume_cb(const std::function& cb) { on_resume.connect(cb); } + /*! Add a callback fired when this specific VM is resumed*/ + void on_this_resume_cb(const std::function& cb) + { + on_this_resume.connect(cb); + } + /*! \static Add a callback fired when any VM is destroyed*/ + static void on_destruction_cb(const std::function& cb) { on_vm_destruction.connect(cb); } + /*! Add a callback fired when this specific VM is destroyed*/ + void on_this_destruction_cb(const std::function& cb) + { + on_this_vm_destruction.connect(cb); + } + /*! \static Add a callback fired when any VM starts a migration*/ + static void on_migration_start_cb(const std::function& cb) + { + on_migration_start.connect(cb); + } + /*! Add a callback fired when this specific VM starts a migration*/ + void on_this_migration_start_cb(const std::function& cb) + { + on_this_migration_start.connect(cb); + } + /*! \static Add a callback fired when any VM ends a migration*/ + static void on_migration_end_cb(const std::function& cb) + { + on_migration_end.connect(cb); + } + /*! Add a callback fired when this specific VM ends a migration*/ + void on_this_migration_end_cb(const std::function& cb) + { + on_this_migration_end.connect(cb); + } }; -} // namespace s4u -} // namespace simgrid +} // namespace simgrid::s4u #endif