docs/source/app_s4u.rst

   1 .. _S4U_doc:
   2
   3 The S4U Interface
   4 #################
   5
   6 .. raw:: html
   7
   8    <object id="TOC" data="graphical-toc.svg" type="image/svg+xml"></object>
   9    <script>
  10    window.onload=function() { // Wait for the SVG to be loaded before changing it
  11      var elem=document.querySelector("#TOC").contentDocument.getElementById("ActorBox")
  12      elem.style="opacity:0.93999999;fill:#ff0000;fill-opacity:0.1;stroke:#000000;stroke-width:0.35277778;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1";
  13    }
  14    </script>
  15    <br/>
  16    <br/>
  17
  18 The S4U interface (SimGrid for you) mixes the full power of SimGrid
  19 with the full power of C++. This is the preferred interface to describe
  20 abstract algorithms in the domains of Cloud, P2P, HPC, IoT, and similar
  21 settings.
  22
  23 Since v3.20 (June 2018), S4U is the way to go for long-term
  24 projects. It is feature complete, but may still evolve slightly in
  25 future releases. It can already be used to do everything that can be
  26 done in SimGrid, but you may have to adapt your code in future
  27 releases. When this happens, compiling your code will produce
  28 deprecation warnings for 4 releases (one year) before the removal of
  29 the old symbols.
  30 If you want an API that will never ever evolve in the future, you
  31 should use the :ref:`deprecated MSG API <MSG_doc>` instead.
  32
  33 Main Concepts
  34 *************
  35
  36 A typical SimGrid simulation is composed of several |API_s4u_Actors|_, that
  37 execute user-provided functions. The actors have to explicitly use the
  38 S4U interface to express their :ref:`computation <API_s4u_Exec>`,
  39 :ref:`communication <API_s4u_Comm>`, :ref:`disk usage <API_s4u_Io>`,
  40 and other |API_s4u_Activities|_, so that they get reflected within the
  41 simulator. These activities take place on resources such as |API_s4u_Hosts|_,
  42 |API_s4u_Links|_, and |API_s4u_Disks|_. SimGrid predicts the time taken by each
  43 activity and orchestrates the actors accordingly, waiting for the
  44 completion of these activities.
  45
  46
  47 When **communicating**, data is not directly sent to other actors but
  48 posted onto a |API_s4u_Mailbox|_ that serves as a rendezvous point between
  49 communicating actors. This means that you don't need to know who you
  50 are talking to, you just put your communication `Put` request in a
  51 mailbox, and it will be matched with a complementary `Get`
  52 request.  Alternatively, actors can interact through **classical
  53 synchronization mechanisms** such as |API_s4u_Barrier|_, |API_s4u_Semaphore|_,
  54 |API_s4u_Mutex|_, and |API_s4u_ConditionVariable|_.
  55
  56 Each actor is located on a simulated |API_s4u_Host|_. Each host is located
  57 in a |API_s4u_NetZone|_, that knows the networking path between one
  58 resource to another. Each NetZone is included in another one, forming
  59 a tree of NetZones which root zone contains the whole platform. The
  60 actors can also be located on a |API_s4U_VirtualMachine|_ that may
  61 restrict the activities it contains to a limited amount of cores.
  62 Virtual machines can also be migrated between hosts.
  63
  64 The :ref:`simgrid::s4u::this_actor <API_s4u_this_actor>` namespace
  65 provides many helper functions to simplify the code of actors.
  66
  67 - **Simulation Elements**
  68
  69   - :ref:`class Actor <API_s4u_Actor>`:
  70     Active entities executing your application.
  71   - :ref:`class Engine <API_s4u_Engine>`
  72     Simulation engine (singleton).
  73   - :ref:`class Mailbox <API_s4u_Mailbox>`
  74     Communication rendezvous, with which actors meet each other.
  75
  76 - **Resources**
  77
  78   - :ref:`class Disk <API_s4u_Disk>`
  79     Resource on which actors can write and read data.
  80   - :ref:`class Host <API_s4u_Host>`:
  81     Actor location, providing computational power.
  82   - :ref:`class Link <API_s4u_Link>`
  83     Interconnecting hosts.
  84   - :ref:`class NetZone <API_s4u_NetZone>`:
  85     Sub-region of the platform, containing resources (Hosts, Links, etc).
  86   - :ref:`class VirtualMachine <API_s4u_VirtualMachine>`:
  87     Execution containers that can be moved between Hosts.
  88
  89 - **Activities** (:ref:`class Activity <API_s4u_Activity>`):
  90   The things that actors can do on resources
  91
  92   - :ref:`class Comm <API_s4u_Comm>`
  93     Communication activity, started on Mailboxes and consuming links.
  94   - :ref:`class Exec <API_s4u_Exec>`
  95     Computation activity, started on Host and consuming CPU resources.
  96   - :ref:`class Io <API_s4u_Io>`
  97     I/O activity, started on and consuming disks.
  98
  99 - **Synchronization Objects**: Classical IPC that actors can use
 100
 101   - :ref:`class Barrier <API_s4u_Barrier>`
 102   - :ref:`class ConditionVariable <API_s4u_ConditionVariable>`
 103   - :ref:`class Mutex <API_s4u_Mutex>`
 104   - :ref:`class Semaphore <API_s4u_Semaphore>`
 105
 106
 107 .. |API_s4u_Actors| replace:: **Actors**
 108 .. _API_s4u_Actors: #api-s4u-actor
 109
 110 .. |API_s4u_Activities| replace:: **Activities**
 111 .. _API_s4u_Activities: #api-s4u-activity
 112
 113 .. |API_s4u_Hosts| replace:: **Hosts**
 114 .. _API_s4u_Hosts: #api-s4u-host
 115
 116 .. |API_s4u_Links| replace:: **Links**
 117 .. _API_s4u_Links: #api-s4u-link
 118
 119 .. |API_s4u_Disks| replace:: **Disks**
 120 .. _API_s4u_Disks: #api-s4u-disk
 121
 122 .. |API_s4u_VirtualMachine| replace:: **VirtualMachines**
 123
 124 .. |API_s4u_Host| replace:: **Host**
 125
 126 .. |API_s4u_Mailbox| replace:: **Mailbox**
 127
 128 .. |API_s4u_Mailboxes| replace:: **Mailboxes**
 129 .. _API_s4u_Mailboxes: #s4u-mailbox
 130
 131 .. |API_s4u_NetZone| replace:: **NetZone**
 132
 133 .. |API_s4u_Barrier| replace:: **Barrier**
 134
 135 .. |API_s4u_Semaphore| replace:: **Semaphore**
 136
 137 .. |API_s4u_ConditionVariable| replace:: **ConditionVariable**
 138
 139 .. |API_s4u_Mutex| replace:: **Mutex**
 140
 141 .. _s4u_Activities:
 142
 143 Activities
 144 **********
 145
 146 Activities represent the actions that consume a resource, such as a
 147 :ref:`Comm <API_s4u_Comm>` that consumes the *transmitting power* of
 148 :ref:`Link <API_s4u_Link>` resources, or an :ref:`Exec <API_s4u_Exec>`
 149 that consumes the *computing power* of :ref:`Host <API_s4u_Host>` resources.
 150 See also the :ref:`full API <API_s4u_Activity>` below.
 151
 152 =======================
 153 Asynchronous Activities
 154 =======================
 155
 156 Every activity can be either **blocking** or **asynchronous**. For
 157 example, :cpp:func:`s4u::Mailbox::put() <simgrid::s4u::Mailbox::put>`
 158 and :cpp:func:`s4u::Mailbox::get() <simgrid::s4u::Mailbox::get>`
 159 create blocking communications: the actor is blocked until the
 160 completion of that communication. Asynchronous communications do not
 161 block the actor during their execution but progress on their own.
 162
 163 Once your asynchronous activity is started, you can test for its
 164 completion using :cpp:func:`s4u::Activity::test() <simgrid::s4u::Activity::test>`.
 165 This function returns ``true`` if the activity is completed already.
 166 You can also use :cpp:func:`s4u::Activity::wait() <simgrid::s4u::Activity::wait>`
 167 to block until the completion of the activity. To wait for at most a given amount of time,
 168 use  :cpp:func:`s4u::Activity::wait_for() <simgrid::s4u::Activity::wait_for>`.
 169 Finally, to wait at most until a specified time limit, use
 170 :cpp:func:`s4u::Activity::wait_until() <simgrid::s4u::Activity::wait_until>`.
 171
 172 Every kind of activity can be asynchronous:
 173
 174   - :ref:`s4u::CommPtr <API_s4u_Comm>` are created with
 175     :cpp:func:`s4u::Mailbox::put_async() <simgrid::s4u::Mailbox::put_async>` and
 176     :cpp:func:`s4u::Mailbox::get_async() <simgrid::s4u::Mailbox::get_async>`.
 177   - :ref:`s4u::IoPtr <API_s4u_Io>` are created with
 178     :cpp:func:`s4u::Disk::read_async() <simgrid::s4u::Disk::read_async>` and
 179     :cpp:func:`s4u::Disk::write_async() <simgrid::s4u::Disk::write_async>`.
 180   - :ref:`s4u::ExecPtr <API_s4u_Exec>` are created with
 181     :cpp:func:`s4u::Host::exec_async() <simgrid::s4u::Host::exec_async>`.
 182   - In the future, it will become possible to have asynchronous IPC
 183     such as asynchronous mutex lock requests.
 184
 185 The following example shows how to have several concurrent
 186 communications ongoing.  First, you have to declare a vector in which
 187 we will store the ongoing communications. It is also useful to have a
 188 vector of mailboxes.
 189
 190 .. literalinclude:: ../../examples/cpp/comm-waitall/s4u-comm-waitall.cpp
 191    :language: c++
 192    :start-after: init-begin
 193    :end-before: init-end
 194    :dedent: 4
 195
 196 Then, you start all the communications that should occur concurrently with
 197 :cpp:func:`s4u::Mailbox::put_async() <simgrid::s4u::Mailbox::put_async>`.
 198 Finally, the actor waits for the completion of all of them at once
 199 with
 200 :cpp:func:`s4u::Comm::wait_all() <simgrid::s4u::Comm::wait_all>`.
 201
 202 .. literalinclude:: ../../examples/cpp/comm-waitall/s4u-comm-waitall.cpp
 203    :language: c++
 204    :start-after: put-begin
 205    :end-before: put-end
 206    :dedent: 4
 207
 208
 209 =====================
 210 Activities Life cycle
 211 =====================
 212
 213 Sometimes, you want to change the setting of an activity before it even starts.
 214
 215 .. todo:: write this section
 216
 217 .. _s4u_mailbox:
 218
 219 Mailboxes
 220 *********
 221
 222 Please also refer to the :ref:`API reference for s4u::Mailbox
 223 <API_s4u_Mailbox>`.
 224
 225 ===================
 226 What are Mailboxes?
 227 ===================
 228
 229 |API_s4u_Mailboxes|_ are rendezvous points for network communications,
 230 similar to URLs on which you could post and retrieve data. Actually,
 231 the mailboxes are not involved in the communication once it starts,
 232 but only to find the contact with which you want to communicate.
 233
 234 They are similar to many common things: The phone number, which allows
 235 the caller to find the receiver. The Twitter hashtag, which helps
 236 senders and receivers to find each other. In TCP, the pair
 237 ``{host name, host port}`` to which you can connect to find your peer.
 238 In HTTP, URLs through which the clients can connect to the servers.
 239 In ZeroMQ, the queues are used to match senders and receivers.
 240
 241 One big difference with most of these systems is that no actor is the
 242 exclusive owner of a mailbox, neither in sending nor in receiving.
 243 Many actors can send into and/or receive from the same mailbox.  TCP
 244 socket ports for example are shared on the sender side but exclusive
 245 on the receiver side (only one process can receive from a given socket
 246 at a given point of time).
 247
 248 A big difference with TCP sockets or MPI communications is that
 249 communications do not start right away after a
 250 :cpp:func:`Mailbox::put() <simgrid::s4u::Mailbox::put>`, but wait
 251 for the corresponding :cpp:func:`Mailbox::get() <simgrid::s4u::Mailbox::get>`.
 252 You can change this by :ref:`declaring a receiving actor <s4u_receiving_actor>`.
 253
 254 A big difference with Twitter hashtags is that SimGrid does not
 255 offer easy support to broadcast a given message to many
 256 receivers. So that would be like a Twitter tag where each message
 257 is consumed by the first receiver.
 258
 259 A big difference with the ZeroMQ queues is that you cannot filter
 260 on the data you want to get from the mailbox. To model such settings
 261 in SimGrid, you'd have one mailbox per potential topic, and subscribe
 262 to each topic individually with a
 263 :cpp:func:`get_async() <simgrid::s4u::Mailbox::get_async>` on each mailbox.
 264 Then, use :cpp:func:`Comm::wait_any() <simgrid::s4u::Comm::wait_any>`
 265 to get the first message on any of the mailboxes you are subscribed to.
 266
 267 The mailboxes are not located on the network, and you can access
 268 them without any latency. The network delays are only related to the
 269 location of the sender and receiver once the match between them is
 270 done on the mailbox. This is just like the phone number that you
 271 can use locally, and the geographical distance only comes into play
 272 once you start the communication by dialing this number.
 273
 274 =====================
 275 How to use Mailboxes?
 276 =====================
 277
 278 You can retrieve any existing mailbox from its name (which is a
 279 unique string, just like a Twitter tag). This results in a
 280 versatile tool that can be used to build many different
 281 situations.
 282
 283 To model classical socket communications, use "hostname:port" as
 284 mailbox names, and make sure that only one actor reads into a given
 285 mailbox. This does not make it easy to build a perfectly realistic
 286 model of the TCP sockets, but in most cases, this system is too
 287 cumbersome for your simulations anyway. You probably want something
 288 simpler, that turns out to be easy to build with the mailboxes.
 289
 290 Many SimGrid examples use a sort of yellow page system where the
 291 mailbox names are the name of the service (such as "worker",
 292 "master", or "reducer"). That way, you don't have to know where your
 293 peer is located to contact it. You don't even need its name. Its
 294 function is enough for that. This also gives you some sort of load
 295 balancing for free if more than one actor pulls from the mailbox:
 296 the first actor that can deal with the request will handle it.
 297
 298 =========================================
 299 How are put() and get() requests matched?
 300 =========================================
 301
 302 The matching algorithm simple: first come, first serve. When a new
 303 send arrives, it matches the oldest enqueued receive. If no receive is
 304 currently enqueued, then the incoming send is enqueued. As you can
 305 see, the mailbox cannot contain both send and receive requests: all
 306 enqueued requests must be of the same sort.
 307
 308 .. _s4u_receiving_actor:
 309
 310 ===========================
 311 Declaring a Receiving Actor
 312 ===========================
 313
 314 The last twist is that by default in the simulator, the data starts
 315 to be exchanged only when both the sender and the receiver are
 316 announced (it waits until both :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
 317 and :cpp:func:`get() <simgrid::s4u::Mailbox::get()>` are posted).
 318 In TCP, since you establish connections beforehand, the data starts to
 319 flow as soon as the sender posts it, even if the receiver did not post
 320 its :cpp:func:`put() <simgrid::s4u::Mailbox::put()>` yet.
 321
 322 To model this in SimGrid, you can declare a specific receiver to a
 323 given mailbox (with the function
 324 :cpp:func:`set_receiver() <simgrid::s4u::Mailbox::set_receiver()>`).
 325 That way, any :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
 326 posted to that mailbox will start as soon as possible, and the data
 327 will already be there on the receiver host when the receiver actor
 328 posts its :cpp:func:`get() <simgrid::s4u::Mailbox::get()>`
 329
 330 Note that being permanent receivers of a mailbox prevents actors to be
 331 garbage-collected. If your simulation creates many short-lived actors
 332 that are marked as permanent receiver, you should call
 333 ``mailbox->set_receiver(nullptr)`` by the end of the actors so that their
 334 memory gets properly reclaimed. This call should be at the end of the
 335 actor's function, not in an on_exit callback.
 336
 337 .. _s4u_raii:
 338
 339 Memory Management
 340 *****************
 341
 342 For sake of simplicity, we use `RAII
 343 <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`_
 344 for many classes in S4U. This is an idiom where resources are automatically
 345 managed through the context. Provided that you never manipulate
 346 objects of type Foo directly but always FooPtr references (which are
 347 defined as `boost::intrusive_ptr
 348 <http://www.boost.org/doc/libs/1_61_0/libs/smart_ptr/intrusive_ptr.html>`_
 349 <Foo>), you will never have to explicitly release the resource that
 350 you use nor to free the memory of unused objects.
 351 Here is a little example:
 352
 353 .. code-block:: cpp
 354
 355    void myFunc()
 356    {
 357      simgrid::s4u::MutexPtr mutex = simgrid::s4u::Mutex::create(); // Too bad we cannot use `new`
 358
 359      mutex->lock();   // use the mutex as a simple reference
 360      //  bla bla
 361      mutex->unlock();
 362
 363    } // The mutex gets automatically freed because the only existing reference gets out of scope
 364
 365 Note that Mailboxes, Hosts, and Links are not handled through smart
 366 pointers (yet?). This means that it is currently impossible to destroy a
 367 mailbox or a link. You can still destroy a host (but probably
 368 shouldn't), using :cpp:func:`simgrid::s4u::Host::destroy`.
 369
 370 .. THE EXAMPLES
 371
 372 .. include:: ../../examples/README.rst
 373
 374 API Reference
 375 *************
 376
 377 .. _API_s4u_simulation_object:
 378
 379 ==================
 380 Simulation objects
 381 ==================
 382
 383 .. _API_s4u_Actor:
 384
 385 ==============
 386 ⁣  class Actor
 387 ==============
 388
 389 .. doxygenclass:: simgrid::s4u::Actor
 390
 391 .. doxygentypedef:: aid_t
 392
 393 Basic management
 394 ----------------
 395
 396 .. tabs::
 397
 398    .. group-tab:: C++
 399
 400       .. code:: C++
 401
 402          #include <simgrid/s4u/Actor.hpp>
 403
 404       .. doxygentypedef:: ActorPtr
 405
 406    .. group-tab:: Python
 407
 408       .. code:: Python
 409
 410          from simgrid import Actor
 411
 412    .. group-tab:: C
 413
 414       .. code:: C
 415
 416          #include <simgrid/actor.h>
 417
 418       .. doxygentypedef:: sg_actor_t
 419       .. cpp:type:: const s4u_Actor* const_sg_actor_t
 420
 421          Pointer to a constant actor object.
 422
 423       .. doxygenfunction:: sg_actor_ref
 424       .. doxygenfunction:: sg_actor_unref
 425
 426
 427 Creating actors
 428 ---------------
 429
 430 .. tabs::
 431
 432    .. group-tab:: C++
 433
 434       .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::function< void()> &code)
 435       .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code)
 436       .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code, Args... args)
 437       .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::string &function, std::vector< std::string > args)
 438
 439       .. doxygenfunction:: simgrid::s4u::Actor::init(const std::string &name, s4u::Host *host)
 440       .. doxygenfunction:: simgrid::s4u::Actor::start(const std::function< void()> &code)
 441
 442    .. group-tab:: Python
 443
 444       .. automethod:: simgrid.Actor.create
 445
 446    .. group-tab:: C
 447
 448       .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, const char *const *argv)
 449       .. doxygenfunction:: sg_actor_init(const char *name, sg_host_t host)
 450       .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char *const *argv)
 451
 452       .. doxygenfunction:: sg_actor_attach(const char *name, void *data, sg_host_t host, xbt_dict_t properties)
 453       .. doxygenfunction:: sg_actor_detach()
 454
 455 Retrieving actors
 456 -----------------
 457
 458 .. tabs::
 459
 460    .. group-tab:: C++
 461
 462       .. doxygenfunction:: simgrid::s4u::Actor::by_pid(aid_t pid)
 463       .. doxygenfunction:: simgrid::s4u::Actor::self()
 464
 465    .. group-tab:: Python
 466
 467       .. automethod:: simgrid.Actor.by_pid
 468       .. automethod:: simgrid.Actor.self
 469
 470    .. group-tab:: C
 471
 472       .. doxygenfunction:: sg_actor_by_PID(aid_t pid)
 473       .. doxygenfunction:: sg_actor_self()
 474
 475 Querying info
 476 -------------
 477
 478 .. tabs::
 479
 480    .. group-tab:: C++
 481
 482       .. doxygenfunction:: simgrid::s4u::Actor::get_cname
 483       .. doxygenfunction:: simgrid::s4u::Actor::get_name
 484       .. doxygenfunction:: simgrid::s4u::Actor::get_pid
 485       .. doxygenfunction:: simgrid::s4u::Actor::get_ppid
 486       .. doxygenfunction:: simgrid::s4u::Actor::get_properties() const
 487       .. doxygenfunction:: simgrid::s4u::Actor::get_property(const std::string &key) const
 488       .. doxygenfunction:: simgrid::s4u::Actor::set_property(const std::string &key, const std::string &value)
 489
 490       .. doxygenfunction:: simgrid::s4u::Actor::get_host
 491       .. doxygenfunction:: simgrid::s4u::Actor::set_host
 492
 493       .. doxygenfunction:: simgrid::s4u::Actor::get_refcount
 494       .. doxygenfunction:: simgrid::s4u::Actor::get_impl
 495
 496    .. group-tab:: Python
 497
 498       .. autoattribute:: simgrid.Actor.name
 499       .. autoattribute:: simgrid.Actor.host
 500       .. autoattribute:: simgrid.Actor.pid
 501       .. autoattribute:: simgrid.Actor.ppid
 502
 503    .. group-tab:: C
 504
 505       .. doxygenfunction:: sg_actor_get_name(const_sg_actor_t actor)
 506       .. doxygenfunction:: sg_actor_get_PID(const_sg_actor_t actor)
 507       .. doxygenfunction:: sg_actor_get_PPID(const_sg_actor_t actor)
 508       .. doxygenfunction:: sg_actor_get_properties(const_sg_actor_t actor)
 509       .. doxygenfunction:: sg_actor_get_property_value(const_sg_actor_t actor, const char *name)
 510
 511       .. doxygenfunction:: sg_actor_get_host(const_sg_actor_t actor)
 512       .. doxygenfunction:: sg_actor_set_host(sg_actor_t actor, sg_host_t host)
 513
 514       .. doxygenfunction:: sg_actor_get_data(const_sg_actor_t actor)
 515       .. doxygenfunction:: sg_actor_set_data(sg_actor_t actor, void *userdata)
 516
 517 Suspending and resuming actors
 518 ------------------------------
 519
 520 .. tabs::
 521
 522    .. group-tab:: C++
 523
 524       .. doxygenfunction:: simgrid::s4u::Actor::suspend()
 525       .. doxygenfunction:: simgrid::s4u::Actor::resume()
 526       .. doxygenfunction:: simgrid::s4u::Actor::is_suspended
 527
 528    .. group-tab:: Python
 529
 530       .. automethod:: simgrid.Actor.resume
 531       .. automethod:: simgrid.Actor.suspend
 532       .. automethod:: simgrid.Actor.is_suspended
 533
 534    .. group-tab:: C
 535
 536       .. doxygenfunction:: sg_actor_suspend(sg_actor_t actor)
 537       .. doxygenfunction:: sg_actor_resume(sg_actor_t actor)
 538       .. doxygenfunction:: sg_actor_is_suspended(const_sg_actor_t actor)
 539
 540 Specifying when actors should terminate
 541 ---------------------------------------
 542
 543 .. tabs::
 544
 545    .. group-tab:: C++
 546
 547       .. doxygenfunction:: simgrid::s4u::Actor::kill()
 548       .. doxygenfunction:: simgrid::s4u::Actor::kill_all()
 549       .. doxygenfunction:: simgrid::s4u::Actor::set_kill_time(double time)
 550       .. doxygenfunction:: simgrid::s4u::Actor::get_kill_time
 551
 552       .. doxygenfunction:: simgrid::s4u::Actor::restart()
 553       .. doxygenfunction:: simgrid::s4u::Actor::daemonize()
 554       .. doxygenfunction:: simgrid::s4u::Actor::is_daemon
 555
 556    .. group-tab:: Python
 557
 558       .. automethod:: simgrid.Actor.kill
 559       .. automethod:: simgrid.Actor.kill_all
 560
 561       .. automethod:: simgrid.Actor.daemonize
 562       .. automethod:: simgrid.Actor.is_daemon
 563
 564    .. group-tab:: C
 565
 566       .. doxygenfunction:: sg_actor_kill(sg_actor_t actor)
 567       .. doxygenfunction:: sg_actor_kill_all()
 568       .. doxygenfunction:: sg_actor_set_kill_time(sg_actor_t actor, double kill_time)
 569
 570       .. doxygenfunction:: sg_actor_restart(sg_actor_t actor)
 571       .. doxygenfunction:: sg_actor_daemonize(sg_actor_t actor)
 572       .. doxygenfunction:: sg_actor_is_daemon
 573
 574 .. _API_s4u_Actor_end:
 575
 576 Reacting to the end of actors
 577 -----------------------------
 578
 579 .. tabs::
 580
 581    .. group-tab:: C++
 582
 583       .. doxygenfunction:: simgrid::s4u::Actor::on_exit
 584       .. doxygenfunction:: simgrid::s4u::Actor::join() const
 585       .. doxygenfunction:: simgrid::s4u::Actor::join(double timeout) const
 586       .. doxygenfunction:: simgrid::s4u::Actor::set_auto_restart(bool autorestart)
 587
 588    .. group-tab:: Python
 589
 590       .. automethod:: simgrid.Actor.join
 591
 592    .. group-tab:: C
 593
 594       .. doxygenfunction:: sg_actor_join(const_sg_actor_t actor, double timeout)
 595       .. doxygenfunction:: sg_actor_set_auto_restart(sg_actor_t actor, int auto_restart)
 596
 597 Signals
 598 -------
 599
 600 .. tabs::
 601
 602    .. group-tab:: C++
 603
 604       .. doxygenvariable:: simgrid::s4u::Actor::on_creation
 605       .. doxygenvariable:: simgrid::s4u::Actor::on_suspend
 606       .. doxygenvariable:: simgrid::s4u::Actor::on_host_change
 607       .. doxygenvariable:: simgrid::s4u::Actor::on_resume
 608       .. doxygenvariable:: simgrid::s4u::Actor::on_sleep
 609       .. doxygenvariable:: simgrid::s4u::Actor::on_wake_up
 610       .. doxygenvariable:: simgrid::s4u::Actor::on_termination
 611       .. doxygenvariable:: simgrid::s4u::Actor::on_destruction
 612
 613 .. _API_s4u_this_actor:
 614
 615 ====================
 616 ⁣  The current actor
 617 ====================
 618
 619 These functions can be used in your user code to interact with the actor
 620 currently running (the one retrieved with :cpp:func:`simgrid::s4u::Actor::self`).
 621 Using these functions can greatly improve the code readability.
 622
 623 Querying info
 624 -------------
 625
 626 .. tabs::
 627
 628    .. group-tab:: C++
 629
 630       .. doxygenfunction:: simgrid::s4u::this_actor::get_cname()
 631       .. doxygenfunction:: simgrid::s4u::this_actor::get_name()
 632       .. doxygenfunction:: simgrid::s4u::this_actor::get_pid()
 633       .. doxygenfunction:: simgrid::s4u::this_actor::get_ppid()
 634       .. doxygenfunction:: simgrid::s4u::this_actor::is_maestro()
 635
 636       .. doxygenfunction:: simgrid::s4u::this_actor::get_host()
 637       .. doxygenfunction:: simgrid::s4u::this_actor::set_host(Host *new_host)
 638
 639    .. group-tab:: Python
 640
 641       .. autofunction:: simgrid.this_actor.get_host
 642       .. autofunction:: simgrid.this_actor.set_host
 643
 644    .. group-tab:: C
 645
 646       .. doxygenfunction:: sg_actor_self_get_data()
 647       .. doxygenfunction:: sg_actor_self_set_data(void *data)
 648       .. doxygenfunction:: sg_actor_self_get_name()
 649       .. doxygenfunction:: sg_actor_self_get_pid()
 650       .. doxygenfunction:: sg_actor_self_get_ppid()
 651       .. doxygenfunction:: sg_host_self()
 652       .. doxygenfunction:: sg_host_self_get_name()
 653
 654 Suspending and resuming
 655 -----------------------
 656
 657 .. tabs::
 658
 659    .. group-tab:: C++
 660
 661       .. doxygenfunction:: simgrid::s4u::this_actor::suspend()
 662       .. doxygenfunction:: simgrid::s4u::this_actor::yield()
 663
 664    .. group-tab:: Python
 665
 666       .. autofunction:: simgrid.this_actor.suspend
 667       .. autofunction:: simgrid.this_actor.yield_
 668
 669    .. group-tab:: C
 670
 671       .. doxygenfunction:: sg_actor_yield()
 672
 673 Logging messages
 674 ----------------
 675
 676 .. tabs::
 677
 678    .. group-tab:: Python
 679
 680        .. autofunction:: simgrid.this_actor.info
 681        .. autofunction:: simgrid.this_actor.error
 682
 683 Sleeping
 684 --------
 685
 686 .. tabs::
 687
 688    .. group-tab:: C++
 689
 690       .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(double duration)
 691       .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(std::chrono::duration< Rep, Period > duration)
 692       .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(const SimulationTimePoint< Duration > &wakeup_time)
 693       .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(double wakeup_time)
 694
 695    .. group-tab:: Python
 696
 697       .. autofunction:: simgrid.this_actor.sleep_for
 698       .. autofunction:: simgrid.this_actor.sleep_until
 699
 700    .. group-tab:: C
 701
 702       .. doxygenfunction:: sg_actor_sleep_for(double duration)
 703
 704 Simulating executions
 705 ---------------------
 706
 707 Simulate the execution of some code on this actor. You can either simulate
 708 parallel or sequential code and you can either block upon the termination of
 709 the execution, or start an asynchronous activity.
 710
 711 .. tabs::
 712
 713    .. group-tab:: C++
 714
 715       .. doxygenfunction:: simgrid::s4u::this_actor::exec_async
 716       .. doxygenfunction:: simgrid::s4u::this_actor::exec_init(const std::vector< s4u::Host * > &hosts, const std::vector< double > &flops_amounts, const std::vector< double > &bytes_amounts)
 717       .. doxygenfunction:: simgrid::s4u::this_actor::exec_init(double flops_amounts)
 718       .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop)
 719       .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop, double priority)
 720       .. doxygenfunction:: simgrid::s4u::this_actor::parallel_execute(const std::vector< s4u::Host * > &hosts, const std::vector< double > &flops_amounts, const std::vector< double > &bytes_amounts)
 721       .. doxygenfunction:: simgrid::s4u::this_actor::parallel_execute(const std::vector< s4u::Host * > &hosts, const std::vector< double > &flops_amounts, const std::vector< double > &bytes_amounts, double timeout)
 722
 723    .. group-tab:: Python
 724
 725       .. autofunction:: simgrid.this_actor.exec_init
 726       .. autofunction:: simgrid.this_actor.execute
 727
 728    .. group-tab:: C
 729
 730       .. doxygenfunction:: sg_actor_execute(double flops)
 731       .. doxygenfunction:: sg_actor_execute_with_priority(double flops, double priority)
 732       .. doxygenfunction:: sg_actor_exec_init(double computation_amount)
 733       .. doxygenfunction:: sg_actor_exec_async(double computation_amount)
 734       .. doxygenfunction:: sg_actor_parallel_exec_init(int host_nb, const sg_host_t* host_list, double* flops_amount, double* bytes_amount);
 735
 736 Exiting
 737 -------
 738
 739 .. tabs::
 740
 741    .. group-tab:: C++
 742
 743       .. doxygenfunction:: simgrid::s4u::this_actor::exit()
 744       .. doxygenfunction:: simgrid::s4u::this_actor::on_exit(const std::function< void(bool)> &fun)
 745
 746    .. group-tab:: Python
 747
 748       .. autofunction:: simgrid.this_actor.exit
 749       .. autofunction:: simgrid.this_actor.on_exit
 750
 751 .. _API_s4u_Engine:
 752
 753 ====================
 754 ⁣  Simulation Engine
 755 ====================
 756
 757 .. doxygenclass:: simgrid::s4u::Engine
 758
 759 Initialization
 760 --------------
 761
 762 .. tabs::
 763
 764    .. group-tab:: C++
 765
 766       .. doxygenfunction:: simgrid::s4u::Engine::Engine(int *argc, char **argv)
 767       .. doxygenfunction:: simgrid::s4u::Engine::is_initialized()
 768       .. doxygenfunction:: simgrid::s4u::Engine::shutdown()
 769       .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &str)
 770       .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, bool value)
 771       .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, double value)
 772       .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, int value)
 773       .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, const std::string &value)
 774
 775       .. doxygenfunction:: simgrid::s4u::Engine::load_deployment
 776       .. doxygenfunction:: simgrid::s4u::Engine::load_platform
 777       .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name)
 778       .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name, F code)
 779       .. doxygenfunction:: simgrid::s4u::Engine::register_default(const std::function< void(int, char **)> &code)
 780       .. doxygenfunction:: simgrid::s4u::Engine::register_default(const kernel::actor::ActorCodeFactory &factory)
 781
 782       .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(int, char **)> &code)
 783       .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(std::vector< std::string >)> &code)
 784       .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const kernel::actor::ActorCodeFactory &factory)
 785
 786    .. group-tab:: Python
 787
 788        .. automethod:: simgrid.Engine.load_deployment
 789        .. automethod:: simgrid.Engine.load_platform
 790        .. automethod:: simgrid.Engine.register_actor
 791
 792    .. group-tab:: C
 793
 794       .. doxygenfunction:: simgrid_init
 795
 796       .. doxygenfunction:: simgrid_load_deployment
 797       .. doxygenfunction:: simgrid_load_platform
 798       .. doxygenfunction:: simgrid_register_default
 799       .. doxygenfunction:: simgrid_register_function
 800
 801 Run the simulation
 802 ------------------
 803
 804 .. tabs::
 805
 806    .. group-tab:: C++
 807
 808       .. doxygenfunction:: simgrid::s4u::Engine::get_clock()
 809       .. doxygenfunction:: simgrid::s4u::Engine::run
 810
 811    .. group-tab:: Python
 812
 813       .. automethod:: simgrid.Engine.get_clock
 814       .. automethod:: simgrid.Engine.run
 815
 816    .. group-tab:: C
 817
 818       .. doxygenfunction:: simgrid_get_clock
 819       .. doxygenfunction:: simgrid_run
 820
 821 Retrieving actors
 822 -----------------
 823
 824 .. tabs::
 825
 826    .. group-tab:: C++
 827
 828       .. doxygenfunction:: simgrid::s4u::Engine::get_actor_count
 829       .. doxygenfunction:: simgrid::s4u::Engine::get_all_actors
 830       .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_actors
 831
 832    .. group-tab:: C
 833
 834       .. doxygenfunction:: simgrid_get_actor_count()
 835
 836 Retrieving hosts
 837 ----------------
 838
 839 .. tabs::
 840
 841    .. group-tab:: C++
 842
 843       .. doxygenfunction:: simgrid::s4u::Engine::get_all_hosts
 844       .. doxygenfunction:: simgrid::s4u::Engine::get_host_count
 845       .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_hosts
 846       .. doxygenfunction:: simgrid::s4u::Engine::host_by_name
 847       .. doxygenfunction:: simgrid::s4u::Engine::host_by_name_or_null
 848
 849    .. group-tab:: Python
 850
 851       .. automethod:: simgrid.Engine.get_all_hosts
 852
 853    .. group-tab:: C
 854
 855       See also :cpp:func:`sg_host_list` and :cpp:func:`sg_host_count`.
 856
 857 Retrieving links
 858 ----------------
 859
 860 .. tabs::
 861
 862    .. group-tab:: C++
 863
 864       .. doxygenfunction:: simgrid::s4u::Engine::get_all_links
 865       .. doxygenfunction:: simgrid::s4u::Engine::get_link_count
 866       .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_links
 867       .. doxygenfunction:: simgrid::s4u::Engine::link_by_name
 868       .. doxygenfunction:: simgrid::s4u::Engine::link_by_name_or_null
 869
 870 Interacting with the routing
 871 ----------------------------
 872
 873 .. tabs::
 874
 875    .. group-tab:: C++
 876
 877       .. doxygenfunction:: simgrid::s4u::Engine::get_all_netpoints
 878       .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_netzones
 879       .. doxygenfunction:: simgrid::s4u::Engine::get_instance()
 880       .. doxygenfunction:: simgrid::s4u::Engine::get_netzone_root
 881       .. doxygenfunction:: simgrid::s4u::Engine::netpoint_by_name_or_null
 882       .. doxygenfunction:: simgrid::s4u::Engine::netzone_by_name_or_null
 883       .. doxygenfunction:: simgrid::s4u::Engine::set_netzone_root(const NetZone *netzone)
 884
 885 Signals
 886 -------
 887
 888 .. tabs::
 889
 890    .. group-tab:: C++
 891
 892       .. doxygenvariable:: simgrid::s4u::Engine::on_deadlock
 893       .. doxygenvariable:: simgrid::s4u::Engine::on_platform_created
 894       .. doxygenvariable:: simgrid::s4u::Engine::on_platform_creation
 895       .. doxygenvariable:: simgrid::s4u::Engine::on_simulation_end
 896       .. doxygenvariable:: simgrid::s4u::Engine::on_time_advance
 897
 898 .. _API_s4u_Mailbox:
 899
 900 ================
 901 ⁣  class Mailbox
 902 ================
 903
 904 .. doxygenclass:: simgrid::s4u::Mailbox
 905
 906 Please also refer to the :ref:`full doc on s4u::Mailbox <s4u_mailbox>`.
 907
 908 Basic management
 909 ----------------
 910
 911 .. tabs::
 912
 913    .. group-tab:: C++
 914
 915       .. code-block:: C++
 916
 917          #include <simgrid/s4u/Mailbox.hpp>
 918
 919       Note that there is no MailboxPtr type and that you cannot use the RAII
 920       idiom on mailboxes because they are internal objects to the simulation
 921       engine. Once created, there is no way to destroy a mailbox before the end
 922       of the simulation.
 923
 924       .. doxygenfunction:: simgrid::s4u::Mailbox::by_name(const std::string &name)
 925
 926    .. group-tab:: Python
 927
 928       .. automethod:: simgrid.Mailbox.by_name
 929
 930       .. code-block:: C
 931
 932          #include <simgrid/s4u/mailbox.h>
 933
 934       .. doxygenfunction:: sg_mailbox_by_name(const char *alias)
 935
 936    .. group-tab:: C
 937
 938 Querying info
 939 -------------
 940
 941 .. tabs::
 942
 943    .. group-tab:: C++
 944
 945       .. doxygenfunction:: simgrid::s4u::Mailbox::get_cname
 946       .. doxygenfunction:: simgrid::s4u::Mailbox::get_name
 947
 948    .. group-tab:: Python
 949
 950       .. autoattribute:: simgrid.Mailbox.name
 951
 952 Sending data
 953 ------------
 954
 955 .. tabs::
 956
 957    .. group-tab:: C++
 958
 959       .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes)
 960       .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes, double timeout)
 961       .. doxygenfunction:: simgrid::s4u::Mailbox::put_async(void *data, uint64_t simulated_size_in_bytes)
 962       .. doxygenfunction:: simgrid::s4u::Mailbox::put_init()
 963       .. doxygenfunction:: simgrid::s4u::Mailbox::put_init(void *data, uint64_t simulated_size_in_bytes)
 964
 965    .. group-tab:: Python
 966
 967       .. automethod:: simgrid.Mailbox.put
 968       .. automethod:: simgrid.Mailbox.put_async
 969
 970    .. group-tab: C
 971
 972       .. doxygenfunction:: sg_mailbox_put(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
 973       .. doxygenfunction:: sg_mailbox_put_init(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
 974       .. doxygenfunction:: sg_mailbox_put_async(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
 975
 976
 977 Receiving data
 978 --------------
 979
 980 .. tabs::
 981
 982    .. group-tab:: C++
 983
 984       .. doxygenfunction:: simgrid::s4u::Mailbox::empty
 985       .. doxygenfunction:: simgrid::s4u::Mailbox::front
 986       .. doxygenfunction:: simgrid::s4u::Mailbox::get()
 987       .. doxygenfunction:: simgrid::s4u::Mailbox::get(double timeout)
 988       .. doxygenfunction:: simgrid::s4u::Mailbox::get_async(T **data)
 989       .. doxygenfunction:: simgrid::s4u::Mailbox::get_init()
 990       .. doxygenfunction:: simgrid::s4u::Mailbox::iprobe(int type, bool(*match_fun)(void *, void *, kernel::activity::CommImpl *), void *data)
 991       .. doxygenfunction:: simgrid::s4u::Mailbox::listen
 992       .. doxygenfunction:: simgrid::s4u::Mailbox::ready
 993
 994    .. group-tab:: Python
 995
 996        .. automethod:: simgrid.Mailbox.get
 997
 998    .. group-tab:: C
 999
1000       .. doxygenfunction:: sg_mailbox_get(sg_mailbox_t mailbox)
1001       .. doxygenfunction:: sg_mailbox_get_async(sg_mailbox_t mailbox, void **data)
1002       .. doxygenfunction:: sg_mailbox_get_name(const_sg_mailbox_t mailbox)
1003       .. doxygenfunction:: sg_mailbox_listen(const char *alias)
1004
1005 Receiving actor
1006 ---------------
1007
1008 See :ref:`s4u_receiving_actor`.
1009
1010 .. tabs::
1011
1012    .. group-tab:: C++
1013
1014       .. doxygenfunction:: simgrid::s4u::Mailbox::get_receiver
1015       .. doxygenfunction:: simgrid::s4u::Mailbox::set_receiver(ActorPtr actor)
1016
1017    .. group-tab:: C
1018
1019       .. doxygenfunction:: sg_mailbox_set_receiver(const char *alias)
1020
1021 .. _API_s4u_Resource:
1022
1023 =========
1024 Resources
1025 =========
1026
1027 .. _API_s4u_Disk:
1028
1029 =============
1030 ⁣  class Disk
1031 =============
1032
1033 .. doxygenclass:: simgrid::s4u::Disk
1034
1035 Basic management
1036 ----------------
1037
1038 .. tabs::
1039
1040    .. group-tab:: C++
1041
1042       .. code-block:: C++
1043
1044          #include <simgrid/s4u/Disk.hpp>
1045
1046       Note that there is no DiskPtr type and that you cannot use the RAII
1047       idiom on disks because SimGrid does not allow (yet) to create nor
1048       destroy resources once the simulation is started.
1049
1050
1051 Querying info
1052 -------------
1053
1054 .. tabs::
1055
1056    .. group-tab:: C++
1057
1058       .. doxygenfunction:: simgrid::s4u::Disk::get_cname() const
1059       .. doxygenfunction:: simgrid::s4u::Disk::get_host() const
1060       .. doxygenfunction:: simgrid::s4u::Disk::get_name() const
1061       .. doxygenfunction:: simgrid::s4u::Disk::get_properties() const
1062       .. doxygenfunction:: simgrid::s4u::Disk::get_property(const std::string &key) const
1063       .. doxygenfunction:: simgrid::s4u::Disk::get_read_bandwidth() const
1064       .. doxygenfunction:: simgrid::s4u::Disk::get_write_bandwidth() const
1065       .. doxygenfunction:: simgrid::s4u::Disk::set_property(const std::string &, const std::string &value)
1066
1067 I/O operations
1068 --------------
1069
1070 .. tabs::
1071
1072    .. group-tab:: C++
1073
1074       .. doxygenfunction:: simgrid::s4u::Disk::io_init(sg_size_t size, s4u::Io::OpType type)
1075       .. doxygenfunction:: simgrid::s4u::Disk::read(sg_size_t size)
1076       .. doxygenfunction:: simgrid::s4u::Disk::read_async(sg_size_t size)
1077       .. doxygenfunction:: simgrid::s4u::Disk::write(sg_size_t size)
1078       .. doxygenfunction:: simgrid::s4u::Disk::write_async(sg_size_t size)
1079
1080 Signals
1081 -------
1082
1083 .. tabs::
1084
1085    .. group-tab:: C++
1086
1087       .. doxygenvariable:: simgrid::s4u::Disk::on_creation
1088       .. doxygenvariable:: simgrid::s4u::Disk::on_destruction
1089       .. doxygenvariable:: simgrid::s4u::Disk::on_state_change
1090
1091
1092 .. _API_s4u_Host:
1093
1094 =============
1095 ⁣  class Host
1096 =============
1097
1098 .. doxygenclass:: simgrid::s4u::Host
1099
1100 Basic management
1101 ----------------
1102
1103 .. tabs::
1104
1105    .. group-tab:: C++
1106
1107       .. code-block:: C++
1108
1109          #include <simgrid/s4u/Host.hpp>
1110
1111       Note that there is no HostPtr type, and that you cannot use the RAII
1112       idiom on hosts because SimGrid does not allow (yet) to create nor
1113       destroy resources once the simulation is started.
1114
1115       .. doxygenfunction:: simgrid::s4u::Host::destroy()
1116
1117    .. group-tab:: Python
1118
1119       .. code:: Python
1120
1121          from simgrid import Host
1122
1123    .. group-tab:: C
1124
1125       .. code:: C
1126
1127          #include <simgrid/host.h>
1128
1129       .. doxygentypedef:: sg_host_t
1130       .. cpp:type:: const s4u_Host* const_sg_host_t
1131
1132          Pointer to a constant host object.
1133
1134 Retrieving hosts
1135 ----------------
1136
1137 .. tabs::
1138
1139    .. group-tab:: C++
1140
1141       See also :cpp:func:`simgrid::s4u::Engine::get_all_hosts`.
1142
1143       .. doxygenfunction:: simgrid::s4u::Host::by_name(const std::string &name)
1144       .. doxygenfunction:: simgrid::s4u::Host::by_name_or_null(const std::string &name)
1145       .. doxygenfunction:: simgrid::s4u::Host::current()
1146
1147    .. group-tab:: Python
1148
1149       See also :py:func:`simgrid.Engine.get_all_hosts`.
1150
1151       .. automethod:: simgrid.Host.by_name
1152       .. automethod:: simgrid.Host.current
1153
1154    .. group-tab:: C
1155
1156       .. doxygenfunction:: sg_host_by_name(const char *name)
1157       .. doxygenfunction:: sg_host_count()
1158       .. doxygenfunction:: sg_host_list()
1159       .. doxygenfunction:: sg_hosts_as_dynar()
1160
1161 Querying info
1162 -------------
1163
1164 .. tabs::
1165
1166    .. group-tab:: C++
1167
1168       .. doxygenfunction:: simgrid::s4u::Host::get_cname() const
1169       .. doxygenfunction:: simgrid::s4u::Host::get_core_count() const
1170       .. doxygenfunction:: simgrid::s4u::Host::get_name() const
1171       .. doxygenfunction:: simgrid::s4u::Host::get_available_speed() const
1172       .. doxygenfunction:: simgrid::s4u::Host::get_load() const
1173       .. doxygenfunction:: simgrid::s4u::Host::get_speed() const
1174
1175    .. group-tab:: Python
1176
1177       .. autoattribute:: simgrid.Host.name
1178       .. autoattribute:: simgrid.Host.load
1179       .. autoattribute:: simgrid.Host.pstate
1180       .. autoattribute:: simgrid.Host.speed
1181
1182    .. group-tab:: C
1183
1184       .. doxygenfunction:: sg_host_core_count(const_sg_host_t host)
1185       .. doxygenfunction:: sg_host_dump(const_sg_host_t ws)
1186       .. doxygenfunction:: sg_host_get_name(const_sg_host_t host)
1187       .. doxygenfunction:: sg_host_get_load(const_sg_host_t host)
1188       .. doxygenfunction:: sg_host_get_speed(const_sg_host_t host)
1189
1190 User data and properties
1191 ------------------------
1192
1193 .. tabs::
1194
1195    .. group-tab:: C++
1196
1197       .. doxygenfunction:: simgrid::s4u::Host::get_properties() const
1198       .. doxygenfunction:: simgrid::s4u::Host::get_property(const std::string &key) const
1199       .. doxygenfunction:: simgrid::s4u::Host::set_properties(const std::unordered_map< std::string, std::string > &properties)
1200       .. doxygenfunction:: simgrid::s4u::Host::set_property(const std::string &key, const std::string &value)
1201
1202    .. group-tab:: C
1203
1204       .. doxygenfunction:: sg_host_set_property_value(sg_host_t host, const char *name, const char *value)
1205       .. doxygenfunction:: sg_host_get_properties(const_sg_host_t host)
1206       .. doxygenfunction:: sg_host_get_property_value(const_sg_host_t host, const char *name)
1207       .. doxygenfunction:: sg_host_extension_create(void(*deleter)(void *))
1208       .. doxygenfunction:: sg_host_extension_get(const_sg_host_t host, size_t rank)
1209
1210 Retrieving components
1211 ---------------------
1212
1213 .. tabs::
1214
1215    .. group-tab:: C++
1216
1217       .. doxygenfunction:: simgrid::s4u::Host::add_disk(const Disk *disk)
1218       .. doxygenfunction:: simgrid::s4u::Host::get_actor_count() const
1219       .. doxygenfunction:: simgrid::s4u::Host::get_all_actors() const
1220       .. doxygenfunction:: simgrid::s4u::Host::get_disks() const
1221       .. doxygenfunction:: simgrid::s4u::Host::remove_disk(const std::string &disk_name)
1222
1223    .. group-tab:: C
1224
1225       .. doxygenfunction:: sg_host_get_actor_list(const_sg_host_t host, xbt_dynar_t whereto)
1226
1227 On/Off
1228 ------
1229
1230 .. tabs::
1231
1232    .. group-tab:: C++
1233
1234       .. doxygenfunction:: simgrid::s4u::Host::is_on() const
1235       .. doxygenfunction:: simgrid::s4u::Host::turn_off()
1236       .. doxygenfunction:: simgrid::s4u::Host::turn_on()
1237
1238    .. group-tab:: C
1239
1240       .. doxygenfunction:: sg_host_is_on(const_sg_host_t host)
1241       .. doxygenfunction:: sg_host_turn_off(sg_host_t host)
1242       .. doxygenfunction:: sg_host_turn_on(sg_host_t host)
1243
1244 DVFS
1245 ----
1246
1247 .. tabs::
1248
1249    .. group-tab:: C++
1250
1251       .. doxygenfunction:: simgrid::s4u::Host::get_pstate() const
1252       .. doxygenfunction:: simgrid::s4u::Host::get_pstate_count() const
1253       .. doxygenfunction:: simgrid::s4u::Host::get_pstate_speed(int pstate_index) const
1254       .. doxygenfunction:: simgrid::s4u::Host::set_pstate(int pstate_index)
1255       .. doxygenfunction:: simgrid::s4u::Host::set_speed_profile(kernel::profile::Profile *p)
1256       .. doxygenfunction:: simgrid::s4u::Host::set_state_profile(kernel::profile::Profile *p)
1257
1258    .. group-tab:: Python
1259
1260       .. automethod:: simgrid.Host.get_pstate_count
1261       .. automethod:: simgrid.Host.get_pstate_speed
1262
1263    .. group-tab:: C
1264
1265       .. doxygenfunction:: sg_host_get_available_speed(const_sg_host_t host)
1266       .. doxygenfunction:: sg_host_get_nb_pstates(const_sg_host_t host)
1267       .. doxygenfunction:: sg_host_get_pstate(const_sg_host_t host)
1268       .. doxygenfunction:: sg_host_get_pstate_speed(const_sg_host_t host, int pstate_index)
1269       .. doxygenfunction:: sg_host_set_pstate(sg_host_t host, int pstate)
1270
1271 Execution
1272 ---------
1273
1274 .. tabs::
1275
1276    .. group-tab:: C++
1277
1278       .. doxygenfunction:: simgrid::s4u::Host::exec_async
1279       .. doxygenfunction:: simgrid::s4u::Host::execute(double flops) const
1280       .. doxygenfunction:: simgrid::s4u::Host::execute(double flops, double priority) const
1281
1282 Platform and routing
1283 --------------------
1284
1285 .. tabs::
1286
1287    .. group-tab:: C++
1288
1289       .. doxygenfunction:: simgrid::s4u::Host::get_englobing_zone()
1290       .. doxygenfunction:: simgrid::s4u::Host::get_netpoint() const
1291       .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< Link * > &links, double *latency) const
1292       .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< kernel::resource::LinkImpl * > &links, double *latency) const
1293       .. doxygenfunction:: simgrid::s4u::Host::sendto(Host *dest, double byte_amount)
1294       .. doxygenfunction:: simgrid::s4u::Host::sendto_async(Host *dest, double byte_amount)
1295
1296    .. group-tab:: C
1297
1298       .. doxygenfunction:: sg_host_get_route(const_sg_host_t from, const_sg_host_t to, xbt_dynar_t links)
1299       .. doxygenfunction:: sg_host_get_route_bandwidth(const_sg_host_t from, const_sg_host_t to)
1300       .. doxygenfunction:: sg_host_get_route_latency(const_sg_host_t from, const_sg_host_t to)
1301       .. doxygenfunction:: sg_host_sendto(sg_host_t from, sg_host_t to, double byte_amount)
1302
1303 Signals
1304 -------
1305
1306 .. tabs::
1307
1308    .. group-tab:: C++
1309
1310       .. doxygenvariable:: simgrid::s4u::Host::on_creation
1311       .. doxygenvariable:: simgrid::s4u::Host::on_destruction
1312       .. doxygenvariable:: simgrid::s4u::Host::on_speed_change
1313       .. doxygenvariable:: simgrid::s4u::Host::on_state_change
1314
1315 .. _API_s4u_Link:
1316
1317 =============
1318 ⁣  class Link
1319 =============
1320
1321 .. doxygenclass:: simgrid::s4u::Link
1322
1323 Basic management
1324 ----------------
1325
1326 .. tabs::
1327
1328    .. group-tab:: C++
1329
1330       .. code-block:: C++
1331
1332          #include <simgrid/s4u/Link.hpp>
1333
1334       Note that there is no LinkPtr type and that you cannot use the RAII
1335       idiom on hosts because SimGrid does not allow (yet) to create nor
1336       destroy resources once the simulation is started.
1337
1338    .. group-tab:: Python
1339
1340       .. code:: Python
1341
1342          from simgrid import Link
1343
1344    .. group-tab:: C
1345
1346       .. code:: C
1347
1348          #include <simgrid/link.h>
1349
1350       .. doxygentypedef:: sg_link_t
1351       .. cpp:type:: const s4u_Link* const_sg_link_t
1352
1353          Pointer to a constant link object.
1354
1355 Retrieving links
1356 ----------------
1357
1358 .. tabs::
1359
1360    .. group-tab:: C++
1361
1362       See also :cpp:func:`simgrid::s4u::Engine::get_all_links`.
1363
1364       .. doxygenfunction:: simgrid::s4u::Link::by_name(const std::string &name)
1365       .. doxygenfunction:: simgrid::s4u::Link::by_name_or_null(const std::string &name)
1366
1367    .. group-tab:: C
1368
1369       .. doxygenfunction:: sg_link_by_name(const char *name)
1370       .. doxygenfunction:: sg_link_count()
1371       .. doxygenfunction:: sg_link_list()
1372
1373 Querying info
1374 --------------
1375
1376 .. tabs::
1377
1378    .. group-tab:: C++
1379
1380       .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
1381       .. doxygenfunction:: simgrid::s4u::Link::get_cname() const
1382       .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
1383       .. doxygenfunction:: simgrid::s4u::Link::get_name() const
1384       .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
1385       .. doxygenfunction:: simgrid::s4u::Link::get_usage() const
1386       .. doxygenfunction:: simgrid::s4u::Link::is_used() const
1387
1388    .. group-tab:: C
1389
1390       .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
1391       .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
1392       .. doxygenfunction:: sg_link_get_name(const_sg_link_t link)
1393       .. doxygenfunction:: sg_link_is_shared(const_sg_link_t link)
1394
1395 Modifying characteristics
1396 -------------------------
1397
1398 .. tabs::
1399
1400    .. group-tab:: C++
1401
1402       .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth(double value)
1403       .. doxygenfunction:: simgrid::s4u::Link::set_latency(double value)
1404
1405    .. group-tab:: C
1406
1407       .. doxygenfunction:: sg_link_set_bandwidth(sg_link_t link, double value)
1408       .. doxygenfunction:: sg_link_set_latency(sg_link_t link, double value)
1409
1410 User data and properties
1411 ------------------------
1412
1413 .. tabs::
1414
1415    .. group-tab:: C++
1416
1417       .. doxygenfunction:: simgrid::s4u::Link::get_property(const std::string &key) const
1418       .. doxygenfunction:: simgrid::s4u::Link::set_property(const std::string &key, const std::string &value)
1419
1420    .. group-tab:: C
1421
1422       .. doxygenfunction:: sg_link_get_data(const_sg_link_t link)
1423       .. doxygenfunction:: sg_link_set_data(sg_link_t link, void *data)
1424
1425 On/Off
1426 ------
1427
1428 .. tabs::
1429
1430    .. group-tab:: C++
1431
1432       See also :cpp:func:`simgrid::s4u::Link::set_state_profile`.
1433
1434       .. doxygenfunction:: simgrid::s4u::Link::is_on() const
1435       .. doxygenfunction:: simgrid::s4u::Link::turn_off()
1436       .. doxygenfunction:: simgrid::s4u::Link::turn_on()
1437
1438 Dynamic profiles
1439 ----------------
1440
1441 See :ref:`howto_churn` for more details.
1442
1443 .. tabs::
1444
1445    .. group-tab:: C++
1446
1447       .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth_profile(kernel::profile::Profile *profile)
1448       .. doxygenfunction:: simgrid::s4u::Link::set_latency_profile(kernel::profile::Profile *profile)
1449       .. doxygenfunction:: simgrid::s4u::Link::set_state_profile(kernel::profile::Profile *profile)
1450
1451 WIFI links
1452 ----------
1453
1454 .. tabs::
1455
1456    .. group-tab:: C++
1457
1458       .. doxygenfunction:: simgrid::s4u::Link::set_host_wifi_rate
1459
1460 Signals
1461 -------
1462
1463 .. tabs::
1464
1465    .. group-tab:: C++
1466
1467       .. doxygenvariable:: simgrid::s4u::Link::on_bandwidth_change
1468       .. doxygenvariable:: simgrid::s4u::Link::on_communicate
1469       .. doxygenvariable:: simgrid::s4u::Link::on_communication_state_change
1470       .. doxygenvariable:: simgrid::s4u::Link::on_creation
1471       .. doxygenvariable:: simgrid::s4u::Link::on_destruction
1472       .. doxygenvariable:: simgrid::s4u::Link::on_state_change
1473
1474 .. _API_s4u_NetZone:
1475
1476 ================
1477 ⁣  class NetZone
1478 ================
1479
1480 .. doxygenclass:: simgrid::s4u::NetZone
1481
1482 Basic management
1483 ----------------
1484
1485 .. tabs::
1486
1487    .. group-tab:: C++
1488
1489       .. code-block:: C++
1490
1491          #include <simgrid/s4u/NetZone.hpp>
1492
1493       Note that there is no NetZonePtr type and that you cannot use the RAII
1494       idiom on network zones because SimGrid does not allow (yet) to create nor
1495       destroy resources once the simulation is started.
1496
1497    .. group-tab:: C
1498
1499       .. code:: C
1500
1501          #include <simgrid/zone.h>
1502
1503       .. doxygentypedef:: sg_netzone_t
1504       .. cpp:type:: const s4u_NetZone* const_sg_netzone_t
1505
1506          Pointer to a constant network zone object.
1507
1508 Retrieving zones
1509 ----------------
1510
1511 .. tabs::
1512
1513    .. group-tab:: C++
1514
1515       See :cpp:func:`simgrid::s4u::Engine::get_netzone_root`,
1516       :cpp:func:`simgrid::s4u::Engine::netzone_by_name_or_null` and
1517       :cpp:func:`simgrid::s4u::Engine::get_filtered_netzones`.
1518
1519    .. group-tab:: C
1520
1521       .. doxygenfunction:: sg_zone_get_by_name(const char *name)
1522       .. doxygenfunction:: sg_zone_get_root()
1523
1524 Querying info
1525 --------------
1526
1527 .. tabs::
1528
1529    .. group-tab:: C++
1530
1531       .. doxygenfunction:: simgrid::s4u::NetZone::get_cname() const
1532       .. doxygenfunction:: simgrid::s4u::NetZone::get_name() const
1533
1534    .. group-tab:: C
1535
1536       .. doxygenfunction:: sg_zone_get_name(const_sg_netzone_t zone)
1537
1538 User data and properties
1539 ------------------------
1540
1541 .. tabs::
1542
1543    .. group-tab:: C++
1544
1545       .. doxygenfunction:: simgrid::s4u::NetZone::get_properties() const
1546       .. doxygenfunction:: simgrid::s4u::NetZone::get_property(const std::string &key) const
1547       .. doxygenfunction:: simgrid::s4u::NetZone::set_property(const std::string &key, const std::string &value)
1548
1549    .. group-tab:: C
1550
1551       .. doxygenfunction:: sg_zone_get_property_value(const_sg_netzone_t as, const char *name)
1552       .. doxygenfunction:: sg_zone_set_property_value(sg_netzone_t netzone, const char *name, const char *value)
1553
1554 Retrieving components
1555 ---------------------
1556
1557 .. tabs::
1558
1559    .. group-tab:: C++
1560
1561       .. doxygenfunction:: simgrid::s4u::NetZone::get_all_hosts() const
1562       .. doxygenfunction:: simgrid::s4u::NetZone::get_host_count() const
1563
1564    .. group-tab:: C
1565
1566       .. doxygenfunction:: sg_zone_get_hosts(const_sg_netzone_t zone, xbt_dynar_t whereto)
1567
1568 Routing data
1569 ------------
1570
1571 .. tabs::
1572
1573    .. group-tab:: C++
1574
1575       .. doxygenfunction:: simgrid::s4u::NetZone::add_bypass_route
1576       .. doxygenfunction:: simgrid::s4u::NetZone::add_component(kernel::routing::NetPoint *elm)
1577       .. doxygenfunction:: simgrid::s4u::NetZone::add_route
1578       .. doxygenfunction:: simgrid::s4u::NetZone::get_children() const
1579       .. doxygenfunction:: simgrid::s4u::NetZone::get_father()
1580
1581    .. group-tab:: C
1582
1583       .. doxygenfunction:: sg_zone_get_sons(const_sg_netzone_t zone, xbt_dict_t whereto)
1584
1585 Signals
1586 -------
1587
1588 .. tabs::
1589
1590   .. group-tab:: C++
1591
1592      .. doxygenvariable:: simgrid::s4u::NetZone::on_creation
1593      .. doxygenvariable:: simgrid::s4u::NetZone::on_route_creation
1594      .. doxygenvariable:: simgrid::s4u::NetZone::on_seal
1595
1596 .. _API_s4u_VirtualMachine:
1597
1598 =======================
1599 ⁣  class VirtualMachine
1600 =======================
1601
1602
1603 .. doxygenclass:: simgrid::s4u::VirtualMachine
1604
1605 Basic management
1606 ----------------
1607 .. tabs::
1608
1609    .. group-tab:: C++
1610
1611       .. code-block:: C++
1612
1613          #include <simgrid/s4u/VirtualMachine.hpp>
1614
1615       Note that there is no VirtualMachinePtr type, and that you cannot use the RAII
1616       idiom on virtual machines. There is no good reason for that and should change in the future.
1617
1618    .. group-tab:: C
1619
1620       .. code:: C
1621
1622          #include <simgrid/vm.h>
1623
1624       .. doxygentypedef:: sg_vm_t
1625       .. cpp:type:: const s4u_VirtualMachine* const_sg_vm_t
1626
1627          Pointer to a constant virtual machine object.
1628
1629 Creating VMs
1630 ------------
1631
1632 .. tabs::
1633
1634    .. group-tab:: C++
1635
1636       .. doxygenfunction:: simgrid::s4u::VirtualMachine::VirtualMachine(const std::string &name, Host *physical_host, int core_amount)
1637       .. doxygenfunction:: simgrid::s4u::VirtualMachine::VirtualMachine(const std::string &name, Host *physical_host, int core_amount, size_t ramsize)
1638       .. doxygenfunction:: simgrid::s4u::VirtualMachine::destroy
1639
1640    .. group-tab:: C
1641
1642       .. doxygenfunction:: sg_vm_create_core
1643       .. doxygenfunction:: sg_vm_create_multicore
1644       .. doxygenfunction:: sg_vm_destroy
1645
1646 Querying info
1647 --------------
1648
1649 .. tabs::
1650
1651    .. group-tab:: C++
1652
1653       .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_pm() const
1654       .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_ramsize() const
1655       .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_state() const
1656
1657       .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_bound(double bound)
1658       .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_pm(Host *pm)
1659       .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_ramsize(size_t ramsize)
1660
1661    .. group-tab:: C
1662
1663       .. doxygenfunction:: sg_vm_get_ramsize(const_sg_vm_t vm)
1664       .. doxygenfunction:: sg_vm_set_bound(sg_vm_t vm, double bound)
1665       .. doxygenfunction:: sg_vm_set_ramsize(sg_vm_t vm, size_t size)
1666
1667       .. doxygenfunction:: sg_vm_get_name
1668       .. doxygenfunction:: sg_vm_get_pm
1669       .. doxygenfunction:: sg_vm_is_created
1670       .. doxygenfunction:: sg_vm_is_running
1671       .. doxygenfunction:: sg_vm_is_suspended
1672
1673 Life cycle
1674 ----------
1675
1676 .. tabs::
1677
1678    .. group-tab:: C++
1679
1680       .. doxygenfunction:: simgrid::s4u::VirtualMachine::resume()
1681       .. doxygenfunction:: simgrid::s4u::VirtualMachine::shutdown()
1682       .. doxygenfunction:: simgrid::s4u::VirtualMachine::start()
1683       .. doxygenfunction:: simgrid::s4u::VirtualMachine::suspend()
1684
1685    .. group-tab:: C
1686
1687       .. doxygenfunction:: sg_vm_start
1688       .. doxygenfunction:: sg_vm_suspend
1689       .. doxygenfunction:: sg_vm_resume
1690       .. doxygenfunction:: sg_vm_shutdown
1691
1692 Signals
1693 -------
1694
1695 .. tabs::
1696
1697    .. group-tab:: C++
1698
1699       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_migration_end
1700       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_migration_start
1701       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_resume
1702       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_shutdown
1703       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_start
1704       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_started
1705       .. doxygenvariable:: simgrid::s4u::VirtualMachine::on_suspend
1706
1707 .. _API_s4u_Activity:
1708
1709 ==============
1710 class Activity
1711 ==============
1712
1713 .. doxygenclass:: simgrid::s4u::Activity
1714
1715 **Known subclasses:**
1716 :ref:`Communications <API_s4u_Comm>` (started on Mailboxes and consuming links),
1717 :ref:`Executions <API_s4u_Exec>` (started on Host and consuming CPU resources)
1718 :ref:`I/O <API_s4u_Io>` (started on and consumming disks).
1719 See also the :ref:`section on activities <s4u_Activities>` above.
1720
1721 Basic management
1722 ----------------
1723
1724 .. tabs::
1725
1726    .. group-tab:: C++
1727
1728       .. code-block:: C++
1729
1730          #include <simgrid/s4u/Activity.hpp>
1731
1732       .. doxygentypedef:: ActivityPtr
1733
1734 Querying info
1735 -------------
1736
1737 .. tabs::
1738
1739    .. group-tab:: C++
1740
1741       .. doxygenfunction:: simgrid::s4u::Activity::get_cname
1742       .. doxygenfunction:: simgrid::s4u::Activity::get_name
1743       .. doxygenfunction:: simgrid::s4u::Activity::get_remaining() const
1744       .. doxygenfunction:: simgrid::s4u::Activity::get_state() const
1745       .. doxygenfunction:: simgrid::s4u::Activity::set_remaining(double remains)
1746       .. doxygenfunction:: simgrid::s4u::Activity::set_state(Activity::State state)
1747
1748
1749 Activities life cycle
1750 ---------------------
1751
1752 .. tabs::
1753
1754    .. group-tab:: C++
1755
1756       .. doxygenfunction:: simgrid::s4u::Activity::start
1757       .. doxygenfunction:: simgrid::s4u::Activity::cancel
1758       .. doxygenfunction:: simgrid::s4u::Activity::test
1759       .. doxygenfunction:: simgrid::s4u::Activity::wait
1760       .. doxygenfunction:: simgrid::s4u::Activity::wait_for
1761       .. doxygenfunction:: simgrid::s4u::Activity::wait_until(double time_limit)
1762       .. doxygenfunction:: simgrid::s4u::Activity::vetoable_start()
1763
1764 Suspending and resuming an activity
1765 -----------------------------------
1766
1767 .. tabs::
1768
1769    .. group-tab:: C++
1770
1771       .. doxygenfunction:: simgrid::s4u::Activity::suspend
1772       .. doxygenfunction:: simgrid::s4u::Activity::resume
1773       .. doxygenfunction:: simgrid::s4u::Activity::is_suspended
1774
1775 .. _API_s4u_Comm:
1776
1777 =============
1778 ⁣  class Comm
1779 =============
1780
1781 .. doxygenclass:: simgrid::s4u::Comm
1782
1783 Basic management
1784 ----------------
1785
1786 .. tabs::
1787
1788    .. group-tab:: C++
1789
1790       .. code-block:: C++
1791
1792          #include <simgrid/s4u/Comm.hpp>
1793
1794       .. doxygentypedef:: CommPtr
1795
1796    .. group-tab:: Python
1797
1798       .. code:: Python
1799
1800          from simgrid import Comm
1801
1802 Querying info
1803 -------------
1804
1805 .. tabs::
1806
1807    .. group-tab:: C++
1808
1809       .. doxygenfunction:: simgrid::s4u::Comm::get_dst_data_size() const
1810       .. doxygenfunction:: simgrid::s4u::Comm::get_mailbox() const
1811       .. doxygenfunction:: simgrid::s4u::Comm::get_sender() const
1812       .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff)
1813       .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff, size_t size)
1814       .. doxygenfunction:: simgrid::s4u::Comm::detach()
1815       .. doxygenfunction:: simgrid::s4u::Comm::detach(void(*clean_function)(void *))
1816       .. doxygenfunction:: simgrid::s4u::Comm::set_rate(double rate)
1817       .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff)
1818       .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff, size_t size)
1819       .. doxygenfunction:: simgrid::s4u::Comm::set_src_data_size(size_t size)
1820
1821 Life cycle
1822 ----------
1823
1824 .. tabs::
1825
1826    .. group-tab:: C++
1827
1828       .. doxygenfunction:: simgrid::s4u::Comm::cancel
1829       .. doxygenfunction:: simgrid::s4u::Comm::start
1830       .. doxygenfunction:: simgrid::s4u::Comm::test
1831       .. doxygenfunction:: simgrid::s4u::Comm::test_any(const std::vector< CommPtr > *comms)
1832       .. doxygenfunction:: simgrid::s4u::Comm::wait
1833       .. doxygenfunction:: simgrid::s4u::Comm::wait_all(const std::vector< CommPtr > *comms)
1834       .. doxygenfunction:: simgrid::s4u::Comm::wait_any(const std::vector< CommPtr > *comms)
1835       .. doxygenfunction:: simgrid::s4u::Comm::wait_any_for(const std::vector< CommPtr > *comms_in, double timeout)
1836       .. doxygenfunction:: simgrid::s4u::Comm::wait_for
1837
1838    .. group-tab:: Python
1839
1840        .. automethod:: simgrid.Comm.test
1841        .. automethod:: simgrid.Comm.wait
1842        .. automethod:: simgrid.Comm.wait_all
1843        .. automethod:: simgrid.Comm.wait_any
1844
1845 Signals
1846 -------
1847
1848 .. tabs::
1849
1850    .. group-tab:: C++
1851
1852       .. doxygenvariable:: simgrid::s4u::Comm::on_completion
1853       .. doxygenvariable:: simgrid::s4u::Comm::on_start
1854
1855 .. _API_s4u_Exec:
1856
1857 =============
1858 ⁣  class Exec
1859 =============
1860
1861 .. doxygenclass:: simgrid::s4u::Exec
1862
1863 Basic management
1864 ----------------
1865
1866 .. tabs::
1867
1868    .. group-tab:: C++
1869
1870       .. code-block:: C++
1871
1872          #include <simgrid/s4u/Exec.hpp>
1873
1874       .. doxygentypedef:: ExecPtr
1875
1876    .. group-tab:: Python
1877
1878       .. code:: Python
1879
1880          from simgrid import Exec
1881
1882    .. group-tab:: C
1883
1884       .. code-block:: C
1885
1886          #include <simgrid/exec.h>
1887
1888 Querying info
1889 -------------
1890
1891 .. tabs::
1892
1893    .. group-tab:: C++
1894
1895       .. doxygenfunction:: simgrid::s4u::Exec::get_cost() const
1896       .. doxygenfunction:: simgrid::s4u::Exec::get_finish_time() const
1897       .. doxygenfunction:: simgrid::s4u::Exec::get_host() const
1898       .. doxygenfunction:: simgrid::s4u::Exec::get_host_number() const
1899       .. cpp:function:: double Exec::get_remaining()
1900
1901          On sequential executions, returns the amount of flops that remain to be done;
1902          This cannot be used on parallel executions.
1903
1904       .. doxygenfunction:: simgrid::s4u::Exec::get_remaining_ratio
1905       .. doxygenfunction:: simgrid::s4u::Exec::get_start_time() const
1906       .. doxygenfunction:: simgrid::s4u::Exec::set_bound(double bound)
1907       .. doxygenfunction:: simgrid::s4u::Exec::set_host
1908       .. doxygenfunction:: simgrid::s4u::Exec::set_priority(double priority)
1909
1910    .. group-tab:: Python
1911
1912       .. autoattribute:: simgrid.Exec.host
1913       .. autoattribute:: simgrid.Exec.remaining
1914       .. autoattribute:: simgrid.Exec.remaining_ratio
1915
1916    .. group-tab:: C
1917
1918       .. doxygenfunction:: sg_exec_set_bound(sg_exec_t exec, double bound)
1919       .. doxygenfunction:: sg_exec_get_name(const_sg_exec_t exec)
1920       .. doxygenfunction:: sg_exec_set_name(sg_exec_t exec, const char* name)
1921       .. doxygenfunction:: sg_exec_set_host(sg_exec_t exec, sg_host_t new_host)
1922       .. doxygenfunction:: sg_exec_get_remaining(const_sg_exec_t exec)
1923       .. doxygenfunction:: sg_exec_get_remaining_ratio(const_sg_exec_t exec)
1924
1925 Life cycle
1926 ----------
1927
1928 .. tabs::
1929
1930    .. group-tab:: C++
1931
1932       .. doxygenfunction:: simgrid::s4u::Exec::cancel
1933       .. doxygenfunction:: simgrid::s4u::Exec::set_timeout(double timeout)
1934       .. doxygenfunction:: simgrid::s4u::Exec::start
1935       .. doxygenfunction:: simgrid::s4u::Exec::test
1936       .. doxygenfunction:: simgrid::s4u::Exec::wait
1937       .. doxygenfunction:: simgrid::s4u::Exec::wait_any(std::vector< ExecPtr > *execs)
1938       .. doxygenfunction:: simgrid::s4u::Exec::wait_any_for(std::vector< ExecPtr > *execs, double timeout)
1939       .. doxygenfunction:: simgrid::s4u::Exec::wait_for
1940
1941    .. group-tab:: Python
1942
1943        .. automethod:: simgrid.Exec.cancel
1944        .. automethod:: simgrid.Exec.start
1945        .. automethod:: simgrid.Exec.test
1946        .. automethod:: simgrid.Exec.wait
1947
1948    .. group-tab:: C
1949
1950        .. doxygenfunction:: sg_exec_start(sg_exec_t exec)
1951        .. doxygenfunction:: sg_exec_cancel(sg_exec_t exec);
1952        .. doxygenfunction:: sg_exec_test(sg_exec_t exec);
1953        .. doxygenfunction:: sg_exec_wait(sg_exec_t exec);
1954        .. doxygenfunction:: sg_exec_wait_for(sg_exec_t exec, double timeout);
1955        .. doxygenfunction:: sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout);
1956        .. doxygenfunction:: sg_exec_wait_any(sg_exec_t* execs, size_t count);
1957
1958 Signals
1959 -------
1960
1961 .. tabs::
1962
1963    .. group-tab:: C++
1964
1965       .. doxygenvariable:: simgrid::s4u::Exec::on_start
1966       .. doxygenvariable:: simgrid::s4u::Exec::on_completion
1967
1968 .. _API_s4u_Io:
1969
1970 ===========
1971 ⁣  class Io
1972 ===========
1973
1974 .. doxygenclass:: simgrid::s4u::Io
1975
1976 Basic management
1977 ----------------
1978
1979 .. tabs::
1980
1981    .. group-tab:: C++
1982
1983       .. code-block:: C++
1984
1985          #include <simgrid/s4u/Io.hpp>
1986
1987       .. doxygentypedef:: IoPtr
1988
1989 Querying info
1990 -------------
1991
1992 .. tabs::
1993
1994    .. group-tab:: C++
1995
1996       .. doxygenfunction:: simgrid::s4u::Io::get_performed_ioops() const
1997       .. doxygenfunction:: simgrid::s4u::Io::get_remaining
1998
1999 Life cycle
2000 ----------
2001
2002 .. tabs::
2003
2004    .. group-tab:: C++
2005
2006       .. doxygenfunction:: simgrid::s4u::Io::cancel
2007       .. doxygenfunction:: simgrid::s4u::Io::start
2008       .. doxygenfunction:: simgrid::s4u::Io::test
2009       .. doxygenfunction:: simgrid::s4u::Io::wait
2010       .. doxygenfunction:: simgrid::s4u::Io::wait_for
2011
2012 .. _API_s4u_Synchronizations:
2013
2014 =======================
2015 Synchronization Objects
2016 =======================
2017
2018 .. _API_s4u_Mutex:
2019
2020 ==============
2021 ⁣  Mutex
2022 ==============
2023
2024 .. doxygenclass:: simgrid::s4u::Mutex
2025
2026 Basic management
2027 ----------------
2028
2029    .. tabs::
2030
2031       .. group-tab:: C++
2032
2033          .. code-block:: C++
2034
2035             #include <simgrid/s4u/Mutex.hpp>
2036
2037          .. doxygentypedef:: MutexPtr
2038
2039          .. doxygenfunction:: simgrid::s4u::Mutex::Mutex(kernel::activity::MutexImpl *mutex)
2040          .. doxygenfunction:: simgrid::s4u::Mutex::create()
2041          .. doxygenfunction:: simgrid::s4u::Mutex::~Mutex()
2042
2043       .. group-tab:: C
2044
2045          .. code-block:: C
2046
2047             #include <simgrid/mutex.h>
2048
2049          .. doxygentypedef:: sg_mutex_t
2050          .. cpp:type:: const s4u_Mutex* const_sg_mutex_t
2051
2052             Pointer to a constant mutex object.
2053
2054          .. doxygenfunction:: sg_mutex_init()
2055          .. doxygenfunction:: sg_mutex_destroy(const_sg_mutex_t mutex)
2056
2057 Locking
2058 -------
2059
2060    .. tabs::
2061
2062       .. group-tab:: C++
2063
2064          .. doxygenfunction:: simgrid::s4u::Mutex::lock()
2065          .. doxygenfunction:: simgrid::s4u::Mutex::try_lock()
2066          .. doxygenfunction:: simgrid::s4u::Mutex::unlock()
2067
2068       .. group-tab:: C
2069
2070          .. doxygenfunction:: sg_mutex_lock(sg_mutex_t mutex)
2071          .. doxygenfunction:: sg_mutex_try_lock(sg_mutex_t mutex)
2072          .. doxygenfunction:: sg_mutex_unlock(sg_mutex_t mutex)
2073
2074 .. _API_s4u_Barrier:
2075
2076 ================
2077 ⁣  Barrier
2078 ================
2079
2080 .. doxygenclass:: simgrid::s4u::Barrier
2081
2082 .. tabs::
2083
2084    .. group-tab:: C++
2085
2086       .. code-block:: C++
2087
2088          #include <simgrid/s4u/Barrier.hpp>
2089
2090       .. doxygentypedef:: BarrierPtr
2091
2092       .. doxygenfunction:: simgrid::s4u::Barrier::Barrier(unsigned int expected_actors)
2093       .. doxygenfunction:: simgrid::s4u::Barrier::create(unsigned int expected_actors)
2094       .. doxygenfunction:: simgrid::s4u::Barrier::wait()
2095
2096    .. group-tab:: C
2097
2098       .. code-block:: C
2099
2100          #include <simgrid/barrier.hpp>
2101
2102       .. doxygentypedef:: sg_bar_t
2103       .. cpp:type:: const s4u_Barrier* const_sg_bar_t
2104
2105          Pointer to a constant barrier object.
2106
2107       .. doxygenfunction:: sg_barrier_init(unsigned int count)
2108       .. doxygenfunction:: sg_barrier_destroy(const_sg_bar_t bar)
2109       .. doxygenfunction:: sg_barrier_wait(sg_bar_t bar)
2110
2111
2112 .. _API_s4u_ConditionVariable:
2113
2114 ==========================
2115 ⁣  Condition variable
2116 ==========================
2117
2118 .. doxygenclass:: simgrid::s4u::ConditionVariable
2119
2120 Basic management
2121 ----------------
2122
2123    .. tabs::
2124
2125       .. group-tab:: C++
2126
2127          .. code-block:: C++
2128
2129             #include <simgrid/s4u/ConditionVariable.hpp>
2130
2131          .. doxygentypedef:: ConditionVariablePtr
2132
2133          .. doxygenfunction:: simgrid::s4u::ConditionVariable::create()
2134
2135       .. group-tab:: C
2136
2137          .. code-block:: C
2138
2139             #include <simgrid/cond.h>
2140
2141          .. doxygentypedef:: sg_cond_t
2142          .. doxygenfunction:: sg_cond_init
2143          .. doxygenfunction:: sg_cond_destroy
2144
2145 Waiting and notifying
2146 ---------------------
2147
2148    .. tabs::
2149
2150       .. group-tab:: C++
2151
2152          .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_all()
2153          .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_one()
2154          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(s4u::MutexPtr lock)
2155          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< s4u::Mutex > &lock)
2156          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< Mutex > &lock, P pred)
2157          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration)
2158          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration, P pred)
2159          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration)
2160          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration, P pred)
2161          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time)
2162          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time, P pred)
2163          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time)
2164          .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time, P pred)
2165
2166       .. group-tab:: C
2167
2168          .. doxygenfunction:: sg_cond_notify_all
2169          .. doxygenfunction:: sg_cond_notify_one
2170          .. doxygenfunction:: sg_cond_wait
2171          .. doxygenfunction:: sg_cond_wait_for
2172
2173 .. _API_s4u_Semaphore:
2174
2175 ==================
2176 ⁣  Semaphore
2177 ==================
2178
2179 .. doxygenclass:: simgrid::s4u::Semaphore
2180
2181
2182 Basic management
2183 ----------------
2184
2185    .. tabs::
2186
2187       .. group-tab:: C++
2188
2189          .. code-block:: C++
2190
2191             #include <simgrid/s4u/Semaphore.hpp>
2192
2193          .. doxygentypedef:: SemaphorePtr
2194          .. doxygenfunction:: simgrid::s4u::Semaphore::Semaphore(unsigned int initial_capacity)
2195          .. doxygenfunction:: simgrid::s4u::Semaphore::~Semaphore()
2196          .. doxygenfunction:: simgrid::s4u::Semaphore::create(unsigned int initial_capacity)
2197
2198       .. group-tab:: C
2199
2200          .. code-block:: C
2201
2202             #include <simgrid/semaphore.h>
2203
2204          .. doxygentypedef:: sg_sem_t
2205          .. cpp:type:: const s4u_Semaphore* const_sg_sem_t
2206
2207             Pointer to a constant semaphore object.
2208
2209          .. doxygenfunction:: sg_sem_init(int initial_value)
2210          .. doxygenfunction:: sg_sem_destroy(const_sg_sem_t sem)
2211
2212 Locking
2213 -------
2214
2215    .. tabs::
2216
2217       .. group-tab:: C++
2218
2219          .. doxygenfunction:: simgrid::s4u::Semaphore::acquire()
2220          .. doxygenfunction:: simgrid::s4u::Semaphore::acquire_timeout(double timeout)
2221          .. doxygenfunction:: simgrid::s4u::Semaphore::get_capacity() const
2222          .. doxygenfunction:: simgrid::s4u::Semaphore::release()
2223          .. doxygenfunction:: simgrid::s4u::Semaphore::would_block() const
2224
2225       .. group-tab:: C
2226
2227          .. doxygenfunction:: sg_sem_acquire(sg_sem_t sem)
2228          .. doxygenfunction:: sg_sem_acquire_timeout(sg_sem_t sem, double timeout)
2229          .. doxygenfunction:: sg_sem_get_capacity(const_sg_sem_t sem)
2230          .. doxygenfunction:: sg_sem_release(sg_sem_t sem)
2231          .. doxygenfunction:: sg_sem_would_block(const_sg_sem_t sem)
2232
2233 .. |hr| raw:: html
2234
2235    <hr />