X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/386393c4094b45cce01179befdd3d519b320db04..978c69bf0a49adab13df9ba6dabcd0998485030b:/include/simgrid/s4u/VirtualMachine.hpp diff --git a/include/simgrid/s4u/VirtualMachine.hpp b/include/simgrid/s4u/VirtualMachine.hpp index 73f03e5cf8..b26902226d 100644 --- a/include/simgrid/s4u/VirtualMachine.hpp +++ b/include/simgrid/s4u/VirtualMachine.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2021. 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. */ @@ -10,8 +10,17 @@ #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 * @@ -22,12 +31,34 @@ namespace s4u { * */ class XBT_PUBLIC VirtualMachine : public s4u::Host { - vm::VirtualMachineImpl* const pimpl_vm_; + 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; @@ -41,11 +72,8 @@ public: SUSPENDED, /**< Suspend/resume does not involve disk I/O, so we assume there is no transition states. */ DESTROYED ); -#ifndef DOXYGEN - using state XBT_ATTRIB_DEPRECATED_v332("Please use VirtualMachine::State") = State; -#endif - vm::VirtualMachineImpl* get_vm_impl() const { return pimpl_vm_; } + kernel::resource::VirtualMachineImpl* get_vm_impl() const { return pimpl_vm_; } void start(); void suspend(); void resume(); @@ -57,19 +85,77 @@ public: size_t get_ramsize() const; VirtualMachine* set_ramsize(size_t ramsize); VirtualMachine* set_bound(double bound); + void start_migration() const; + void end_migration() const; State get_state() const; - static xbt::signal on_creation; - 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; - static xbt::signal on_destruction; + + /* 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