* @endrst
*/
class XBT_PUBLIC Host : public xbt::Extendable<Host> {
+#ifndef DOXYGEN
friend vm::VMModel; // Use the pimpl_cpu to compute the VM sharing
friend vm::VirtualMachineImpl; // creates the the pimpl_cpu
friend kernel::routing::NetZoneImpl;
public:
explicit Host(const std::string& name);
- /** Host destruction logic */
protected:
virtual ~Host();
void set_netpoint(kernel::routing::NetPoint* netpoint) { pimpl_netpoint_ = netpoint; }
private:
bool currently_destroying_ = false;
+#endif
public:
/** Called on each newly created host */
static xbt::signal<void(Host const&)> on_speed_change;
virtual void destroy();
+#ifndef DOXYGEN
// No copy/move
Host(Host const&) = delete;
Host& operator=(Host const&) = delete;
+#endif
/** Retrieve a host from its name, or return nullptr */
static Host* by_name_or_null(const std::string& name);
void set_state_profile(kernel::profile::Profile* p);
void set_speed_profile(kernel::profile::Profile* p);
+ /** @brief Get the peak computing speed in flops/s at the current pstate, NOT taking the external load into account.
+ *
+ * The amount of flops per second available for computing depends on several things:
+ * - The current pstate determines the maximal peak computing speed (use @ref get_pstate_speed() to retrieve the
+ * computing speed you would get at another pstate)
+ * - If you declared an external load (with @ref simgrid::surf::Cpu::set_speed_profile()), you must multiply the
+ * result of get_speed() by get_available_speed() to retrieve what a new computation would get.
+ *
+ * The remaining speed is then shared between the executions located on this host.
+ * You can retrieve the amount of tasks currently running on this host with @ref get_load().
+ *
+ * The host may have multiple cores, and your executions may be able to use more than a single core.
+ *
+ * Finally, executions of priority 2 get twice the amount of flops than executions of priority 1.
+ */
double get_speed() const;
+ /** @brief Get the available speed ratio, between 0 and 1.
+ *
+ * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_profile()).
+ */
double get_available_speed() const;
+ /** Returns the number of core of the processor. */
int get_core_count() const;
+ /** Returns the current computation load (in flops per second)
+ *
+ * The external load (coming from an availability trace) is not taken in account.
+ * You may also be interested in the load plugin.
+ */
double get_load() const;
double get_pstate_speed(int pstate_index) const;
void route_to(const Host* dest, std::vector<Link*>& links, double* latency) const;
void route_to(const Host* dest, std::vector<kernel::resource::LinkImpl*>& links, double* latency) const;
- void send_to(Host* dest, double byte_amount);
+ /** Do a blocking communication between two arbitrary hosts.
+ *
+ * This starts a blocking communication right away, bypassing the mailbox and actors mechanism.
+ * The calling actor is blocked until the end of the communication; there is really no limit on the hosts involved.
+ * In particular, the actor does not have to be on one of the involved hosts. Enjoy the comfort of the simulator :)
+ */
+ void sendto(Host* dest, double byte_amount);
+
+ /** Do an asynchronous communication between two arbitrary hosts.
+ *
+ * This initializes a communication that completely bypass the mailbox and actors mechanism.
+ * There is really no limit on the hosts involved. In particular, the actor does not have to be on one of the involved
+ * hosts.
+ */
+ ActivityPtr sendto_async(Host* dest, double byte_amount);
+
+#ifndef DOXYGEN
+ XBT_ATTRIB_DEPRECATED_v330("Please use Host::sendto()") void send_to(Host* dest, double byte_amount)
+ {
+ sendto(dest, byte_amount);
+ }
+#endif
NetZone* get_englobing_zone();
/** Block the calling actor on an execution located on the called host
* It is not a problem if the actor is not located on the called host.
* The actor will not be migrated in this case. Such remote execution are easy in simulation.
*/
- void execute(double flops);
+ void execute(double flops) const;
/** Start an asynchronous computation on that host (possibly remote) */
- ExecPtr exec_async(double flops_amounts);
+ ExecPtr exec_async(double flops_amounts) const;
/** Block the calling actor on an execution located on the called host (with explicit priority) */
- void execute(double flops, double priority);
+ void execute(double flops, double priority) const;
private:
xbt::string name_{"noname"};