more chaining for CPUs too

[simgrid.git] / include / simgrid / s4u / Host.hpp

diff --git a/include/simgrid/s4u/Host.hpp b/include/simgrid/s4u/Host.hpp
index eede647..f4a1174 100644 (file)
--- a/include/simgrid/s4u/Host.hpp
+++ b/include/simgrid/s4u/Host.hpp
@@ -45,11 +45,8 @@ public:
   explicit Host(const std::string& name);
 
 protected:
-  virtual ~Host();
-  void set_netpoint(kernel::routing::NetPoint* netpoint) { pimpl_netpoint_ = netpoint; }
-
-private:
-  bool currently_destroying_ = false;
+  virtual ~Host(); // Call destroy() instead of manually deleting it.
+  Host* set_netpoint(kernel::routing::NetPoint* netpoint);
 #endif
 
 public:
@@ -103,12 +100,12 @@ public:
   bool is_on() const;
 
   const char* get_property(const std::string& key) const;
-  void set_property(const std::string& key, const std::string& value);
+  Host* set_property(const std::string& key, const std::string& value);
   const std::unordered_map<std::string, std::string>* get_properties() const;
-  void set_properties(const std::unordered_map<std::string, std::string>& properties);
+  Host* set_properties(const std::unordered_map<std::string, std::string>& properties);
 
-  void set_state_profile(kernel::profile::Profile* p);
-  void set_speed_profile(kernel::profile::Profile* p);
+  Host* set_state_profile(kernel::profile::Profile* p);
+  Host* 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.
    *
@@ -131,8 +128,11 @@ public:
    * 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;
+  Host* set_core_count(int core_count);
+
   /** Returns the current computation load (in flops per second)
    *
    * The external load (coming from an availability trace) is not taken in account.
@@ -140,38 +140,25 @@ public:
    */
   double get_load() const;
 
-  double get_pstate_speed(int pstate_index) const;
   int get_pstate_count() const;
-  void set_pstate(int pstate_index);
   int get_pstate() const;
+  double get_pstate_speed(int pstate_index) const;
+  Host* set_pstate(int pstate_index);
 
   std::vector<Disk*> get_disks() const;
+  Disk* create_disk(const std::string& name, double read_bandwidth, double write_bandwidth);
   void add_disk(const Disk* disk);
   void remove_disk(const std::string& disk_name);
 
   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;
-  /** 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.
-   */
-  CommPtr 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);
-  }
+  XBT_ATTRIB_DEPRECATED_v331("Please use Comm::sendto()") void sendto(Host* dest, double byte_amount);
+
+  XBT_ATTRIB_DEPRECATED_v331("Please use Comm::sendto_async()") CommPtr sendto_async(Host* dest, double byte_amount);
+
+  XBT_ATTRIB_DEPRECATED_v330("Please use Host::sendto()") void send_to(Host* dest, double byte_amount);
 #endif
 
   NetZone* get_englobing_zone();
@@ -182,6 +169,7 @@ public:
    */
   void execute(double flops) const;
   /** Start an asynchronous computation on that host (possibly remote) */
+  ExecPtr exec_init(double flops_amounts) const;
   ExecPtr exec_async(double flops_amounts) const;
 
   /** Block the calling actor on an execution located on the called host (with explicit priority) */