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