8 <object id="TOC" data="graphical-toc.svg" type="image/svg+xml"></object>
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";
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
23 Since v3.33 (Spring 2023), S4U is the main interface of SimGrid for algorithms.
24 It is feature complete, but may still evolve slightly in future releases.
25 When this happens, compiling your code will produce deprecation warnings for 4
26 releases (one year) before the removal of the old symbols.
28 .. _S4U_main_concepts:
33 A typical SimGrid simulation is composed of several |API_s4u_Actors|_, that
34 execute user-provided functions. The actors have to explicitly use the
35 S4U interface to express their :ref:`computation <API_s4u_Exec>`,
36 :ref:`communication <API_s4u_Comm>`, :ref:`disk usage <API_s4u_Io>`,
37 and other |API_s4u_Activities|_, so that they get reflected within the
38 simulator. These activities take place on resources such as |API_s4u_Hosts|_,
39 |API_s4u_Links|_, and |API_s4u_Disks|_. SimGrid predicts the time taken by each
40 activity and orchestrates the actors accordingly, waiting for the
41 completion of these activities.
44 When **communicating**, data is not directly sent to other actors but
45 posted onto a |API_s4u_Mailbox|_ that serves as a rendezvous point between
46 communicating actors. This means that you don't need to know who you
47 are talking to, you just put your communication `Put` request in a
48 mailbox, and it will be matched with a complementary `Get`
49 request. Alternatively, actors can interact through **classical
50 synchronization mechanisms** such as |API_s4u_Barrier|_, |API_s4u_Semaphore|_,
51 |API_s4u_Mutex|_, and |API_s4u_ConditionVariable|_.
53 Each actor is located on a simulated |API_s4u_Host|_. Each host is located
54 in a |API_s4u_NetZone|_, that knows the networking path between one
55 resource to another. Each NetZone is included in another one, forming
56 a tree of NetZones which root zone contains the whole platform. The
57 actors can also be located on a |API_s4U_VirtualMachine|_ that may
58 restrict the activities it contains to a limited amount of cores.
59 Virtual machines can also be migrated between hosts.
61 The :ref:`simgrid::s4u::this_actor <API_s4u_this_actor>` namespace
62 provides many helper functions to simplify the code of actors.
64 .. rst-class:: compact-list
66 - **Simulation Elements**
68 - :ref:`class Actor <API_s4u_Actor>`: Active entities executing your application.
69 - :ref:`class Engine <API_s4u_Engine>`: Simulation engine (singleton).
70 - :ref:`class Mailbox <API_s4u_Mailbox>`: Communication rendezvous, with which actors meet each other.
74 - :ref:`class Disk <API_s4u_Disk>`: Resource on which actors can write and read data.
75 - :ref:`class Host <API_s4u_Host>`: Actor location, providing computational power.
76 - :ref:`class Link <API_s4u_Link>`: Interconnecting hosts.
77 - :ref:`class NetZone <API_s4u_NetZone>`: Sub-region of the platform, containing resources (Hosts, Links, etc).
78 - :ref:`class VirtualMachine <API_s4u_VirtualMachine>`: Execution containers that can be moved between Hosts.
80 - **Activities** (:ref:`class Activity <API_s4u_Activity>`): The things that actors can do on resources.
82 - :ref:`class Comm <API_s4u_Comm>`: Communication activity, started on Mailboxes and consuming links.
83 - :ref:`class Exec <API_s4u_Exec>`: Computation activity, started on Host and consuming CPU resources.
84 - :ref:`class Io <API_s4u_Io>`: I/O activity, started on and consuming disks.
86 - **Synchronization Objects**: Classical IPC that actors can use
88 - :ref:`class Barrier <API_s4u_Barrier>`
89 - :ref:`class ConditionVariable <API_s4u_ConditionVariable>`
90 - :ref:`class Mutex <API_s4u_Mutex>`
91 - :ref:`class Semaphore <API_s4u_Semaphore>`
93 .. |API_s4u_Actors| replace:: **Actors**
94 .. _API_s4u_Actors: #api-s4u-actor
96 .. |API_s4u_Activities| replace:: **Activities**
97 .. _API_s4u_Activities: #api-s4u-activity
99 .. |API_s4u_Tasks| replace:: **Tasks**
100 .. _API_s4u_Tasks: #api-s4u-task
102 .. |API_s4u_Hosts| replace:: **Hosts**
103 .. _API_s4u_Hosts: #api-s4u-host
105 .. |API_s4u_Links| replace:: **Links**
106 .. _API_s4u_Links: #api-s4u-link
108 .. |API_s4u_Disks| replace:: **Disks**
109 .. _API_s4u_Disks: #api-s4u-disk
111 .. |API_s4u_VirtualMachine| replace:: **VirtualMachines**
113 .. |API_s4u_Host| replace:: **Host**
115 .. |API_s4u_Mailbox| replace:: **Mailbox**
117 .. |API_s4u_Mailboxes| replace:: **Mailboxes**
118 .. _API_s4u_Mailboxes: #s4u-mailbox
120 .. |API_s4u_NetZone| replace:: **NetZone**
122 .. |API_s4u_Barrier| replace:: **Barrier**
124 .. |API_s4u_Semaphore| replace:: **Semaphore**
126 .. |API_s4u_ConditionVariable| replace:: **ConditionVariable**
128 .. |API_s4u_Mutex| replace:: **Mutex**
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.
141 =======================
142 Asynchronous Activities
143 =======================
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.
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>`.
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.
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
175 .. literalinclude:: ../../examples/cpp/comm-waitall/s4u-comm-waitall.cpp
177 :start-after: init-begin
178 :end-before: init-end
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>`.
186 .. literalinclude:: ../../examples/cpp/comm-waitall/s4u-comm-waitall.cpp
188 :start-after: put-begin
192 =====================
193 Activities Life Cycle
194 =====================
196 Sometimes, you want to change the setting of an activity before it even starts.
198 .. todo:: write this section
200 =====================
201 Repeatable Activities
202 =====================
204 In order to simulate the execution of Dataflow applications, we introduced the
205 concept of |API_s4u_Tasks|, that can be seen as repeatable activities. A Dataflow
206 is defined as a graph of |API_s4u_Tasks|, where each |API_s4u_Tasks| has a set of
207 successors and predecessors. When a |API_s4u_Tasks| ends it sends a token to each
208 of its successors. Each |API_s4u_Tasks| has to receive a token from each of its
209 predecessor to start. Tokens can carry any user-defined data.
211 |API_s4u_Tasks| are composed of several instances: a dispatcher, a collector, and
212 instance_0 to instance_n. The dispatcher rely on a load balancing function to select
213 the next instance to fire. Once this instance finishes it fires the collector.
215 Each instance of an |API_s4u_ExecTask| can be placed on a different host.
216 |API_s4u_Comm| activities are automatically created when an instance triggers
217 another instance on a different host. Each instance has its own parallelism degree
218 to scale horizontally on several cores.
220 To initiate the execution of a Dataflow, it is possible to some make
221 |API_s4u_Tasks| fire one or more activities without waiting for any token with the
222 :cpp:func:`s4u::Task::enqueue_firings() <simgrid::s4u::Task::enqueue_firings>`
225 The parameters of Tasks can be redefined at runtime by attaching
227 :cpp:func:`s4u::Task::on_this_start <simgrid::s4u::Task::on_this_start>`
229 :cpp:func:`s4u::Task::on_this_completion <simgrid::s4u::Task::on_this_completion>`
230 signals. The former is triggered by instances others than the dispatcher and the collector,
231 and the latter is triggered by the collector.
240 Please also refer to the :ref:`API reference for s4u::Mailbox
247 |API_s4u_Mailboxes|_ are rendezvous points for network communications,
248 similar to URLs on which you could post and retrieve data. Actually,
249 the mailboxes are not involved in the communication once it starts,
250 but only to find the contact with which you want to communicate.
252 They are similar to many common things: The phone number, which allows
253 the caller to find the receiver. The Twitter hashtag, which helps
254 senders and receivers to find each other. In TCP, the pair
255 ``{host name, host port}`` to which you can connect to find your peer.
256 In HTTP, URLs through which the clients can connect to the servers.
257 In ZeroMQ, the queues are used to match senders and receivers.
259 One big difference with most of these systems is that no actor is the
260 exclusive owner of a mailbox, neither in sending nor in receiving.
261 Many actors can send into and/or receive from the same mailbox. TCP
262 socket ports for example are shared on the sender side but exclusive
263 on the receiver side (only one process can receive from a given socket
264 at a given point of time).
266 A big difference with TCP sockets or MPI communications is that
267 communications do not start right away after a
268 :cpp:func:`Mailbox::put() <simgrid::s4u::Mailbox::put>`, but wait
269 for the corresponding :cpp:func:`Mailbox::get() <simgrid::s4u::Mailbox::get>`.
270 You can change this by :ref:`declaring a receiving actor <s4u_receiving_actor>`.
272 A big difference with Twitter hashtags is that SimGrid does not
273 offer easy support to broadcast a given message to many
274 receivers. So that would be like a Twitter tag where each message
275 is consumed by the first receiver.
277 A big difference with the ZeroMQ queues is that you cannot filter
278 on the data you want to get from the mailbox. To model such settings
279 in SimGrid, you'd have one mailbox per potential topic, and subscribe
280 to each topic individually with a
281 :cpp:func:`get_async() <simgrid::s4u::Mailbox::get_async>` on each mailbox.
282 Then, use :cpp:func:`Comm::wait_any() <simgrid::s4u::Comm::wait_any>`
283 to get the first message on any of the mailboxes you are subscribed to.
285 The mailboxes are not located on the network, and you can access
286 them without any latency. The network delays are only related to the
287 location of the sender and receiver once the match between them is
288 done on the mailbox. This is just like the phone number that you
289 can use locally, and the geographical distance only comes into play
290 once you start the communication by dialing this number.
292 =====================
293 How to use Mailboxes?
294 =====================
296 You can retrieve any existing mailbox from its name (which is a
297 unique string, just like a Twitter tag). This results in a
298 versatile tool that can be used to build many different
301 To model classical socket communications, use "hostname:port" as
302 mailbox names, and make sure that only one actor reads into a given
303 mailbox. This does not make it easy to build a perfectly realistic
304 model of the TCP sockets, but in most cases, this system is too
305 cumbersome for your simulations anyway. You probably want something
306 simpler, that turns out to be easy to build with the mailboxes.
308 Many SimGrid examples use a sort of yellow page system where the
309 mailbox names are the name of the service (such as "worker",
310 "master", or "reducer"). That way, you don't have to know where your
311 peer is located to contact it. You don't even need its name. Its
312 function is enough for that. This also gives you some sort of load
313 balancing for free if more than one actor pulls from the mailbox:
314 the first actor that can deal with the request will handle it.
316 =========================================
317 How are put() and get() requests matched?
318 =========================================
320 The matching algorithm simple: first come, first serve. When a new
321 send arrives, it matches the oldest enqueued receive. If no receive is
322 currently enqueued, then the incoming send is enqueued. As you can
323 see, the mailbox cannot contain both send and receive requests: all
324 enqueued requests must be of the same sort.
326 .. _s4u_receiving_actor:
328 ===========================
329 Declaring a Receiving Actor
330 ===========================
332 The last twist is that by default in the simulator, the data starts
333 to be exchanged only when both the sender and the receiver are
334 announced (it waits until both :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
335 and :cpp:func:`get() <simgrid::s4u::Mailbox::get()>` are posted).
336 In TCP, since you establish connections beforehand, the data starts to
337 flow as soon as the sender posts it, even if the receiver did not post
338 its :cpp:func:`put() <simgrid::s4u::Mailbox::put()>` yet.
340 To model this in SimGrid, you can declare a specific receiver to a
341 given mailbox (with the function
342 :cpp:func:`set_receiver() <simgrid::s4u::Mailbox::set_receiver()>`).
343 That way, any :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
344 posted to that mailbox will start as soon as possible, and the data
345 will already be there on the receiver host when the receiver actor
346 posts its :cpp:func:`get() <simgrid::s4u::Mailbox::get()>`
348 Note that being permanent receivers of a mailbox prevents actors to be
349 garbage-collected. If your simulation creates many short-lived actors
350 that are marked as permanent receiver, you should call
351 ``mailbox->set_receiver(nullptr)`` by the end of the actors so that their
352 memory gets properly reclaimed. This call should be at the end of the
353 actor's function, not in an on_exit callback.
355 ===============================
356 Communicating without Mailboxes
357 ===============================
359 Sometimes you don't want to simulate communications between actors as
360 allowed by mailboxes, but you want to create a direct communication
361 between two arbitrary hosts. This can arise when you write a
362 high-level model of a centralized scheduler, or when you model direct
363 communications such as one-sided communications in MPI or remote
364 memory direct access in PGAS.
366 For that, :cpp:func:`Comm::sendto() <simgrid::s4u::Comm::sendto()>`
367 simulates a direct communication between the two specified hosts. No
368 mailbox is used, and there is no rendezvous between actors. You can
369 freely mix such direct communications and rendezvous-based
370 communications. Alternatively, :cpp:func:`Comm::sendto_init()
371 <simgrid::s4u::Comm::sendto_init()>` and
372 :cpp:func:`Comm::sendto_async() <simgrid::s4u::Comm::sendto_async()>`
373 create asynchronous direct communications.
380 For sake of simplicity, we use `RAII
381 <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`_
382 for many classes in S4U. This is an idiom where resources are automatically
383 managed through the context. Provided that you never manipulate
384 objects of type Foo directly but always FooPtr references (which are
385 defined as `boost::intrusive_ptr
386 <http://www.boost.org/doc/libs/1_61_0/libs/smart_ptr/intrusive_ptr.html>`_
387 <Foo>), you will never have to explicitly release the resource that
388 you use nor to free the memory of unused objects.
389 Here is a little example:
395 simgrid::s4u::MutexPtr mutex = simgrid::s4u::Mutex::create(); // Too bad we cannot use `new`
397 mutex->lock(); // use the mutex as a simple reference
401 } // The mutex gets automatically freed because the only existing reference gets out of scope
403 Note that Mailboxes, Hosts, and Links are not handled through smart
404 pointers (yet?). This means that it is currently impossible to destroy a
405 mailbox or a link. You can still destroy a host (but probably
406 shouldn't), using :cpp:func:`simgrid::s4u::Host::destroy`.
411 .. _API_s4u_simulation_object:
427 .. doxygenclass:: simgrid::s4u::Actor
429 .. doxygentypedef:: aid_t
432 .. group-tab:: Python
434 .. autoclass:: simgrid.Actor
445 #include <simgrid/s4u/Actor.hpp>
447 .. doxygentypedef:: ActorPtr
449 .. group-tab:: Python
453 from simgrid import Actor
459 #include <simgrid/actor.h>
461 .. doxygentypedef:: sg_actor_t
462 .. doxygentypedef:: const_sg_actor_t
463 .. doxygenfunction:: sg_actor_ref
464 .. doxygenfunction:: sg_actor_unref
470 See also :ref:`the relevant example <s4u_ex_actors_create>`.
476 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::function< void()> &code)
477 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code)
478 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code, Args... args)
479 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::string &function, std::vector< std::string > args)
481 .. doxygenfunction:: simgrid::s4u::Actor::init(const std::string &name, s4u::Host *host)
482 .. doxygenfunction:: simgrid::s4u::Actor::start(const std::function< void()> &code)
483 .. doxygenfunction:: simgrid::s4u::Actor::set_stacksize
485 .. group-tab:: Python
487 .. automethod:: simgrid.Actor.create
491 .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, char *const *argv)
492 .. doxygenfunction:: sg_actor_init(const char *name, sg_host_t host)
493 .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char *const *argv)
494 .. doxygenfunction:: sg_actor_set_stacksize
496 .. doxygenfunction:: sg_actor_attach(const char *name, void *data, sg_host_t host, xbt_dict_t properties)
497 .. doxygenfunction:: sg_actor_detach()
506 .. doxygenfunction:: simgrid::s4u::Actor::by_pid(aid_t pid)
507 .. doxygenfunction:: simgrid::s4u::Actor::self()
509 .. group-tab:: Python
511 .. automethod:: simgrid.Actor.by_pid
512 .. automethod:: simgrid.Actor.self
516 .. doxygenfunction:: sg_actor_by_pid(aid_t pid)
517 .. doxygenfunction:: sg_actor_self()
518 .. doxygenfunction:: sg_actor_list()
527 .. doxygenfunction:: simgrid::s4u::Actor::get_cname
528 .. doxygenfunction:: simgrid::s4u::Actor::get_name
529 .. doxygenfunction:: simgrid::s4u::Actor::get_pid
530 .. doxygenfunction:: simgrid::s4u::Actor::get_ppid
531 .. doxygenfunction:: simgrid::s4u::Actor::get_properties() const
532 .. doxygenfunction:: simgrid::s4u::Actor::get_property(const std::string &key) const
533 .. doxygenfunction:: simgrid::s4u::Actor::set_property(const std::string &key, const std::string &value)
535 .. doxygenfunction:: simgrid::s4u::Actor::get_host
536 .. doxygenfunction:: simgrid::s4u::Actor::set_host
538 .. doxygenfunction:: simgrid::s4u::Actor::get_refcount
539 .. doxygenfunction:: simgrid::s4u::Actor::get_impl
541 .. group-tab:: Python
543 .. autoattribute:: simgrid.Actor.name
544 .. autoattribute:: simgrid.Actor.host
545 .. autoattribute:: simgrid.Actor.pid
546 .. autoattribute:: simgrid.Actor.ppid
550 .. doxygenfunction:: sg_actor_get_name(const_sg_actor_t actor)
551 .. doxygenfunction:: sg_actor_get_pid(const_sg_actor_t actor)
552 .. doxygenfunction:: sg_actor_get_ppid(const_sg_actor_t actor)
553 .. doxygenfunction:: sg_actor_get_properties(const_sg_actor_t actor)
554 .. doxygenfunction:: sg_actor_get_property_value(const_sg_actor_t actor, const char *name)
556 .. doxygenfunction:: sg_actor_get_host(const_sg_actor_t actor)
557 .. doxygenfunction:: sg_actor_set_host(sg_actor_t actor, sg_host_t host)
559 .. doxygenfunction:: sg_actor_get_data(const_sg_actor_t actor)
560 .. doxygenfunction:: sg_actor_set_data(sg_actor_t actor, void *userdata)
562 Suspending and resuming actors
563 ------------------------------
569 .. doxygenfunction:: simgrid::s4u::Actor::suspend()
570 .. doxygenfunction:: simgrid::s4u::Actor::resume()
571 .. doxygenfunction:: simgrid::s4u::Actor::is_suspended
573 .. group-tab:: Python
575 .. automethod:: simgrid.Actor.resume
576 .. automethod:: simgrid.Actor.suspend
577 .. automethod:: simgrid.Actor.is_suspended
581 .. doxygenfunction:: sg_actor_suspend(sg_actor_t actor)
582 .. doxygenfunction:: sg_actor_resume(sg_actor_t actor)
583 .. doxygenfunction:: sg_actor_is_suspended(const_sg_actor_t actor)
585 Specifying when actors should terminate
586 ---------------------------------------
592 .. doxygenfunction:: simgrid::s4u::Actor::kill()
593 .. doxygenfunction:: simgrid::s4u::Actor::kill_all()
594 .. doxygenfunction:: simgrid::s4u::Actor::set_kill_time(double time)
595 .. doxygenfunction:: simgrid::s4u::Actor::get_kill_time
597 .. doxygenfunction:: simgrid::s4u::Actor::restart()
598 .. doxygenfunction:: simgrid::s4u::Actor::daemonize()
599 .. doxygenfunction:: simgrid::s4u::Actor::is_daemon
601 .. group-tab:: Python
603 .. automethod:: simgrid.Actor.kill
604 .. automethod:: simgrid.Actor.kill_all
606 .. automethod:: simgrid.Actor.daemonize
607 .. automethod:: simgrid.Actor.is_daemon
611 .. doxygenfunction:: sg_actor_kill(sg_actor_t actor)
612 .. doxygenfunction:: sg_actor_kill_all()
613 .. doxygenfunction:: sg_actor_set_kill_time(sg_actor_t actor, double kill_time)
615 .. doxygenfunction:: sg_actor_restart(sg_actor_t actor)
616 .. doxygenfunction:: sg_actor_daemonize(sg_actor_t actor)
617 .. doxygenfunction:: sg_actor_is_daemon
619 .. _API_s4u_Actor_end:
621 Reacting to the end of actors
622 -----------------------------
628 .. doxygenfunction:: simgrid::s4u::Actor::on_exit
629 .. doxygenfunction:: simgrid::s4u::Actor::join() const
630 .. doxygenfunction:: simgrid::s4u::Actor::join(double timeout) const
631 .. doxygenfunction:: simgrid::s4u::Actor::set_auto_restart(bool autorestart)
632 .. doxygenfunction:: simgrid::s4u::Actor::get_restart_count
634 .. group-tab:: Python
636 .. automethod:: simgrid.Actor.join
640 .. doxygenfunction:: sg_actor_on_exit
641 .. doxygenfunction:: sg_actor_join(const_sg_actor_t actor, double timeout)
642 .. doxygenfunction:: sg_actor_set_auto_restart(sg_actor_t actor, int auto_restart)
651 .. doxygenfunction:: simgrid::s4u::Actor::on_creation_cb
652 .. doxygenfunction:: simgrid::s4u::Actor::on_suspend_cb
653 .. doxygenfunction:: simgrid::s4u::Actor::on_this_suspend_cb
654 .. doxygenfunction:: simgrid::s4u::Actor::on_host_change_cb
655 .. doxygenfunction:: simgrid::s4u::Actor::on_this_host_change_cb
656 .. doxygenfunction:: simgrid::s4u::Actor::on_resume_cb
657 .. doxygenfunction:: simgrid::s4u::Actor::on_this_resume_cb
658 .. doxygenfunction:: simgrid::s4u::Actor::on_sleep_cb
659 .. doxygenfunction:: simgrid::s4u::Actor::on_this_sleep_cb
660 .. doxygenfunction:: simgrid::s4u::Actor::on_wake_up_cb
661 .. doxygenfunction:: simgrid::s4u::Actor::on_this_wake_up_cb
662 .. doxygenfunction:: simgrid::s4u::Actor::on_termination_cb
663 .. doxygenfunction:: simgrid::s4u::Actor::on_this_termination_cb
664 .. doxygenfunction:: simgrid::s4u::Actor::on_destruction_cb
665 .. doxygenfunction:: simgrid::s4u::Actor::on_this_destruction_cb
667 .. _API_s4u_this_actor:
673 These functions can be used in your user code to interact with the actor
674 currently running (the one retrieved with :cpp:func:`simgrid::s4u::Actor::self`).
675 Using these functions can greatly improve the code readability.
684 .. doxygenfunction:: simgrid::s4u::this_actor::get_cname()
685 .. doxygenfunction:: simgrid::s4u::this_actor::get_name()
686 .. doxygenfunction:: simgrid::s4u::this_actor::get_pid()
687 .. doxygenfunction:: simgrid::s4u::this_actor::get_ppid()
688 .. doxygenfunction:: simgrid::s4u::this_actor::is_maestro()
690 .. doxygenfunction:: simgrid::s4u::this_actor::get_host()
691 .. doxygenfunction:: simgrid::s4u::this_actor::set_host(Host *new_host)
693 .. group-tab:: Python
695 .. autofunction:: simgrid.this_actor.get_host
696 .. autofunction:: simgrid.this_actor.set_host
698 .. autofunction:: simgrid.this_actor.get_pid
699 .. autofunction:: simgrid.this_actor.get_ppid
703 .. doxygenfunction:: sg_actor_self_get_data()
704 .. doxygenfunction:: sg_actor_self_set_data(void *data)
705 .. doxygenfunction:: sg_actor_self_get_name()
706 .. doxygenfunction:: sg_actor_self_get_pid()
707 .. doxygenfunction:: sg_actor_self_get_ppid()
708 .. doxygenfunction:: sg_host_self()
709 .. doxygenfunction:: sg_host_self_get_name()
711 Suspending and resuming
712 -----------------------
718 .. doxygenfunction:: simgrid::s4u::this_actor::suspend()
719 .. doxygenfunction:: simgrid::s4u::this_actor::yield()
721 .. group-tab:: Python
723 .. autofunction:: simgrid.this_actor.suspend
724 .. autofunction:: simgrid.this_actor.yield_
728 .. doxygenfunction:: sg_actor_yield()
737 Please refer to :ref:`the relevant documentation <logging_prog>`.
739 .. group-tab:: Python
741 .. autofunction:: simgrid.this_actor.debug
742 .. autofunction:: simgrid.this_actor.info
743 .. autofunction:: simgrid.this_actor.warning
744 .. autofunction:: simgrid.this_actor.error
753 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(double duration)
754 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(std::chrono::duration< Rep, Period > duration)
755 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(const SimulationTimePoint< Duration > &wakeup_time)
756 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(double wakeup_time)
758 .. group-tab:: Python
760 .. autofunction:: simgrid.this_actor.sleep_for
761 .. autofunction:: simgrid.this_actor.sleep_until
765 .. doxygenfunction:: sg_actor_sleep_for(double duration)
767 Simulating executions
768 ---------------------
770 Simulate the execution of some code on this actor. You can either simulate
771 parallel or sequential code and you can either block upon the termination of
772 the execution, or start an asynchronous activity.
778 .. doxygenfunction:: simgrid::s4u::this_actor::exec_async
779 .. 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)
780 .. doxygenfunction:: simgrid::s4u::this_actor::exec_init(double flops_amounts)
781 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop)
782 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop, double priority)
783 .. 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)
784 .. doxygenfunction:: simgrid::s4u::this_actor::thread_execute
786 .. group-tab:: Python
788 .. autofunction:: simgrid.this_actor.exec_async
789 .. autofunction:: simgrid.this_actor.exec_init
790 .. autofunction:: simgrid.this_actor.execute
794 .. doxygenfunction:: sg_actor_execute(double flops)
795 .. doxygenfunction:: sg_actor_execute_with_priority(double flops, double priority)
796 .. doxygenfunction:: sg_actor_exec_init(double computation_amount)
797 .. doxygenfunction:: sg_actor_exec_async(double computation_amount)
798 .. doxygenfunction:: sg_actor_parallel_exec_init(int host_nb, const sg_host_t* host_list, double* flops_amount, double* bytes_amount);
807 .. doxygenfunction:: simgrid::s4u::this_actor::exit()
808 .. doxygenfunction:: simgrid::s4u::this_actor::on_exit(const std::function< void(bool)> &fun)
810 .. group-tab:: Python
812 .. autofunction:: simgrid.this_actor.exit
813 .. autofunction:: simgrid.this_actor.on_exit
817 See also :cpp:func:`sg_actor_on_exit`.
819 .. doxygenfunction:: sg_actor_exit
831 .. doxygenclass:: simgrid::s4u::Engine
833 .. group-tab:: Python
835 .. autoclass:: simgrid.Engine
844 .. doxygenfunction:: simgrid::s4u::Engine::Engine(int *argc, char **argv)
845 .. doxygenfunction:: simgrid::s4u::Engine::is_initialized()
846 .. doxygenfunction:: simgrid::s4u::Engine::shutdown()
847 .. doxygenfunction:: simgrid::s4u::Engine::get_instance()
849 .. group-tab:: Python
851 .. automethod:: simgrid.Engine.__init__
852 .. autoattribute:: simgrid.Engine.instance
856 .. doxygenfunction:: simgrid_init
865 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &str)
866 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, bool value)
867 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, double value)
868 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, int value)
869 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, const std::string &value)
871 .. doxygenfunction:: simgrid::s4u::Engine::load_deployment
872 .. doxygenfunction:: simgrid::s4u::Engine::load_platform
873 .. doxygenfunction:: simgrid::s4u::Engine::flatify_platform
874 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name)
875 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name, F code)
876 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const std::function< void(int, char **)> &code)
877 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const kernel::actor::ActorCodeFactory &factory)
879 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(int, char **)> &code)
880 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(std::vector< std::string >)> &code)
881 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const kernel::actor::ActorCodeFactory &factory)
883 .. group-tab:: Python
885 .. automethod:: simgrid.Engine.load_deployment
886 .. automethod:: simgrid.Engine.load_platform
887 .. automethod:: simgrid.Engine.register_actor
891 .. doxygenfunction:: simgrid_load_deployment
892 .. doxygenfunction:: simgrid_load_platform
893 .. doxygenfunction:: simgrid_register_default
894 .. doxygenfunction:: simgrid_register_function
904 .. doxygenfunction:: simgrid::s4u::Engine::get_clock()
905 .. doxygenfunction:: simgrid::s4u::Engine::run
906 .. doxygenfunction:: simgrid::s4u::Engine::run_until
908 .. group-tab:: Python
910 .. autoattribute:: simgrid.Engine.clock
911 .. automethod:: simgrid.Engine.run
912 .. automethod:: simgrid.Engine.run_until
916 .. doxygenfunction:: simgrid_get_clock
917 .. doxygenfunction:: simgrid_run
918 .. doxygenfunction:: simgrid_run_until
927 .. doxygenfunction:: simgrid::s4u::Engine::get_actor_count
928 .. doxygenfunction:: simgrid::s4u::Engine::get_all_actors
929 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_actors
933 .. doxygenfunction:: sg_actor_count()
942 .. doxygenfunction:: simgrid::s4u::Engine::get_all_hosts
943 .. doxygenfunction:: simgrid::s4u::Engine::get_host_count
944 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_hosts
945 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name
946 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name_or_null
948 .. group-tab:: Python
950 .. autoattribute:: simgrid.Engine.all_hosts
951 .. automethod:: simgrid.Engine.host_by_name
955 See also :cpp:func:`sg_host_list` and :cpp:func:`sg_host_count`.
964 .. doxygenfunction:: simgrid::s4u::Engine::get_all_links
965 .. doxygenfunction:: simgrid::s4u::Engine::get_link_count
966 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_links
967 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name
968 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name_or_null
970 .. group-tab:: Python
972 .. autoattribute:: simgrid.Engine.all_links
974 Interacting with the routing
975 ----------------------------
981 .. doxygenfunction:: simgrid::s4u::Engine::get_all_netpoints
982 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_netzones
983 .. doxygenfunction:: simgrid::s4u::Engine::get_netzone_root
984 .. doxygenfunction:: simgrid::s4u::Engine::netpoint_by_name_or_null
985 .. doxygenfunction:: simgrid::s4u::Engine::netzone_by_name_or_null
987 .. group-tab:: Python
989 .. autoattribute:: simgrid.Engine.all_netpoints
990 .. autoattribute:: simgrid.Engine.netzone_root
991 .. automethod:: simgrid.Engine.netpoint_by_name
992 .. automethod:: simgrid.Engine.netzone_by_name
1001 .. doxygenfunction:: simgrid::s4u::Engine::on_deadlock_cb
1002 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_created_cb
1003 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_creation_cb
1004 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_start_cb
1005 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_end_cb
1006 .. doxygenfunction:: simgrid::s4u::Engine::on_time_advance_cb
1008 .. _API_s4u_Mailbox:
1018 .. doxygenclass:: simgrid::s4u::Mailbox
1020 .. group-tab:: Python
1022 .. autoclass:: simgrid.Mailbox
1024 Please also refer to the :ref:`full doc on s4u::Mailbox <s4u_mailbox>`.
1035 #include <simgrid/s4u/Mailbox.hpp>
1037 Note that there is no MailboxPtr type and that you cannot use the RAII
1038 idiom on mailboxes because they are internal objects to the simulation
1039 engine. Once created, there is no way to destroy a mailbox before the end
1042 .. doxygenfunction:: simgrid::s4u::Mailbox::by_name(const std::string &name)
1044 .. group-tab:: Python
1048 #include <simgrid/mailbox.h>
1050 .. automethod:: simgrid.Mailbox.by_name
1056 #include <simgrid/s4u/mailbox.h>
1058 .. doxygentypedef:: sg_mailbox_t
1059 .. doxygentypedef:: const_sg_mailbox_t
1061 .. doxygenfunction:: sg_mailbox_by_name(const char *alias)
1070 .. doxygenfunction:: simgrid::s4u::Mailbox::get_cname
1071 .. doxygenfunction:: simgrid::s4u::Mailbox::get_name
1073 .. group-tab:: Python
1075 .. autoattribute:: simgrid.Mailbox.name
1084 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes)
1085 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes, double timeout)
1086 .. doxygenfunction:: simgrid::s4u::Mailbox::put_async(void *data, uint64_t simulated_size_in_bytes)
1087 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init()
1088 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init(void *data, uint64_t simulated_size_in_bytes)
1090 .. group-tab:: Python
1092 .. automethod:: simgrid.Mailbox.put
1093 .. automethod:: simgrid.Mailbox.put_async
1094 .. automethod:: simgrid.Mailbox.put_init
1098 .. doxygenfunction:: sg_mailbox_put(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1099 .. doxygenfunction:: sg_mailbox_put_init(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1100 .. doxygenfunction:: sg_mailbox_put_async(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1110 .. doxygenfunction:: simgrid::s4u::Mailbox::empty
1111 .. doxygenfunction:: simgrid::s4u::Mailbox::front
1112 .. doxygenfunction:: simgrid::s4u::Mailbox::get()
1113 .. doxygenfunction:: simgrid::s4u::Mailbox::get(double timeout)
1114 .. doxygenfunction:: simgrid::s4u::Mailbox::get_async(T **data)
1115 .. doxygenfunction:: simgrid::s4u::Mailbox::get_init()
1116 .. doxygenfunction:: simgrid::s4u::Mailbox::iprobe(int type, const std::function<bool(void *, void *, kernel::activity::CommImpl *)>& match_fun, void *data)
1117 .. doxygenfunction:: simgrid::s4u::Mailbox::listen
1118 .. doxygenfunction:: simgrid::s4u::Mailbox::ready
1120 .. group-tab:: Python
1122 .. automethod:: simgrid.Mailbox.get
1123 .. automethod:: simgrid.Mailbox.get_async
1124 .. autoattribute:: simgrid.Mailbox.ready
1128 .. doxygenfunction:: sg_mailbox_get(sg_mailbox_t mailbox)
1129 .. doxygenfunction:: sg_mailbox_get_async(sg_mailbox_t mailbox, void **data)
1130 .. doxygenfunction:: sg_mailbox_get_name(const_sg_mailbox_t mailbox)
1131 .. doxygenfunction:: sg_mailbox_listen(const char *alias)
1136 See :ref:`s4u_receiving_actor`.
1142 .. doxygenfunction:: simgrid::s4u::Mailbox::get_receiver
1143 .. doxygenfunction:: simgrid::s4u::Mailbox::set_receiver(ActorPtr actor)
1147 .. doxygenfunction:: sg_mailbox_set_receiver(const char *alias)
1149 .. _API_s4u_Resource:
1165 .. doxygenclass:: simgrid::s4u::Disk
1167 .. group-tab:: Python
1169 .. autoclass:: simgrid.Disk
1173 .. doxygentypedef:: sg_disk_t
1174 .. doxygentypedef:: const_sg_disk_t
1185 #include <simgrid/s4u/Disk.hpp>
1187 Note that there is no DiskPtr type and that you cannot use the RAII
1188 idiom on disks because SimGrid does not allow (yet) to create nor
1189 destroy resources once the simulation is started.
1191 .. doxygenfunction:: simgrid::s4u::Disk::seal()
1193 .. group-tab:: Python
1197 from simgrid import Disk
1199 .. automethod:: simgrid.Disk.seal
1209 .. doxygenfunction:: simgrid::s4u::Disk::get_cname() const
1210 .. doxygenfunction:: simgrid::s4u::Disk::get_host() const
1211 .. doxygenfunction:: simgrid::s4u::Disk::get_name() const
1212 .. doxygenfunction:: simgrid::s4u::Disk::get_properties() const
1213 .. doxygenfunction:: simgrid::s4u::Disk::get_property(const std::string &key) const
1214 .. doxygenfunction:: simgrid::s4u::Disk::get_read_bandwidth() const
1215 .. doxygenfunction:: simgrid::s4u::Disk::get_write_bandwidth() const
1216 .. doxygenfunction:: simgrid::s4u::Disk::set_property(const std::string &, const std::string &value)
1217 .. doxygenfunction:: simgrid::s4u::Disk::set_sharing_policy
1219 .. group-tab:: Python
1221 .. autoattribute:: simgrid.Disk.name
1222 .. automethod:: simgrid.Disk.set_sharing_policy
1231 .. doxygenfunction:: simgrid::s4u::Disk::io_init(sg_size_t size, s4u::Io::OpType type) const
1232 .. doxygenfunction:: simgrid::s4u::Disk::read(sg_size_t size) const
1233 .. doxygenfunction:: simgrid::s4u::Disk::read_async(sg_size_t size) const
1234 .. doxygenfunction:: simgrid::s4u::Disk::write(sg_size_t size) const
1235 .. doxygenfunction:: simgrid::s4u::Disk::write_async(sg_size_t size) const
1237 .. group-tab:: Python
1239 .. automethod:: simgrid.Disk.read
1240 .. automethod:: simgrid.Disk.read_async
1241 .. automethod:: simgrid.Disk.write
1242 .. automethod:: simgrid.Disk.write_async
1251 .. doxygenfunction:: simgrid::s4u::Disk::on_creation_cb
1252 .. doxygenfunction:: simgrid::s4u::Disk::on_destruction_cb
1253 .. doxygenfunction:: simgrid::s4u::Disk::on_this_destruction_cb
1254 .. doxygenfunction:: simgrid::s4u::Disk::on_onoff_cb
1255 .. doxygenfunction:: simgrid::s4u::Disk::on_this_onoff_cb
1268 .. doxygenclass:: simgrid::s4u::Host
1270 .. group-tab:: Python
1272 .. autoclass:: simgrid.Host
1283 #include <simgrid/s4u/Host.hpp>
1285 Note that there is no HostPtr type, and that you cannot use the RAII
1286 idiom on hosts because SimGrid does not allow (yet) to create nor
1287 destroy resources once the simulation is started.
1289 .. doxygenfunction:: simgrid::s4u::Host::destroy()
1290 .. doxygenfunction:: simgrid::s4u::Host::seal()
1292 .. group-tab:: Python
1296 from simgrid import Host
1298 .. automethod:: simgrid.Host.seal
1304 #include <simgrid/host.h>
1306 .. doxygentypedef:: sg_host_t
1307 .. cpp:type:: const s4u_Host* const_sg_host_t
1309 Pointer to a constant host object.
1318 See also :cpp:func:`simgrid::s4u::Engine::get_all_hosts`.
1320 .. doxygenfunction:: simgrid::s4u::Host::by_name(const std::string &name)
1321 .. doxygenfunction:: simgrid::s4u::Host::by_name_or_null(const std::string &name)
1322 .. doxygenfunction:: simgrid::s4u::Host::current()
1324 .. group-tab:: Python
1326 See also :py:attr:`simgrid.Engine.all_hosts`.
1328 .. automethod:: simgrid.Host.by_name
1329 .. automethod:: simgrid.Host.current
1333 .. doxygenfunction:: sg_host_by_name(const char *name)
1334 .. doxygenfunction:: sg_host_count()
1335 .. doxygenfunction:: sg_host_list()
1337 Modifying characteristics
1338 -------------------------
1344 .. doxygenfunction:: simgrid::s4u::Host::set_core_count(int core_count)
1345 .. doxygenfunction:: simgrid::s4u::Host::set_coordinates(const std::string& coords)
1346 .. doxygenfunction:: simgrid::s4u::Host::set_sharing_policy
1348 .. group-tab:: Python
1350 .. autoattribute:: simgrid.Host.core_count
1352 .. automethod:: simgrid.Host.set_coordinates
1353 .. automethod:: simgrid.Host.set_sharing_policy
1362 .. doxygenfunction:: simgrid::s4u::Host::get_cname() const
1363 .. doxygenfunction:: simgrid::s4u::Host::get_core_count() const
1364 .. doxygenfunction:: simgrid::s4u::Host::get_name() const
1365 .. doxygenfunction:: simgrid::s4u::Host::get_available_speed() const
1366 .. doxygenfunction:: simgrid::s4u::Host::get_load() const
1367 .. doxygenfunction:: simgrid::s4u::Host::get_speed() const
1369 .. group-tab:: Python
1371 .. autoattribute:: simgrid.Host.name
1372 .. autoattribute:: simgrid.Host.core_count
1373 .. autoattribute:: simgrid.Host.load
1374 .. autoattribute:: simgrid.Host.speed
1375 .. autoattribute:: simgrid.Host.available_speed
1379 .. doxygenfunction:: sg_host_core_count(const_sg_host_t host)
1380 .. doxygenfunction:: sg_host_get_name(const_sg_host_t host)
1381 .. doxygenfunction:: sg_host_get_load(const_sg_host_t host)
1382 .. doxygenfunction:: sg_host_get_speed(const_sg_host_t host)
1384 User data and properties
1385 ------------------------
1391 .. doxygenfunction:: simgrid::s4u::Host::get_properties() const
1392 .. doxygenfunction:: simgrid::s4u::Host::get_property(const std::string &key) const
1393 .. doxygenfunction:: simgrid::s4u::Host::set_properties(const std::unordered_map< std::string, std::string > &properties)
1394 .. doxygenfunction:: simgrid::s4u::Host::set_property(const std::string &key, const std::string &value)
1398 .. doxygenfunction:: sg_host_set_property_value(sg_host_t host, const char *name, const char *value)
1399 .. doxygenfunction:: sg_host_get_properties(const_sg_host_t host)
1400 .. doxygenfunction:: sg_host_get_property_value(const_sg_host_t host, const char *name)
1401 .. doxygenfunction:: sg_host_extension_create(void(*deleter)(void *))
1402 .. doxygenfunction:: sg_host_extension_get(const_sg_host_t host, size_t rank)
1404 Retrieving components
1405 ---------------------
1411 .. doxygenfunction:: simgrid::s4u::Host::add_disk(const Disk *disk)
1412 .. doxygenfunction:: simgrid::s4u::Host::get_actor_count() const
1413 .. doxygenfunction:: simgrid::s4u::Host::get_all_actors() const
1414 .. doxygenfunction:: simgrid::s4u::Host::get_disks() const
1415 .. doxygenfunction:: simgrid::s4u::Host::remove_disk(const std::string &disk_name)
1417 .. group-tab:: Python
1419 .. automethod:: simgrid.Host.get_disks
1423 .. doxygenfunction:: sg_host_get_actor_list(const_sg_host_t host, xbt_dynar_t whereto)
1432 .. doxygenfunction:: simgrid::s4u::Host::is_on() const
1433 .. doxygenfunction:: simgrid::s4u::Host::turn_off()
1434 .. doxygenfunction:: simgrid::s4u::Host::turn_on()
1438 .. doxygenfunction:: sg_host_is_on(const_sg_host_t host)
1439 .. doxygenfunction:: sg_host_turn_off(sg_host_t host)
1440 .. doxygenfunction:: sg_host_turn_on(sg_host_t host)
1442 .. _API_s4u_Host_dvfs:
1447 See also the :ref:`relevant examples <s4u_ex_dvfs>`.
1453 .. doxygenfunction:: simgrid::s4u::Host::get_pstate() const
1454 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_count() const
1455 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_speed(unsigned long pstate_index) const
1456 .. doxygenfunction:: simgrid::s4u::Host::set_pstate(unsigned long pstate_index)
1458 .. group-tab:: Python
1460 .. autoattribute:: simgrid.Host.pstate
1461 .. autoattribute:: simgrid.Host.pstate_count
1462 .. automethod:: simgrid.Host.pstate_speed
1466 .. doxygenfunction:: sg_host_get_available_speed(const_sg_host_t host)
1467 .. doxygenfunction:: sg_host_get_nb_pstates(const_sg_host_t host)
1468 .. doxygenfunction:: sg_host_get_pstate(const_sg_host_t host)
1469 .. doxygenfunction:: sg_host_get_pstate_speed(const_sg_host_t host, unsigned long pstate_index)
1470 .. doxygenfunction:: sg_host_set_pstate(sg_host_t host, unsigned long pstate)
1479 .. doxygenfunction:: simgrid::s4u::Host::set_speed_profile(kernel::profile::Profile *p)
1480 .. doxygenfunction:: simgrid::s4u::Host::set_state_profile(kernel::profile::Profile *p)
1482 .. group-tab:: Python
1484 .. automethod:: simgrid.Host.set_speed_profile
1485 .. automethod:: simgrid.Host.set_state_profile
1494 .. doxygenfunction:: simgrid::s4u::Host::exec_async
1495 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops) const
1496 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops, double priority) const
1498 Platform and routing
1499 --------------------
1501 You can also start direct communications between two arbitrary hosts
1502 using :cpp:func:`Comm::sendto() <simgrid::s4u::Comm::sendto()>`.
1508 .. doxygenfunction:: simgrid::s4u::Host::get_englobing_zone() const
1509 .. doxygenfunction:: simgrid::s4u::Host::get_netpoint() const
1510 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< Link * > &links, double *latency) const
1511 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< kernel::resource::StandardLinkImpl * > &links, double *latency) const
1512 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
1513 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, const std::string& read_bandwidth, const std::string& write_bandwidth)
1515 .. group-tab:: Python
1517 .. autoattribute:: simgrid.Host.netpoint
1518 .. automethod:: simgrid.Host.create_disk
1520 .. automethod:: simgrid.Host.route_to
1524 .. doxygenfunction:: sg_host_get_route(const_sg_host_t from, const_sg_host_t to, xbt_dynar_t links)
1525 .. doxygenfunction:: sg_host_get_route_bandwidth(const_sg_host_t from, const_sg_host_t to)
1526 .. doxygenfunction:: sg_host_get_route_latency(const_sg_host_t from, const_sg_host_t to)
1527 .. doxygenfunction:: sg_host_sendto(sg_host_t from, sg_host_t to, double byte_amount)
1536 .. doxygenfunction:: simgrid::s4u::Host::on_creation_cb
1537 .. doxygenfunction:: simgrid::s4u::Host::on_destruction_cb
1538 .. doxygenfunction:: simgrid::s4u::Host::on_this_destruction_cb
1539 .. doxygenfunction:: simgrid::s4u::Host::on_speed_change_cb
1540 .. doxygenfunction:: simgrid::s4u::Host::on_this_speed_change_cb
1541 .. doxygenfunction:: simgrid::s4u::Host::on_onoff_cb
1542 .. doxygenfunction:: simgrid::s4u::Host::on_this_onoff_cb
1543 .. doxygenfunction:: simgrid::s4u::Host::on_exec_state_change_cb
1555 .. doxygenclass:: simgrid::s4u::Link
1556 .. doxygenclass:: simgrid::s4u::SplitDuplexLink
1557 .. doxygenclass:: simgrid::s4u::LinkInRoute
1560 .. group-tab:: Python
1562 .. autoclass:: simgrid.Link
1573 #include <simgrid/s4u/Link.hpp>
1575 Note that there is no LinkPtr type and that you cannot use the RAII
1576 idiom on hosts because SimGrid does not allow (yet) to create nor
1577 destroy resources once the simulation is started.
1579 .. doxygenfunction:: simgrid::s4u::Link::seal()
1581 .. group-tab:: Python
1585 from simgrid import Link
1587 .. automethod:: simgrid.Link.seal
1593 #include <simgrid/link.h>
1595 .. doxygentypedef:: sg_link_t
1596 .. cpp:type:: const s4u_Link* const_sg_link_t
1598 Pointer to a constant link object.
1607 See also :cpp:func:`simgrid::s4u::Engine::get_all_links`.
1609 .. doxygenfunction:: simgrid::s4u::Link::by_name(const std::string &name)
1610 .. doxygenfunction:: simgrid::s4u::Link::by_name_or_null(const std::string &name)
1612 .. group-tab:: Python
1614 See also :py:attr:`simgrid.Engine.all_links`.
1616 .. automethod:: simgrid.Link.by_name
1617 .. autoattribute:: simgrid.Link.name
1621 .. doxygenfunction:: sg_link_by_name(const char *name)
1622 .. doxygenfunction:: sg_link_count()
1623 .. doxygenfunction:: sg_link_list()
1632 .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
1633 .. doxygenfunction:: simgrid::s4u::Link::get_cname() const
1634 .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
1635 .. doxygenfunction:: simgrid::s4u::Link::get_name() const
1636 .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
1637 .. doxygenfunction:: simgrid::s4u::Link::get_concurrency_limit() const
1638 .. doxygenfunction:: simgrid::s4u::Link::get_usage() const
1639 .. doxygenfunction:: simgrid::s4u::Link::is_used() const
1641 .. group-tab:: Python
1643 .. autoattribute:: simgrid.Link.bandwidth
1644 .. autoattribute:: simgrid.Link.latency
1648 .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
1649 .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
1650 .. doxygenfunction:: sg_link_get_name(const_sg_link_t link)
1651 .. doxygenfunction:: sg_link_is_shared(const_sg_link_t link)
1653 Modifying characteristics
1654 -------------------------
1660 .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth(double value)
1661 .. doxygenfunction:: simgrid::s4u::Link::set_latency(double value)
1662 .. doxygenfunction:: simgrid::s4u::Link::set_latency(const std::string& value)
1663 .. doxygenfunction:: simgrid::s4u::Link::set_concurrency_limit(int limit)
1664 .. doxygenfunction:: simgrid::s4u::Link::set_sharing_policy
1666 .. group-tab:: Python
1668 .. automethod:: simgrid.Link.set_bandwidth
1669 .. automethod:: simgrid.Link.set_latency
1670 .. automethod:: simgrid.Link.set_concurrency_limit
1671 .. automethod:: simgrid.Link.set_sharing_policy
1675 .. doxygenfunction:: sg_link_set_bandwidth(sg_link_t link, double value)
1676 .. doxygenfunction:: sg_link_set_latency(sg_link_t link, double value)
1678 User data and properties
1679 ------------------------
1685 .. doxygenfunction:: simgrid::s4u::Link::get_property(const std::string &key) const
1686 .. doxygenfunction:: simgrid::s4u::Link::set_property(const std::string &key, const std::string &value)
1690 .. doxygenfunction:: sg_link_get_data(const_sg_link_t link)
1691 .. doxygenfunction:: sg_link_set_data(sg_link_t link, void *data)
1700 See also :cpp:func:`simgrid::s4u::Link::set_state_profile`.
1702 .. doxygenfunction:: simgrid::s4u::Link::is_on() const
1703 .. doxygenfunction:: simgrid::s4u::Link::turn_off()
1704 .. doxygenfunction:: simgrid::s4u::Link::turn_on()
1706 .. group-tab:: Python
1708 See also :py:func:`simgrid.Link.set_state_profile`.
1710 .. automethod:: simgrid.Link.is_on
1711 .. automethod:: simgrid.Link.turn_off
1712 .. automethod:: simgrid.Link.turn_on
1717 See :ref:`howto_churn` for more details.
1723 .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth_profile(kernel::profile::Profile *profile)
1724 .. doxygenfunction:: simgrid::s4u::Link::set_latency_profile(kernel::profile::Profile *profile)
1725 .. doxygenfunction:: simgrid::s4u::Link::set_state_profile(kernel::profile::Profile *profile)
1727 .. group-tab:: Python
1729 .. automethod:: simgrid.Link.set_bandwidth_profile
1730 .. automethod:: simgrid.Link.set_latency_profile
1731 .. automethod:: simgrid.Link.set_state_profile
1740 .. doxygenfunction:: simgrid::s4u::Link::set_host_wifi_rate
1742 .. group-tab:: Python
1744 .. automethod:: simgrid.Link.set_host_wifi_rate
1753 .. doxygenfunction:: simgrid::s4u::Link::on_bandwidth_change_cb
1754 .. doxygenfunction:: simgrid::s4u::Link::on_this_bandwidth_change_cb
1755 .. doxygenfunction:: simgrid::s4u::Link::on_communication_state_change_cb
1756 .. doxygenfunction:: simgrid::s4u::Link::on_creation_cb
1757 .. doxygenfunction:: simgrid::s4u::Link::on_destruction_cb
1758 .. doxygenfunction:: simgrid::s4u::Link::on_this_destruction_cb
1759 .. doxygenfunction:: simgrid::s4u::Link::on_onoff_cb
1760 .. doxygenfunction:: simgrid::s4u::Link::on_this_onoff_cb
1762 .. _API_s4u_NetZone:
1772 .. doxygenclass:: simgrid::s4u::NetZone
1774 .. group-tab:: Python
1776 .. autoclass:: simgrid.NetZone
1787 #include <simgrid/s4u/NetZone.hpp>
1789 Note that there is no NetZonePtr type and that you cannot use the RAII
1790 idiom on network zones because SimGrid does not allow (yet) to create nor
1791 destroy resources once the simulation is started.
1793 .. doxygenfunction:: simgrid::s4u::NetZone::seal
1795 .. group-tab:: Python
1799 from simgrid import NetZone
1801 .. automethod:: simgrid.NetZone.seal
1807 #include <simgrid/zone.h>
1809 .. doxygentypedef:: sg_netzone_t
1810 .. cpp:type:: const s4u_NetZone* const_sg_netzone_t
1812 Pointer to a constant network zone object.
1821 See :cpp:func:`simgrid::s4u::Engine::get_netzone_root`,
1822 :cpp:func:`simgrid::s4u::Engine::netzone_by_name_or_null` and
1823 :cpp:func:`simgrid::s4u::Engine::get_filtered_netzones`.
1827 .. doxygenfunction:: sg_zone_get_by_name(const char *name)
1828 .. doxygenfunction:: sg_zone_get_root()
1837 .. doxygenfunction:: simgrid::s4u::NetZone::get_cname() const
1838 .. doxygenfunction:: simgrid::s4u::NetZone::get_name() const
1839 .. doxygenfunction:: simgrid::s4u::NetZone::get_netpoint()
1841 .. group-tab:: Python
1843 .. autoattribute:: simgrid.NetZone.name
1844 .. autoattribute:: simgrid.NetZone.netpoint
1848 .. doxygenfunction:: sg_zone_get_name(const_sg_netzone_t zone)
1850 User data and properties
1851 ------------------------
1857 .. doxygenfunction:: simgrid::s4u::NetZone::get_properties() const
1858 .. doxygenfunction:: simgrid::s4u::NetZone::get_property(const std::string &key) const
1859 .. doxygenfunction:: simgrid::s4u::NetZone::set_property(const std::string &key, const std::string &value)
1861 .. group-tab:: Python
1863 .. automethod:: simgrid.NetZone.set_property
1867 .. doxygenfunction:: sg_zone_get_property_value(const_sg_netzone_t as, const char *name)
1868 .. doxygenfunction:: sg_zone_set_property_value(sg_netzone_t netzone, const char *name, const char *value)
1870 Retrieving components
1871 ---------------------
1877 .. doxygenfunction:: simgrid::s4u::NetZone::get_all_hosts() const
1878 .. doxygenfunction:: simgrid::s4u::NetZone::get_host_count() const
1882 .. doxygenfunction:: sg_zone_get_hosts(const_sg_netzone_t zone, xbt_dynar_t whereto)
1891 .. doxygenfunction:: simgrid::s4u::NetZone::add_component(kernel::routing::NetPoint *elm)
1892 .. doxygenfunction:: simgrid::s4u::NetZone::add_route
1893 .. doxygenfunction:: simgrid::s4u::NetZone::add_bypass_route
1894 .. doxygenfunction:: simgrid::s4u::NetZone::get_children() const
1895 .. doxygenfunction:: simgrid::s4u::NetZone::get_parent() const
1896 .. doxygenfunction:: simgrid::s4u::NetZone::set_parent(const NetZone* parent)
1898 .. group-tab:: Python
1900 .. automethod:: simgrid.NetZone.add_route
1901 .. automethod:: simgrid.NetZone.set_parent
1905 .. doxygenfunction:: sg_zone_get_sons(const_sg_netzone_t zone, xbt_dict_t whereto)
1914 .. doxygenfunction:: simgrid::s4u::NetZone::on_creation_cb
1915 .. doxygenfunction:: simgrid::s4u::NetZone::on_seal_cb
1926 .. doxygenfunction:: simgrid::s4u::create_full_zone
1927 .. doxygenfunction:: simgrid::s4u::create_empty_zone
1928 .. doxygenfunction:: simgrid::s4u::create_star_zone
1929 .. doxygenfunction:: simgrid::s4u::create_dijkstra_zone
1930 .. doxygenfunction:: simgrid::s4u::create_floyd_zone
1931 .. doxygenfunction:: simgrid::s4u::create_vivaldi_zone
1932 .. doxygenfunction:: simgrid::s4u::create_wifi_zone
1933 .. doxygenfunction:: simgrid::s4u::create_torus_zone
1934 .. doxygenfunction:: simgrid::s4u::create_fatTree_zone
1935 .. doxygenfunction:: simgrid::s4u::create_dragonfly_zone
1937 .. group-tab:: Python
1939 .. automethod:: simgrid.NetZone.create_full_zone
1940 .. automethod:: simgrid.NetZone.create_empty_zone
1941 .. automethod:: simgrid.NetZone.create_star_zone
1942 .. automethod:: simgrid.NetZone.create_dijkstra_zone
1943 .. automethod:: simgrid.NetZone.create_floyd_zone
1944 .. automethod:: simgrid.NetZone.create_vivaldi_zone
1945 .. automethod:: simgrid.NetZone.create_wifi_zone
1946 .. automethod:: simgrid.NetZone.create_torus_zone
1947 .. automethod:: simgrid.NetZone.create_fatTree_zone
1948 .. automethod:: simgrid.NetZone.create_dragonfly_zone
1957 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<double>& speed_per_pstate)
1958 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, double speed)
1959 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<std::string>& speed_per_pstate)
1960 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::string& speed)
1962 .. group-tab:: Python
1964 .. automethod:: simgrid.NetZone.create_host
1973 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::vector<double>& bandwidths)
1974 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, double bandwidth)
1975 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::vector<std::string>& bandwidthds)
1976 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::string& bandwidth)
1977 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string& name, const std::string& bandwidth)
1978 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string& name, double bandwidth)
1980 .. group-tab:: Python
1982 .. automethod:: simgrid.NetZone.create_link
1983 .. automethod:: simgrid.NetZone.create_split_duplex_link
1992 .. doxygenfunction:: simgrid::s4u::NetZone::create_router(const std::string& name)
1994 .. group-tab:: Python
1996 .. automethod:: simgrid.NetZone.create_router
1998 .. _API_s4u_VirtualMachine:
2000 =======================
2001 class VirtualMachine
2002 =======================
2005 .. doxygenclass:: simgrid::s4u::VirtualMachine
2015 #include <simgrid/s4u/VirtualMachine.hpp>
2017 Note that there is no VirtualMachinePtr type, and that you cannot use the RAII
2018 idiom on virtual machines. There is no good reason for that and should change in the future.
2024 #include <simgrid/vm.h>
2026 .. doxygentypedef:: sg_vm_t
2027 .. cpp:type:: const s4u_VirtualMachine* const_sg_vm_t
2029 Pointer to a constant virtual machine object.
2038 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount)
2039 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount, size_t ramsize)
2040 .. doxygenfunction:: simgrid::s4u::VirtualMachine::destroy
2044 .. doxygenfunction:: sg_vm_create_core
2045 .. doxygenfunction:: sg_vm_create_multicore
2046 .. doxygenfunction:: sg_vm_destroy
2055 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_pm() const
2056 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_ramsize() const
2057 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_state() const
2059 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_bound(double bound)
2060 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_pm(Host *pm)
2061 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_ramsize(size_t ramsize)
2065 .. doxygenfunction:: sg_vm_get_ramsize(const_sg_vm_t vm)
2066 .. doxygenfunction:: sg_vm_set_bound(sg_vm_t vm, double bound)
2067 .. doxygenfunction:: sg_vm_set_ramsize(sg_vm_t vm, size_t size)
2069 .. doxygenfunction:: sg_vm_get_name
2070 .. doxygenfunction:: sg_vm_get_pm
2071 .. doxygenfunction:: sg_vm_is_created
2072 .. doxygenfunction:: sg_vm_is_running
2073 .. doxygenfunction:: sg_vm_is_suspended
2082 .. doxygenfunction:: simgrid::s4u::VirtualMachine::resume()
2083 .. doxygenfunction:: simgrid::s4u::VirtualMachine::shutdown()
2084 .. doxygenfunction:: simgrid::s4u::VirtualMachine::start()
2085 .. doxygenfunction:: simgrid::s4u::VirtualMachine::suspend()
2089 .. doxygenfunction:: sg_vm_start
2090 .. doxygenfunction:: sg_vm_suspend
2091 .. doxygenfunction:: sg_vm_resume
2092 .. doxygenfunction:: sg_vm_shutdown
2101 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_creation_cb
2102 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_destruction_cb
2103 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_destruction_cb
2104 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_end_cb
2105 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_end_cb
2106 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_start_cb
2107 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_start_cb
2108 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_resume_cb
2109 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_resume_cb
2110 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_shutdown_cb
2111 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_shutdown_cb
2112 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_start_cb
2113 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_start_cb
2114 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_started_cb
2115 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_started_cb
2116 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_suspend_cb
2117 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_suspend_cb
2119 .. _API_s4u_Activity:
2129 .. doxygenclass:: simgrid::s4u::Activity
2131 **Known subclasses:**
2132 :ref:`Communications <API_s4u_Comm>` (started on Mailboxes and consuming links),
2133 :ref:`Executions <API_s4u_Exec>` (started on Host and consuming CPU resources)
2134 :ref:`I/O <API_s4u_Io>` (started on and consuming disks).
2135 See also the :ref:`section on activities <s4u_Activities>` above.
2146 #include <simgrid/s4u/Activity.hpp>
2148 .. doxygentypedef:: ActivityPtr
2157 .. doxygenfunction:: simgrid::s4u::Activity::get_cname() const
2158 .. doxygenfunction:: simgrid::s4u::Activity::get_name() const
2159 .. doxygenfunction:: simgrid::s4u::Activity::get_remaining() const
2160 .. doxygenfunction:: simgrid::s4u::Activity::get_state() const
2161 .. doxygenfunction:: simgrid::s4u::Activity::set_remaining(double remains)
2162 .. doxygenfunction:: simgrid::s4u::Activity::set_state(Activity::State state)
2165 Activities life cycle
2166 ---------------------
2172 .. doxygenfunction:: simgrid::s4u::Activity::start
2173 .. doxygenfunction:: simgrid::s4u::Activity::cancel
2174 .. doxygenfunction:: simgrid::s4u::Activity::test
2175 .. doxygenfunction:: simgrid::s4u::Activity::wait
2176 .. doxygenfunction:: simgrid::s4u::Activity::wait_for
2177 .. doxygenfunction:: simgrid::s4u::Activity::wait_until(double time_limit)
2178 .. doxygenfunction:: simgrid::s4u::Activity::vetoable_start()
2180 Suspending and resuming an activity
2181 -----------------------------------
2187 .. doxygenfunction:: simgrid::s4u::Activity::suspend
2188 .. doxygenfunction:: simgrid::s4u::Activity::resume
2189 .. doxygenfunction:: simgrid::s4u::Activity::is_suspended
2201 .. doxygenclass:: simgrid::s4u::Comm
2203 .. group-tab:: Python
2205 .. autoclass:: simgrid.Comm
2216 #include <simgrid/s4u/Comm.hpp>
2218 .. doxygentypedef:: CommPtr
2220 .. group-tab:: Python
2224 from simgrid import Comm
2230 #include <simgrid/comm.h>
2232 .. doxygentypedef:: sg_comm_t
2241 .. doxygenfunction:: simgrid::s4u::Comm::get_dst_data_size() const
2242 .. doxygenfunction:: simgrid::s4u::Comm::get_mailbox() const
2243 .. doxygenfunction:: simgrid::s4u::Comm::get_sender() const
2244 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff)
2245 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff, size_t size)
2246 .. doxygenfunction:: simgrid::s4u::Comm::detach()
2247 .. doxygenfunction:: simgrid::s4u::Comm::detach(const std::function<void(void*)>& clean_function)
2248 .. doxygenfunction:: simgrid::s4u::Comm::set_payload_size(uint64_t bytes)
2249 .. doxygenfunction:: simgrid::s4u::Comm::set_rate(double rate)
2250 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff)
2251 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff, size_t size)
2252 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data_size(size_t size)
2254 .. group-tab:: Python
2256 .. autoattribute:: simgrid.Comm.dst_data_size
2257 .. autoattribute:: simgrid.Comm.mailbox
2258 .. autoattribute:: simgrid.Comm.sender
2259 .. autoattribute:: simgrid.Comm.state_str
2260 .. automethod:: simgrid.Comm.detach
2261 .. automethod:: simgrid.Comm.set_payload_size
2262 .. automethod:: simgrid.Comm.set_rate
2264 Direct host-to-host communication
2265 ---------------------------------
2267 Most communications are created using :ref:`s4u_mailbox`, but you can
2268 also start direct communications as shown below. See also the
2269 :ref:`relevant examples <s4u_ex_comm_host2host>`.
2275 .. doxygenfunction:: simgrid::s4u::Comm::sendto
2276 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init()
2277 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init(Host *from, Host *to)
2278 .. doxygenfunction:: simgrid::s4u::Comm::sendto_async
2280 .. group-tab:: Python
2282 .. automethod:: simgrid.Comm.sendto
2283 .. automethod:: simgrid.Comm.sendto_init
2284 .. automethod:: simgrid.Comm.sendto_async
2293 .. doxygenfunction:: simgrid::s4u::Comm::cancel
2294 .. doxygenfunction:: simgrid::s4u::Comm::start
2295 .. doxygenfunction:: simgrid::s4u::Comm::test
2296 .. doxygenfunction:: simgrid::s4u::Comm::test_any(const std::vector< CommPtr >& comms)
2297 .. doxygenfunction:: simgrid::s4u::Comm::wait
2298 .. doxygenfunction:: simgrid::s4u::Comm::wait_all(const std::vector< CommPtr >& comms)
2299 .. doxygenfunction:: simgrid::s4u::Comm::wait_all_for(const std::vector< CommPtr >& comms, double timeout)
2300 .. doxygenfunction:: simgrid::s4u::Comm::wait_any(const std::vector< CommPtr >& comms)
2301 .. doxygenfunction:: simgrid::s4u::Comm::wait_any_for(const std::vector< CommPtr >& comms, double timeout)
2302 .. doxygenfunction:: simgrid::s4u::Comm::wait_for
2303 .. doxygenfunction:: simgrid::s4u::Comm::wait_until
2305 .. group-tab:: Python
2307 .. automethod:: simgrid.Comm.cancel
2308 .. automethod:: simgrid.Comm.start
2309 .. automethod:: simgrid.Comm.test
2310 .. automethod:: simgrid.Comm.test_any
2311 .. automethod:: simgrid.Comm.wait
2312 .. automethod:: simgrid.Comm.wait_for
2313 .. automethod:: simgrid.Comm.wait_all
2314 .. automethod:: simgrid.Comm.wait_all_for
2315 .. automethod:: simgrid.Comm.wait_any
2316 .. automethod:: simgrid.Comm.wait_any_for
2317 .. automethod:: simgrid.Comm.wait_until
2321 .. doxygenfunction:: sg_comm_test
2322 .. doxygenfunction:: sg_comm_wait
2323 .. doxygenfunction:: sg_comm_wait_all
2324 .. doxygenfunction:: sg_comm_wait_any
2326 Suspending and resuming a communication
2327 ---------------------------------------
2333 .. doxygenfunction:: simgrid::s4u::Comm::suspend
2334 .. doxygenfunction:: simgrid::s4u::Comm::resume
2335 .. doxygenfunction:: simgrid::s4u::Comm::is_suspended
2337 .. group-tab:: Python
2339 .. automethod:: simgrid.Comm.suspend
2340 .. automethod:: simgrid.Comm.resume
2341 .. autoattribute:: simgrid.Comm.is_suspended
2350 .. doxygenfunction:: simgrid::s4u::Comm::on_start_cb
2351 .. doxygenfunction:: simgrid::s4u::Comm::on_this_start_cb
2352 .. doxygenfunction:: simgrid::s4u::Comm::on_completion_cb
2353 .. doxygenfunction:: simgrid::s4u::Comm::on_this_completion_cb
2354 .. doxygenfunction:: simgrid::s4u::Comm::on_recv_cb
2355 .. doxygenfunction:: simgrid::s4u::Comm::on_send_cb
2356 .. doxygenfunction:: simgrid::s4u::Comm::on_suspended_cb
2357 .. doxygenfunction:: simgrid::s4u::Comm::on_resumed_cb
2358 .. doxygenfunction:: simgrid::s4u::Comm::on_veto_cb
2370 .. doxygenclass:: simgrid::s4u::Exec
2372 .. group-tab:: Python
2374 .. autoclass:: simgrid.Exec
2385 #include <simgrid/s4u/Exec.hpp>
2387 .. doxygentypedef:: ExecPtr
2389 .. group-tab:: Python
2393 from simgrid import Exec
2399 #include <simgrid/exec.h>
2401 .. doxygentypedef:: sg_exec_t
2402 .. doxygentypedef:: const_sg_exec_t
2411 .. doxygenfunction:: simgrid::s4u::Exec::get_cost() const
2412 .. doxygenfunction:: simgrid::s4u::Exec::get_finish_time() const
2413 .. doxygenfunction:: simgrid::s4u::Exec::get_host() const
2414 .. doxygenfunction:: simgrid::s4u::Exec::get_host_number() const
2415 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining
2416 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining_ratio
2417 .. doxygenfunction:: simgrid::s4u::Exec::get_start_time() const
2418 .. doxygenfunction:: simgrid::s4u::Exec::set_bound(double bound)
2419 .. doxygenfunction:: simgrid::s4u::Exec::set_host
2420 .. doxygenfunction:: simgrid::s4u::Exec::set_priority(double priority)
2422 .. group-tab:: Python
2424 .. autoattribute:: simgrid.Exec.host
2425 .. autoattribute:: simgrid.Exec.remaining
2426 .. autoattribute:: simgrid.Exec.remaining_ratio
2430 .. doxygenfunction:: sg_exec_set_bound(sg_exec_t exec, double bound)
2431 .. doxygenfunction:: sg_exec_get_name(const_sg_exec_t exec)
2432 .. doxygenfunction:: sg_exec_set_name(sg_exec_t exec, const char* name)
2433 .. doxygenfunction:: sg_exec_set_host(sg_exec_t exec, sg_host_t new_host)
2434 .. doxygenfunction:: sg_exec_get_remaining(const_sg_exec_t exec)
2435 .. doxygenfunction:: sg_exec_get_remaining_ratio(const_sg_exec_t exec)
2444 .. doxygenfunction:: simgrid::s4u::Exec::cancel
2445 .. doxygenfunction:: simgrid::s4u::Exec::start
2446 .. doxygenfunction:: simgrid::s4u::Exec::test
2447 .. doxygenfunction:: simgrid::s4u::Exec::wait
2448 .. doxygenfunction:: simgrid::s4u::Exec::wait_any(const std::vector< ExecPtr >& execs)
2449 .. doxygenfunction:: simgrid::s4u::Exec::wait_any_for(const std::vector< ExecPtr >& execs, double timeout)
2450 .. doxygenfunction:: simgrid::s4u::Exec::wait_for
2452 .. group-tab:: Python
2454 .. automethod:: simgrid.Exec.cancel
2455 .. automethod:: simgrid.Exec.start
2456 .. automethod:: simgrid.Exec.test
2457 .. automethod:: simgrid.Exec.wait
2461 .. doxygenfunction:: sg_exec_start(sg_exec_t exec)
2462 .. doxygenfunction:: sg_exec_cancel(sg_exec_t exec);
2463 .. doxygenfunction:: sg_exec_test(sg_exec_t exec);
2464 .. doxygenfunction:: sg_exec_wait(sg_exec_t exec);
2465 .. doxygenfunction:: sg_exec_wait_for(sg_exec_t exec, double timeout);
2466 .. doxygenfunction:: sg_exec_wait_any_for(sg_exec_t* execs, size_t count, double timeout);
2467 .. doxygenfunction:: sg_exec_wait_any(sg_exec_t* execs, size_t count);
2469 Suspending and resuming an execution
2470 ------------------------------------
2476 .. doxygenfunction:: simgrid::s4u::Exec::suspend
2477 .. doxygenfunction:: simgrid::s4u::Exec::resume
2478 .. doxygenfunction:: simgrid::s4u::Exec::is_suspended
2480 .. group-tab:: Python
2482 .. automethod:: simgrid.Exec.suspend
2483 .. automethod:: simgrid.Exec.resume
2484 .. autoattribute:: simgrid.Exec.is_suspended
2493 .. doxygenfunction:: simgrid::s4u::Exec::on_start_cb
2494 .. doxygenfunction:: simgrid::s4u::Exec::on_this_start_cb
2495 .. doxygenfunction:: simgrid::s4u::Exec::on_completion_cb
2496 .. doxygenfunction:: simgrid::s4u::Exec::on_this_completion_cb
2498 .. doxygenfunction:: simgrid::s4u::Exec::on_suspended_cb
2499 .. doxygenfunction:: simgrid::s4u::Exec::on_resumed_cb
2500 .. doxygenfunction:: simgrid::s4u::Exec::on_veto_cb
2512 .. doxygenclass:: simgrid::s4u::Io
2514 .. group-tab:: Python
2516 .. autoclass:: simgrid.Io
2527 #include <simgrid/s4u/Io.hpp>
2529 .. doxygentypedef:: IoPtr
2538 .. doxygenfunction:: simgrid::s4u::Io::get_performed_ioops() const
2539 .. doxygenfunction:: simgrid::s4u::Io::get_remaining
2548 .. doxygenfunction:: simgrid::s4u::Io::cancel
2549 .. doxygenfunction:: simgrid::s4u::Io::start
2550 .. doxygenfunction:: simgrid::s4u::Io::test
2551 .. doxygenfunction:: simgrid::s4u::Io::wait
2552 .. doxygenfunction:: simgrid::s4u::Io::wait_for
2553 .. doxygenfunction:: simgrid::s4u::Io::wait_any(const std::vector<IoPtr> &ios)
2554 .. doxygenfunction:: simgrid::s4u::Io::wait_any_for(const std::vector<IoPtr> &ios, double timeout)
2556 .. group-tab:: Python
2558 .. automethod:: simgrid.Io.test
2559 .. automethod:: simgrid.Io.wait
2560 .. automethod:: simgrid.Io.wait_any_for
2561 .. automethod:: simgrid.Io.wait_any
2570 .. doxygenfunction:: simgrid::s4u::Io::on_start_cb
2571 .. doxygenfunction:: simgrid::s4u::Io::on_this_start_cb
2572 .. doxygenfunction:: simgrid::s4u::Io::on_completion_cb
2573 .. doxygenfunction:: simgrid::s4u::Io::on_this_completion_cb
2575 .. doxygenfunction:: simgrid::s4u::Io::on_suspended_cb
2576 .. doxygenfunction:: simgrid::s4u::Io::on_resumed_cb
2577 .. doxygenfunction:: simgrid::s4u::Io::on_veto_cb
2590 .. doxygenclass:: simgrid::s4u::Task
2592 **Known subclasses:**
2593 :ref:`Communication Tasks <API_s4u_CommTask>`,
2594 :ref:`Executions Tasks <API_s4u_ExecTask>`,
2595 :ref:`I/O Tasks <API_s4u_IoTask>`.
2596 See also the :ref:`section on activities <s4u_Tasks>` above.
2607 #include <simgrid/s4u/Task.hpp>
2609 .. doxygentypedef:: TaskPtr
2618 .. doxygenfunction:: simgrid::s4u::Task::get_cname() const
2619 .. doxygenfunction:: simgrid::s4u::Task::get_name() const
2620 .. doxygenfunction:: simgrid::s4u::Task::get_count() const
2621 .. doxygenfunction:: simgrid::s4u::Task::get_amount() const
2622 .. doxygenfunction:: simgrid::s4u::Task::get_parallelism_degree() const
2623 .. doxygenfunction:: simgrid::s4u::Task::set_name(std::string name)
2624 .. doxygenfunction:: simgrid::s4u::Task::set_amount(double amount)
2625 .. doxygenfunction:: simgrid::s4u::Task::set_parallelism_degree(int n)
2633 .. doxygenfunction:: simgrid::s4u::Task::enqueue_firings(int n)
2635 Managing Dependencies
2636 ---------------------
2640 .. doxygenfunction:: simgrid::s4u::Task::add_successor(TaskPtr t)
2641 .. doxygenfunction:: simgrid::s4u::Task::remove_successor(TaskPtr t)
2642 .. doxygenfunction:: simgrid::s4u::Task::remove_all_successors()
2643 .. doxygenfunction:: simgrid::s4u::Task::get_successors() const
2647 .. doxygenclass:: simgrid::s4u::Token
2652 .. doxygenfunction:: simgrid::s4u::Task::get_next_token_from(TaskPtr t)
2653 .. doxygenfunction:: simgrid::s4u::Task::set_token(std::shared_ptr<Token> token)
2661 .. doxygenfunction:: simgrid::s4u::Task::on_start_cb
2662 .. doxygenfunction:: simgrid::s4u::Task::on_this_start_cb
2663 .. doxygenfunction:: simgrid::s4u::Task::on_completion_cb
2664 .. doxygenfunction:: simgrid::s4u::Task::on_this_completion_cb
2666 .. _API_s4u_CommTask:
2675 .. doxygenclass:: simgrid::s4u::CommTask
2686 #include <simgrid/s4u/Task.hpp>
2688 .. doxygentypedef:: CommTaskPtr
2697 .. doxygenfunction:: simgrid::s4u::CommTask::get_source() const
2698 .. doxygenfunction:: simgrid::s4u::CommTask::get_destination() const
2699 .. doxygenfunction:: simgrid::s4u::CommTask::get_bytes() const
2700 .. doxygenfunction:: simgrid::s4u::CommTask::set_source(Host* source);
2701 .. doxygenfunction:: simgrid::s4u::CommTask::set_destination(Host* destination);
2702 .. doxygenfunction:: simgrid::s4u::CommTask::set_bytes(double bytes)
2705 .. _API_s4u_ExecTask:
2714 .. doxygenclass:: simgrid::s4u::ExecTask
2725 #include <simgrid/s4u/Task.hpp>
2727 .. doxygentypedef:: ExecTaskPtr
2736 .. doxygenfunction:: simgrid::s4u::ExecTask::get_host() const
2737 .. doxygenfunction:: simgrid::s4u::ExecTask::get_flops() const
2738 .. doxygenfunction:: simgrid::s4u::ExecTask::set_host(Host* host);
2739 .. doxygenfunction:: simgrid::s4u::ExecTask::set_flops(double flops);
2750 .. doxygenclass:: simgrid::s4u::IoTask
2761 #include <simgrid/s4u/Task.hpp>
2763 .. doxygentypedef:: IoTaskPtr
2772 .. doxygenfunction:: simgrid::s4u::IoTask::get_disk() const
2773 .. doxygenfunction:: simgrid::s4u::IoTask::get_bytes() const
2774 .. doxygenfunction:: simgrid::s4u::IoTask::get_op_type() const
2775 .. doxygenfunction:: simgrid::s4u::IoTask::set_disk(Disk* disk);
2776 .. doxygenfunction:: simgrid::s4u::IoTask::set_bytes(double bytes);
2777 .. doxygenfunction:: simgrid::s4u::IoTask::set_op_type(Io::OpType type);
2779 .. _API_s4u_Synchronizations:
2781 =======================
2782 Synchronization Objects
2783 =======================
2795 .. doxygenclass:: simgrid::s4u::Mutex
2797 .. group-tab:: Python
2799 .. autoclass:: simgrid.Mutex
2810 #include <simgrid/s4u/Mutex.hpp>
2812 .. doxygentypedef:: MutexPtr
2814 .. doxygenfunction:: simgrid::s4u::Mutex::create()
2816 .. group-tab:: Python
2818 .. code-block:: Python
2820 from simgrid import Mutex
2823 # Use a context manager to acquire and automatically release the mutex
2824 # when leaving the scope.
2826 # Access shared resource ...
2829 .. automethod:: simgrid.Mutex.__init__
2835 #include <simgrid/mutex.h>
2837 .. doxygentypedef:: sg_mutex_t
2838 .. cpp:type:: const s4u_Mutex* const_sg_mutex_t
2840 Pointer to a constant mutex object.
2842 .. doxygenfunction:: sg_mutex_init()
2843 .. doxygenfunction:: sg_mutex_destroy(const_sg_mutex_t mutex)
2852 .. doxygenfunction:: simgrid::s4u::Mutex::lock()
2853 .. doxygenfunction:: simgrid::s4u::Mutex::try_lock()
2854 .. doxygenfunction:: simgrid::s4u::Mutex::unlock()
2856 .. group-tab:: Python
2858 .. automethod:: simgrid.Mutex.lock
2859 .. automethod:: simgrid.Mutex.try_lock
2860 .. automethod:: simgrid.Mutex.unlock
2864 .. doxygenfunction:: sg_mutex_lock(sg_mutex_t mutex)
2865 .. doxygenfunction:: sg_mutex_try_lock(sg_mutex_t mutex)
2866 .. doxygenfunction:: sg_mutex_unlock(sg_mutex_t mutex)
2868 .. _API_s4u_Barrier:
2878 .. doxygenclass:: simgrid::s4u::Barrier
2880 .. group-tab:: Python
2882 .. autoclass:: simgrid.Barrier
2890 #include <simgrid/s4u/Barrier.hpp>
2892 .. doxygentypedef:: BarrierPtr
2894 .. doxygenfunction:: simgrid::s4u::Barrier::create(unsigned int expected_actors)
2895 .. doxygenfunction:: simgrid::s4u::Barrier::wait()
2897 .. group-tab:: Python
2899 .. code-block:: Python
2901 from simgrid import Barrier
2902 barrier = Barrier(2)
2904 .. automethod:: simgrid.Barrier.__init__
2905 .. automethod:: simgrid.Barrier.wait
2911 #include <simgrid/barrier.hpp>
2913 .. doxygentypedef:: sg_bar_t
2915 .. doxygenfunction:: sg_barrier_init(unsigned int count)
2916 .. doxygenfunction:: sg_barrier_destroy(sg_bar_t bar)
2917 .. doxygenfunction:: sg_barrier_wait(sg_bar_t bar)
2920 .. _API_s4u_ConditionVariable:
2922 ==========================
2923 Condition variable
2924 ==========================
2926 .. doxygenclass:: simgrid::s4u::ConditionVariable
2937 #include <simgrid/s4u/ConditionVariable.hpp>
2939 .. doxygentypedef:: ConditionVariablePtr
2941 .. doxygenfunction:: simgrid::s4u::ConditionVariable::create()
2947 #include <simgrid/cond.h>
2949 .. doxygentypedef:: sg_cond_t
2950 .. doxygentypedef:: const_sg_cond_t
2951 .. doxygenfunction:: sg_cond_init
2952 .. doxygenfunction:: sg_cond_destroy
2954 Waiting and notifying
2955 ---------------------
2961 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_all()
2962 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_one()
2963 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(s4u::MutexPtr lock)
2964 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< s4u::Mutex > &lock)
2965 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< Mutex > &lock, P pred)
2966 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration)
2967 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration, P pred)
2968 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration)
2969 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration, P pred)
2970 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time)
2971 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time, P pred)
2972 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time)
2973 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time, P pred)
2977 .. doxygenfunction:: sg_cond_notify_all
2978 .. doxygenfunction:: sg_cond_notify_one
2979 .. doxygenfunction:: sg_cond_wait
2980 .. doxygenfunction:: sg_cond_wait_for
2982 .. _API_s4u_Semaphore:
2992 .. doxygenclass:: simgrid::s4u::Semaphore
2994 .. group-tab:: Python
2996 .. autoclass:: simgrid.Semaphore
3007 #include <simgrid/s4u/Semaphore.hpp>
3009 .. doxygentypedef:: SemaphorePtr
3010 .. doxygenfunction:: simgrid::s4u::Semaphore::create(unsigned int initial_capacity)
3012 .. group-tab:: Python
3014 .. code-block:: Python
3016 from simgrid import Semaphore
3017 semaphore = Semaphore(1)
3018 # Automatically acquire the semaphore, and release it after leaving the scope.
3020 # Do something with the shared resource
3023 .. automethod:: simgrid.Semaphore.__init__
3029 #include <simgrid/semaphore.h>
3031 .. doxygentypedef:: sg_sem_t
3032 .. cpp:type:: const s4u_Semaphore* const_sg_sem_t
3034 Pointer to a constant semaphore object.
3036 .. doxygenfunction:: sg_sem_init(int initial_value)
3037 .. doxygenfunction:: sg_sem_destroy(const_sg_sem_t sem)
3046 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire()
3047 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire_timeout(double timeout)
3048 .. doxygenfunction:: simgrid::s4u::Semaphore::get_capacity() const
3049 .. doxygenfunction:: simgrid::s4u::Semaphore::release()
3050 .. doxygenfunction:: simgrid::s4u::Semaphore::would_block() const
3052 .. group-tab:: Python
3054 .. automethod:: simgrid.Semaphore.acquire
3055 .. automethod:: simgrid.Semaphore.acquire_timeout
3056 .. autoattribute:: simgrid.Semaphore.capacity
3057 .. automethod:: simgrid.Semaphore.release
3058 .. autoattribute:: simgrid.Semaphore.would_block
3062 .. doxygenfunction:: sg_sem_acquire(sg_sem_t sem)
3063 .. doxygenfunction:: sg_sem_acquire_timeout(sg_sem_t sem, double timeout)
3064 .. doxygenfunction:: sg_sem_get_capacity(const_sg_sem_t sem)
3065 .. doxygenfunction:: sg_sem_release(sg_sem_t sem)
3066 .. doxygenfunction:: sg_sem_would_block(const_sg_sem_t sem)
3076 .. doxygenclass:: simgrid::Exception
3078 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3080 .. doxygenclass:: simgrid::CancelException
3081 .. doxygenclass:: simgrid::HostFailureException
3082 .. doxygenclass:: simgrid::NetworkFailureException
3083 .. doxygenclass:: simgrid::StorageFailureException
3084 .. doxygenclass:: simgrid::TimeoutException
3085 .. doxygenclass:: simgrid::VmFailureException
3087 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3088 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3089 SimGrid from a python notebook and want to handle the problem accordingly.
3091 .. doxygenclass:: simgrid::AssertionError
3092 .. doxygenclass:: simgrid::ParseError
3093 .. doxygenclass:: simgrid::TracingError
3095 .. group-tab:: Python
3097 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3099 .. autoclass:: simgrid.CancelException
3100 .. autoclass:: simgrid.HostFailureException
3101 .. autoclass:: simgrid.NetworkFailureException
3102 .. autoclass:: simgrid.StorageFailureException
3103 .. autoclass:: simgrid.TimeoutException
3104 .. autoclass:: simgrid.VmFailureException
3106 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3107 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3108 SimGrid from a python notebook and want to handle the problem accordingly.
3110 .. autoclass:: simgrid.AssertionError
3114 .. doxygenenum:: sg_error_t