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.
85 - :ref:`class ActivtySet <API_s4u_ActivitySet>`: Bag of activities, to wait for any of the set, or all of them.
87 - **Synchronization Objects**: Classical IPC that actors can use
89 - :ref:`class Barrier <API_s4u_Barrier>`
90 - :ref:`class ConditionVariable <API_s4u_ConditionVariable>`
91 - :ref:`class Mutex <API_s4u_Mutex>`
92 - :ref:`class Semaphore <API_s4u_Semaphore>`
94 .. |API_s4u_Actors| replace:: **Actors**
95 .. _API_s4u_Actors: #api-s4u-actor
97 .. |API_s4u_Activities| replace:: **Activities**
98 .. _API_s4u_Activities: #api-s4u-activity
100 .. |API_s4u_Tasks| replace:: **Tasks**
101 .. _API_s4u_Tasks: #api-s4u-task
103 .. |API_s4u_Hosts| replace:: **Hosts**
104 .. _API_s4u_Hosts: #api-s4u-host
106 .. |API_s4u_Links| replace:: **Links**
107 .. _API_s4u_Links: #api-s4u-link
109 .. |API_s4u_Disks| replace:: **Disks**
110 .. _API_s4u_Disks: #api-s4u-disk
112 .. |API_s4u_VirtualMachine| replace:: **VirtualMachines**
114 .. |API_s4u_Host| replace:: **Host**
116 .. |API_s4u_Mailbox| replace:: **Mailbox**
118 .. |API_s4u_Mailboxes| replace:: **Mailboxes**
119 .. _API_s4u_Mailboxes: #s4u-mailbox
121 .. |API_s4u_NetZone| replace:: **NetZone**
123 .. |API_s4u_Barrier| replace:: **Barrier**
125 .. |API_s4u_Semaphore| replace:: **Semaphore**
127 .. |API_s4u_ConditionVariable| replace:: **ConditionVariable**
129 .. |API_s4u_Mutex| replace:: **Mutex**
136 Activities represent the actions that consume a resource, such as a
137 :ref:`Comm <API_s4u_Comm>` that consumes the *transmitting power* of
138 :ref:`Link <API_s4u_Link>` resources, or an :ref:`Exec <API_s4u_Exec>`
139 that consumes the *computing power* of :ref:`Host <API_s4u_Host>` resources.
140 See also the :ref:`full API <API_s4u_Activity>` below.
142 =======================
143 Asynchronous Activities
144 =======================
146 Every activity can be either **blocking** or **asynchronous**. For
147 example, :cpp:func:`s4u::Mailbox::put() <simgrid::s4u::Mailbox::put>`
148 and :cpp:func:`s4u::Mailbox::get() <simgrid::s4u::Mailbox::get>`
149 create blocking communications: the actor is blocked until the
150 completion of that communication. Asynchronous communications do not
151 block the actor during their execution but progress on their own.
153 Once your asynchronous activity is started, you can test for its
154 completion using :cpp:func:`s4u::Activity::test() <simgrid::s4u::Activity::test>`.
155 This function returns ``true`` if the activity is completed already.
156 You can also use :cpp:func:`s4u::Activity::wait() <simgrid::s4u::Activity::wait>`
157 to block until the completion of the activity. To wait for at most a given amount of time,
158 use :cpp:func:`s4u::Activity::wait_for() <simgrid::s4u::Activity::wait_for>`.
159 Finally, to wait at most until a specified time limit, use
160 :cpp:func:`s4u::Activity::wait_until() <simgrid::s4u::Activity::wait_until>`.
162 Every kind of activity can be asynchronous.
163 :ref:`s4u::CommPtr <API_s4u_Comm>` are created with :cpp:func:`s4u::Mailbox::put_async() <simgrid::s4u::Mailbox::put_async>` and
164 :cpp:func:`s4u::Mailbox::get_async() <simgrid::s4u::Mailbox::get_async>`;
165 :ref:`s4u::IoPtr <API_s4u_Io>` are created with :cpp:func:`s4u::Disk::read_async() <simgrid::s4u::Disk::read_async>` and
166 :cpp:func:`s4u::Disk::write_async() <simgrid::s4u::Disk::write_async>`; and
167 :ref:`s4u::ExecPtr <API_s4u_Exec>` are created with
168 :cpp:func:`s4u::Host::exec_async() <simgrid::s4u::Host::exec_async>`.
169 In the future, it will become possible to have asynchronous IPC such as asynchronous mutex lock requests (it is already possible
170 internally, but the interface is not exposed in S4U yet).
172 If you want for the completion of any activity in a given set, to react to the earlier occuring completion, then you need an
173 :ref:`activity set <API_s4u_ActivitySet>`. Please refer to the :ref:`relevant examples <s4u_ex_activityset>` for more information.
175 =====================
176 Activities Life Cycle
177 =====================
179 Sometimes, you want to change the setting of an activity before it even starts.
181 .. todo:: write this section
183 =====================
184 Repeatable Activities
185 =====================
187 In order to simulate the execution of Dataflow applications, we introduced the
188 concept of |API_s4u_Tasks|, that can be seen as repeatable activities. A Dataflow
189 is defined as a graph of |API_s4u_Tasks|, where each |API_s4u_Tasks| has a set of
190 successors and predecessors. When a |API_s4u_Tasks| ends it sends a token to each
191 of its successors. Each |API_s4u_Tasks| has to receive a token from each of its
192 predecessor to start. Tokens can carry any user-defined data.
194 |API_s4u_Tasks| are composed of several instances: a dispatcher, a collector, and
195 instance_0 to instance_n. The dispatcher rely on a load balancing function to select
196 the next instance to fire. Once this instance finishes it fires the collector.
198 Each instance of an |API_s4u_ExecTask| can be placed on a different host.
199 |API_s4u_Comm| activities are automatically created when an instance triggers
200 another instance on a different host. Each instance has its own parallelism degree
201 to scale horizontally on several cores.
203 To initiate the execution of a Dataflow, it is possible to some make
204 |API_s4u_Tasks| fire one or more activities without waiting for any token with the
205 :cpp:func:`s4u::Task::enqueue_firings() <simgrid::s4u::Task::enqueue_firings>`
208 The parameters of Tasks can be redefined at runtime by attaching
210 :cpp:func:`s4u::Task::on_this_start <simgrid::s4u::Task::on_this_start>`
212 :cpp:func:`s4u::Task::on_this_completion <simgrid::s4u::Task::on_this_completion>`
213 signals. The former is triggered by instances others than the dispatcher and the collector,
214 and the latter is triggered by the collector.
223 Please also refer to the :ref:`API reference for s4u::Mailbox
230 |API_s4u_Mailboxes|_ are rendezvous points for network communications,
231 similar to URLs on which you could post and retrieve data. Actually,
232 the mailboxes are not involved in the communication once it starts,
233 but only to find the contact with which you want to communicate.
235 They are similar to many common things: The phone number, which allows
236 the caller to find the receiver. The Twitter hashtag, which helps
237 senders and receivers to find each other. In TCP, the pair
238 ``{host name, host port}`` to which you can connect to find your peer.
239 In HTTP, URLs through which the clients can connect to the servers.
240 In ZeroMQ, the queues are used to match senders and receivers.
242 One big difference with most of these systems is that no actor is the
243 exclusive owner of a mailbox, neither in sending nor in receiving.
244 Many actors can send into and/or receive from the same mailbox. TCP
245 socket ports for example are shared on the sender side but exclusive
246 on the receiver side (only one process can receive from a given socket
247 at a given point of time).
249 A big difference with TCP sockets or MPI communications is that
250 communications do not start right away after a
251 :cpp:func:`Mailbox::put() <simgrid::s4u::Mailbox::put>`, but wait
252 for the corresponding :cpp:func:`Mailbox::get() <simgrid::s4u::Mailbox::get>`.
253 You can change this by :ref:`declaring a receiving actor <s4u_receiving_actor>`.
255 A big difference with Twitter hashtags is that SimGrid does not
256 offer easy support to broadcast a given message to many
257 receivers. So that would be like a Twitter tag where each message
258 is consumed by the first receiver.
260 A big difference with the ZeroMQ queues is that you cannot filter
261 on the data you want to get from the mailbox. To model such settings
262 in SimGrid, you'd have one mailbox per potential topic, and subscribe
263 to each topic individually with a
264 :cpp:func:`get_async() <simgrid::s4u::Mailbox::get_async>` on each mailbox.
265 Then, use an :ref:`class ActivtySet <API_s4u_ActivitySet>` to get the first
266 message on any of the mailboxes you are subscribed to.
268 The mailboxes are not located on the network, and you can access
269 them without any latency. The network delays are only related to the
270 location of the sender and receiver once the match between them is
271 done on the mailbox. This is just like the phone number that you
272 can use locally, and the geographical distance only comes into play
273 once you start the communication by dialing this number.
275 =====================
276 How to use Mailboxes?
277 =====================
279 You can retrieve any existing mailbox from its name (which is a
280 unique string, just like a Twitter tag). This results in a
281 versatile tool that can be used to build many different
284 To model classical socket communications, use "hostname:port" as
285 mailbox names, and make sure that only one actor reads into a given
286 mailbox. This does not make it easy to build a perfectly realistic
287 model of the TCP sockets, but in most cases, this system is too
288 cumbersome for your simulations anyway. You probably want something
289 simpler, that turns out to be easy to build with the mailboxes.
291 Many SimGrid examples use a sort of yellow page system where the
292 mailbox names are the name of the service (such as "worker",
293 "master", or "reducer"). That way, you don't have to know where your
294 peer is located to contact it. You don't even need its name. Its
295 function is enough for that. This also gives you some sort of load
296 balancing for free if more than one actor pulls from the mailbox:
297 the first actor that can deal with the request will handle it.
299 =========================================
300 How are put() and get() requests matched?
301 =========================================
303 The matching algorithm simple: first come, first serve. When a new
304 send arrives, it matches the oldest enqueued receive. If no receive is
305 currently enqueued, then the incoming send is enqueued. As you can
306 see, the mailbox cannot contain both send and receive requests: all
307 enqueued requests must be of the same sort.
309 .. _s4u_receiving_actor:
311 ===========================
312 Declaring a Receiving Actor
313 ===========================
315 The last twist is that by default in the simulator, the data starts
316 to be exchanged only when both the sender and the receiver are
317 announced (it waits until both :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
318 and :cpp:func:`get() <simgrid::s4u::Mailbox::get()>` are posted).
319 In TCP, since you establish connections beforehand, the data starts to
320 flow as soon as the sender posts it, even if the receiver did not post
321 its :cpp:func:`put() <simgrid::s4u::Mailbox::put()>` yet.
323 To model this in SimGrid, you can declare a specific receiver to a
324 given mailbox (with the function
325 :cpp:func:`set_receiver() <simgrid::s4u::Mailbox::set_receiver()>`).
326 That way, any :cpp:func:`put() <simgrid::s4u::Mailbox::put()>`
327 posted to that mailbox will start as soon as possible, and the data
328 will already be there on the receiver host when the receiver actor
329 posts its :cpp:func:`get() <simgrid::s4u::Mailbox::get()>`
331 Note that being permanent receivers of a mailbox prevents actors to be
332 garbage-collected. If your simulation creates many short-lived actors
333 that are marked as permanent receiver, you should call
334 ``mailbox->set_receiver(nullptr)`` by the end of the actors so that their
335 memory gets properly reclaimed. This call should be at the end of the
336 actor's function, not in an on_exit callback.
338 ===============================
339 Communicating without Mailboxes
340 ===============================
342 Sometimes you don't want to simulate communications between actors as
343 allowed by mailboxes, but you want to create a direct communication
344 between two arbitrary hosts. This can arise when you write a
345 high-level model of a centralized scheduler, or when you model direct
346 communications such as one-sided communications in MPI or remote
347 memory direct access in PGAS.
349 For that, :cpp:func:`Comm::sendto() <simgrid::s4u::Comm::sendto()>`
350 simulates a direct communication between the two specified hosts. No
351 mailbox is used, and there is no rendezvous between actors. You can
352 freely mix such direct communications and rendezvous-based
353 communications. Alternatively, :cpp:func:`Comm::sendto_init()
354 <simgrid::s4u::Comm::sendto_init()>` and
355 :cpp:func:`Comm::sendto_async() <simgrid::s4u::Comm::sendto_async()>`
356 create asynchronous direct communications.
363 For sake of simplicity, we use `RAII
364 <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`_
365 for many classes in S4U. This is an idiom where resources are automatically
366 managed through the context. Provided that you never manipulate
367 objects of type Foo directly but always FooPtr references (which are
368 defined as `boost::intrusive_ptr
369 <http://www.boost.org/doc/libs/1_61_0/libs/smart_ptr/intrusive_ptr.html>`_
370 <Foo>), you will never have to explicitly release the resource that
371 you use nor to free the memory of unused objects.
372 Here is a little example:
378 simgrid::s4u::MutexPtr mutex = simgrid::s4u::Mutex::create(); // Too bad we cannot use `new`
380 mutex->lock(); // use the mutex as a simple reference
384 } // The mutex gets automatically freed because the only existing reference gets out of scope
386 Note that Mailboxes, Hosts, and Links are not handled through smart
387 pointers (yet?). This means that it is currently impossible to destroy a
388 mailbox or a link. You can still destroy a host (but probably
389 shouldn't), using :cpp:func:`simgrid::s4u::Host::destroy`.
394 .. _API_s4u_simulation_object:
410 .. doxygenclass:: simgrid::s4u::Actor
412 .. doxygentypedef:: aid_t
415 .. group-tab:: Python
417 .. autoclass:: simgrid.Actor
428 #include <simgrid/s4u/Actor.hpp>
430 .. doxygentypedef:: ActorPtr
432 .. group-tab:: Python
436 from simgrid import Actor
442 #include <simgrid/actor.h>
444 .. doxygentypedef:: sg_actor_t
445 .. doxygentypedef:: const_sg_actor_t
446 .. doxygenfunction:: sg_actor_ref
447 .. doxygenfunction:: sg_actor_unref
453 See also :ref:`the relevant example <s4u_ex_actors_create>`.
459 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::function< void()> &code)
460 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code)
461 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, F code, Args... args)
462 .. doxygenfunction:: simgrid::s4u::Actor::create(const std::string &name, s4u::Host *host, const std::string &function, std::vector< std::string > args)
464 .. doxygenfunction:: simgrid::s4u::Actor::init(const std::string &name, s4u::Host *host)
465 .. doxygenfunction:: simgrid::s4u::Actor::start(const std::function< void()> &code)
466 .. doxygenfunction:: simgrid::s4u::Actor::set_stacksize
468 .. group-tab:: Python
470 .. automethod:: simgrid.Actor.create
474 .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, char *const *argv)
475 .. doxygenfunction:: sg_actor_init(const char *name, sg_host_t host)
476 .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char *const *argv)
477 .. doxygenfunction:: sg_actor_set_stacksize
479 .. doxygenfunction:: sg_actor_attach(const char *name, void *data, sg_host_t host, xbt_dict_t properties)
480 .. doxygenfunction:: sg_actor_detach()
489 .. doxygenfunction:: simgrid::s4u::Actor::by_pid(aid_t pid)
490 .. doxygenfunction:: simgrid::s4u::Actor::self()
492 .. group-tab:: Python
494 .. automethod:: simgrid.Actor.by_pid
495 .. automethod:: simgrid.Actor.self
499 .. doxygenfunction:: sg_actor_by_pid(aid_t pid)
500 .. doxygenfunction:: sg_actor_self()
501 .. doxygenfunction:: sg_actor_list()
510 .. doxygenfunction:: simgrid::s4u::Actor::get_cname
511 .. doxygenfunction:: simgrid::s4u::Actor::get_name
512 .. doxygenfunction:: simgrid::s4u::Actor::get_pid
513 .. doxygenfunction:: simgrid::s4u::Actor::get_ppid
514 .. doxygenfunction:: simgrid::s4u::Actor::get_properties() const
515 .. doxygenfunction:: simgrid::s4u::Actor::get_property(const std::string &key) const
516 .. doxygenfunction:: simgrid::s4u::Actor::set_property(const std::string &key, const std::string &value)
518 .. doxygenfunction:: simgrid::s4u::Actor::get_host
519 .. doxygenfunction:: simgrid::s4u::Actor::set_host
521 .. doxygenfunction:: simgrid::s4u::Actor::get_refcount
522 .. doxygenfunction:: simgrid::s4u::Actor::get_impl
524 .. group-tab:: Python
526 .. autoattribute:: simgrid.Actor.name
527 .. autoattribute:: simgrid.Actor.host
528 .. autoattribute:: simgrid.Actor.pid
529 .. autoattribute:: simgrid.Actor.ppid
533 .. doxygenfunction:: sg_actor_get_name(const_sg_actor_t actor)
534 .. doxygenfunction:: sg_actor_get_pid(const_sg_actor_t actor)
535 .. doxygenfunction:: sg_actor_get_ppid(const_sg_actor_t actor)
536 .. doxygenfunction:: sg_actor_get_properties(const_sg_actor_t actor)
537 .. doxygenfunction:: sg_actor_get_property_value(const_sg_actor_t actor, const char *name)
539 .. doxygenfunction:: sg_actor_get_host(const_sg_actor_t actor)
540 .. doxygenfunction:: sg_actor_set_host(sg_actor_t actor, sg_host_t host)
542 .. doxygenfunction:: sg_actor_get_data(const_sg_actor_t actor)
543 .. doxygenfunction:: sg_actor_set_data(sg_actor_t actor, void *userdata)
545 Suspending and resuming actors
546 ------------------------------
552 .. doxygenfunction:: simgrid::s4u::Actor::suspend()
553 .. doxygenfunction:: simgrid::s4u::Actor::resume()
554 .. doxygenfunction:: simgrid::s4u::Actor::is_suspended
556 .. group-tab:: Python
558 .. automethod:: simgrid.Actor.resume
559 .. automethod:: simgrid.Actor.suspend
560 .. automethod:: simgrid.Actor.is_suspended
564 .. doxygenfunction:: sg_actor_suspend(sg_actor_t actor)
565 .. doxygenfunction:: sg_actor_resume(sg_actor_t actor)
566 .. doxygenfunction:: sg_actor_is_suspended(const_sg_actor_t actor)
568 Specifying when actors should terminate
569 ---------------------------------------
575 .. doxygenfunction:: simgrid::s4u::Actor::kill()
576 .. doxygenfunction:: simgrid::s4u::Actor::kill_all()
577 .. doxygenfunction:: simgrid::s4u::Actor::set_kill_time(double time)
578 .. doxygenfunction:: simgrid::s4u::Actor::get_kill_time
580 .. doxygenfunction:: simgrid::s4u::Actor::restart()
581 .. doxygenfunction:: simgrid::s4u::Actor::daemonize()
582 .. doxygenfunction:: simgrid::s4u::Actor::is_daemon
584 .. group-tab:: Python
586 .. automethod:: simgrid.Actor.kill
587 .. automethod:: simgrid.Actor.kill_all
589 .. automethod:: simgrid.Actor.daemonize
590 .. automethod:: simgrid.Actor.is_daemon
594 .. doxygenfunction:: sg_actor_kill(sg_actor_t actor)
595 .. doxygenfunction:: sg_actor_kill_all()
596 .. doxygenfunction:: sg_actor_set_kill_time(sg_actor_t actor, double kill_time)
598 .. doxygenfunction:: sg_actor_restart(sg_actor_t actor)
599 .. doxygenfunction:: sg_actor_daemonize(sg_actor_t actor)
600 .. doxygenfunction:: sg_actor_is_daemon
602 .. _API_s4u_Actor_end:
604 Reacting to the end of actors
605 -----------------------------
611 .. doxygenfunction:: simgrid::s4u::Actor::on_exit
612 .. doxygenfunction:: simgrid::s4u::Actor::join() const
613 .. doxygenfunction:: simgrid::s4u::Actor::join(double timeout) const
614 .. doxygenfunction:: simgrid::s4u::Actor::set_auto_restart(bool autorestart)
615 .. doxygenfunction:: simgrid::s4u::Actor::get_restart_count
617 .. group-tab:: Python
619 .. automethod:: simgrid.Actor.join
623 .. doxygenfunction:: sg_actor_on_exit
624 .. doxygenfunction:: sg_actor_join(const_sg_actor_t actor, double timeout)
625 .. doxygenfunction:: sg_actor_set_auto_restart(sg_actor_t actor, int auto_restart)
634 .. doxygenfunction:: simgrid::s4u::Actor::on_creation_cb
635 .. doxygenfunction:: simgrid::s4u::Actor::on_suspend_cb
636 .. doxygenfunction:: simgrid::s4u::Actor::on_this_suspend_cb
637 .. doxygenfunction:: simgrid::s4u::Actor::on_host_change_cb
638 .. doxygenfunction:: simgrid::s4u::Actor::on_this_host_change_cb
639 .. doxygenfunction:: simgrid::s4u::Actor::on_resume_cb
640 .. doxygenfunction:: simgrid::s4u::Actor::on_this_resume_cb
641 .. doxygenfunction:: simgrid::s4u::Actor::on_sleep_cb
642 .. doxygenfunction:: simgrid::s4u::Actor::on_this_sleep_cb
643 .. doxygenfunction:: simgrid::s4u::Actor::on_wake_up_cb
644 .. doxygenfunction:: simgrid::s4u::Actor::on_this_wake_up_cb
645 .. doxygenfunction:: simgrid::s4u::Actor::on_termination_cb
646 .. doxygenfunction:: simgrid::s4u::Actor::on_this_termination_cb
647 .. doxygenfunction:: simgrid::s4u::Actor::on_destruction_cb
648 .. doxygenfunction:: simgrid::s4u::Actor::on_this_destruction_cb
650 .. _API_s4u_this_actor:
656 These functions can be used in your user code to interact with the actor
657 currently running (the one retrieved with :cpp:func:`simgrid::s4u::Actor::self`).
658 Using these functions can greatly improve the code readability.
667 .. doxygenfunction:: simgrid::s4u::this_actor::get_cname()
668 .. doxygenfunction:: simgrid::s4u::this_actor::get_name()
669 .. doxygenfunction:: simgrid::s4u::this_actor::get_pid()
670 .. doxygenfunction:: simgrid::s4u::this_actor::get_ppid()
671 .. doxygenfunction:: simgrid::s4u::this_actor::is_maestro()
673 .. doxygenfunction:: simgrid::s4u::this_actor::get_host()
674 .. doxygenfunction:: simgrid::s4u::this_actor::set_host(Host *new_host)
676 .. group-tab:: Python
678 .. autofunction:: simgrid.this_actor.get_host
679 .. autofunction:: simgrid.this_actor.set_host
681 .. autofunction:: simgrid.this_actor.get_pid
682 .. autofunction:: simgrid.this_actor.get_ppid
686 .. doxygenfunction:: sg_actor_self_get_data()
687 .. doxygenfunction:: sg_actor_self_set_data(void *data)
688 .. doxygenfunction:: sg_actor_self_get_name()
689 .. doxygenfunction:: sg_actor_self_get_pid()
690 .. doxygenfunction:: sg_actor_self_get_ppid()
691 .. doxygenfunction:: sg_host_self()
692 .. doxygenfunction:: sg_host_self_get_name()
694 Suspending and resuming
695 -----------------------
701 .. doxygenfunction:: simgrid::s4u::this_actor::suspend()
702 .. doxygenfunction:: simgrid::s4u::this_actor::yield()
704 .. group-tab:: Python
706 .. autofunction:: simgrid.this_actor.suspend
707 .. autofunction:: simgrid.this_actor.yield_
711 .. doxygenfunction:: sg_actor_yield()
720 Please refer to :ref:`the relevant documentation <logging_prog>`.
722 .. group-tab:: Python
724 .. autofunction:: simgrid.this_actor.debug
725 .. autofunction:: simgrid.this_actor.info
726 .. autofunction:: simgrid.this_actor.warning
727 .. autofunction:: simgrid.this_actor.error
736 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(double duration)
737 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(std::chrono::duration< Rep, Period > duration)
738 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(const SimulationTimePoint< Duration > &wakeup_time)
739 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(double wakeup_time)
741 .. group-tab:: Python
743 .. autofunction:: simgrid.this_actor.sleep_for
744 .. autofunction:: simgrid.this_actor.sleep_until
748 .. doxygenfunction:: sg_actor_sleep_for(double duration)
750 Simulating executions
751 ---------------------
753 Simulate the execution of some code on this actor. You can either simulate
754 parallel or sequential code and you can either block upon the termination of
755 the execution, or start an asynchronous activity.
761 .. doxygenfunction:: simgrid::s4u::this_actor::exec_async
762 .. 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)
763 .. doxygenfunction:: simgrid::s4u::this_actor::exec_init(double flops_amounts)
764 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop)
765 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop, double priority)
766 .. 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)
767 .. doxygenfunction:: simgrid::s4u::this_actor::thread_execute
769 .. group-tab:: Python
771 .. autofunction:: simgrid.this_actor.exec_async
772 .. autofunction:: simgrid.this_actor.exec_init
773 .. autofunction:: simgrid.this_actor.execute
777 .. doxygenfunction:: sg_actor_execute(double flops)
778 .. doxygenfunction:: sg_actor_execute_with_priority(double flops, double priority)
779 .. doxygenfunction:: sg_actor_exec_init(double computation_amount)
780 .. doxygenfunction:: sg_actor_exec_async(double computation_amount)
781 .. doxygenfunction:: sg_actor_parallel_exec_init(int host_nb, const sg_host_t* host_list, double* flops_amount, double* bytes_amount);
790 .. doxygenfunction:: simgrid::s4u::this_actor::exit()
791 .. doxygenfunction:: simgrid::s4u::this_actor::on_exit(const std::function< void(bool)> &fun)
793 .. group-tab:: Python
795 .. autofunction:: simgrid.this_actor.exit
796 .. autofunction:: simgrid.this_actor.on_exit
800 See also :cpp:func:`sg_actor_on_exit`.
802 .. doxygenfunction:: sg_actor_exit
814 .. doxygenclass:: simgrid::s4u::Engine
816 .. group-tab:: Python
818 .. autoclass:: simgrid.Engine
827 .. doxygenfunction:: simgrid::s4u::Engine::Engine(int *argc, char **argv)
828 .. doxygenfunction:: simgrid::s4u::Engine::is_initialized()
829 .. doxygenfunction:: simgrid::s4u::Engine::shutdown()
830 .. doxygenfunction:: simgrid::s4u::Engine::get_instance()
832 .. group-tab:: Python
834 .. automethod:: simgrid.Engine.__init__
835 .. autoattribute:: simgrid.Engine.instance
839 .. doxygenfunction:: simgrid_init
848 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &str)
849 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, bool value)
850 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, double value)
851 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, int value)
852 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, const std::string &value)
854 .. doxygenfunction:: simgrid::s4u::Engine::load_deployment
855 .. doxygenfunction:: simgrid::s4u::Engine::load_platform
856 .. doxygenfunction:: simgrid::s4u::Engine::flatify_platform
857 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name)
858 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name, F code)
859 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const std::function< void(int, char **)> &code)
860 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const kernel::actor::ActorCodeFactory &factory)
862 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(int, char **)> &code)
863 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(std::vector< std::string >)> &code)
864 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const kernel::actor::ActorCodeFactory &factory)
866 .. group-tab:: Python
868 .. automethod:: simgrid.Engine.load_deployment
869 .. automethod:: simgrid.Engine.load_platform
870 .. automethod:: simgrid.Engine.register_actor
874 .. doxygenfunction:: simgrid_load_deployment
875 .. doxygenfunction:: simgrid_load_platform
876 .. doxygenfunction:: simgrid_register_default
877 .. doxygenfunction:: simgrid_register_function
887 .. doxygenfunction:: simgrid::s4u::Engine::get_clock()
888 .. doxygenfunction:: simgrid::s4u::Engine::run
889 .. doxygenfunction:: simgrid::s4u::Engine::run_until
891 .. group-tab:: Python
893 .. autoattribute:: simgrid.Engine.clock
894 .. automethod:: simgrid.Engine.run
895 .. automethod:: simgrid.Engine.run_until
899 .. doxygenfunction:: simgrid_get_clock
900 .. doxygenfunction:: simgrid_run
901 .. doxygenfunction:: simgrid_run_until
910 .. doxygenfunction:: simgrid::s4u::Engine::get_actor_count
911 .. doxygenfunction:: simgrid::s4u::Engine::get_all_actors
912 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_actors
916 .. doxygenfunction:: sg_actor_count()
925 .. doxygenfunction:: simgrid::s4u::Engine::get_all_hosts
926 .. doxygenfunction:: simgrid::s4u::Engine::get_host_count
927 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_hosts
928 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name
929 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name_or_null
931 .. group-tab:: Python
933 .. autoattribute:: simgrid.Engine.all_hosts
934 .. automethod:: simgrid.Engine.host_by_name
938 See also :cpp:func:`sg_host_list` and :cpp:func:`sg_host_count`.
947 .. doxygenfunction:: simgrid::s4u::Engine::get_all_links
948 .. doxygenfunction:: simgrid::s4u::Engine::get_link_count
949 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_links
950 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name
951 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name_or_null
953 .. group-tab:: Python
955 .. autoattribute:: simgrid.Engine.all_links
957 Interacting with the routing
958 ----------------------------
964 .. doxygenfunction:: simgrid::s4u::Engine::get_all_netpoints
965 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_netzones
966 .. doxygenfunction:: simgrid::s4u::Engine::get_netzone_root
967 .. doxygenfunction:: simgrid::s4u::Engine::netpoint_by_name_or_null
968 .. doxygenfunction:: simgrid::s4u::Engine::netzone_by_name_or_null
970 .. group-tab:: Python
972 .. autoattribute:: simgrid.Engine.all_netpoints
973 .. autoattribute:: simgrid.Engine.netzone_root
974 .. automethod:: simgrid.Engine.netpoint_by_name
975 .. automethod:: simgrid.Engine.netzone_by_name
984 .. doxygenfunction:: simgrid::s4u::Engine::on_deadlock_cb
985 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_created_cb
986 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_creation_cb
987 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_start_cb
988 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_end_cb
989 .. doxygenfunction:: simgrid::s4u::Engine::on_time_advance_cb
1001 .. doxygenclass:: simgrid::s4u::Mailbox
1003 .. group-tab:: Python
1005 .. autoclass:: simgrid.Mailbox
1007 Please also refer to the :ref:`full doc on s4u::Mailbox <s4u_mailbox>`.
1018 #include <simgrid/s4u/Mailbox.hpp>
1020 Note that there is no MailboxPtr type and that you cannot use the RAII
1021 idiom on mailboxes because they are internal objects to the simulation
1022 engine. Once created, there is no way to destroy a mailbox before the end
1025 .. doxygenfunction:: simgrid::s4u::Mailbox::by_name(const std::string &name)
1027 .. group-tab:: Python
1031 #include <simgrid/mailbox.h>
1033 .. automethod:: simgrid.Mailbox.by_name
1039 #include <simgrid/s4u/mailbox.h>
1041 .. doxygentypedef:: sg_mailbox_t
1042 .. doxygentypedef:: const_sg_mailbox_t
1044 .. doxygenfunction:: sg_mailbox_by_name(const char *alias)
1053 .. doxygenfunction:: simgrid::s4u::Mailbox::get_cname
1054 .. doxygenfunction:: simgrid::s4u::Mailbox::get_name
1056 .. group-tab:: Python
1058 .. autoattribute:: simgrid.Mailbox.name
1067 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes)
1068 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes, double timeout)
1069 .. doxygenfunction:: simgrid::s4u::Mailbox::put_async(void *data, uint64_t simulated_size_in_bytes)
1070 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init()
1071 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init(void *data, uint64_t simulated_size_in_bytes)
1073 .. group-tab:: Python
1075 .. automethod:: simgrid.Mailbox.put
1076 .. automethod:: simgrid.Mailbox.put_async
1077 .. automethod:: simgrid.Mailbox.put_init
1081 .. doxygenfunction:: sg_mailbox_put(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1082 .. doxygenfunction:: sg_mailbox_put_init(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1083 .. doxygenfunction:: sg_mailbox_put_async(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1093 .. doxygenfunction:: simgrid::s4u::Mailbox::empty
1094 .. doxygenfunction:: simgrid::s4u::Mailbox::front
1095 .. doxygenfunction:: simgrid::s4u::Mailbox::get()
1096 .. doxygenfunction:: simgrid::s4u::Mailbox::get(double timeout)
1097 .. doxygenfunction:: simgrid::s4u::Mailbox::get_async(T **data)
1098 .. doxygenfunction:: simgrid::s4u::Mailbox::get_init()
1099 .. doxygenfunction:: simgrid::s4u::Mailbox::iprobe(int type, const std::function<bool(void *, void *, kernel::activity::CommImpl *)>& match_fun, void *data)
1100 .. doxygenfunction:: simgrid::s4u::Mailbox::listen
1101 .. doxygenfunction:: simgrid::s4u::Mailbox::ready
1103 .. group-tab:: Python
1105 .. automethod:: simgrid.Mailbox.get
1106 .. automethod:: simgrid.Mailbox.get_async
1107 .. autoattribute:: simgrid.Mailbox.ready
1111 .. doxygenfunction:: sg_mailbox_get(sg_mailbox_t mailbox)
1112 .. doxygenfunction:: sg_mailbox_get_async(sg_mailbox_t mailbox, void **data)
1113 .. doxygenfunction:: sg_mailbox_get_name(const_sg_mailbox_t mailbox)
1114 .. doxygenfunction:: sg_mailbox_listen(const char *alias)
1119 See :ref:`s4u_receiving_actor`.
1125 .. doxygenfunction:: simgrid::s4u::Mailbox::get_receiver
1126 .. doxygenfunction:: simgrid::s4u::Mailbox::set_receiver(ActorPtr actor)
1130 .. doxygenfunction:: sg_mailbox_set_receiver(const char *alias)
1132 .. _API_s4u_Resource:
1148 .. doxygenclass:: simgrid::s4u::Disk
1150 .. group-tab:: Python
1152 .. autoclass:: simgrid.Disk
1156 .. doxygentypedef:: sg_disk_t
1157 .. doxygentypedef:: const_sg_disk_t
1168 #include <simgrid/s4u/Disk.hpp>
1170 Note that there is no DiskPtr type and that you cannot use the RAII
1171 idiom on disks because SimGrid does not allow (yet) to create nor
1172 destroy resources once the simulation is started.
1174 .. doxygenfunction:: simgrid::s4u::Disk::seal()
1176 .. group-tab:: Python
1180 from simgrid import Disk
1182 .. automethod:: simgrid.Disk.seal
1192 .. doxygenfunction:: simgrid::s4u::Disk::get_cname() const
1193 .. doxygenfunction:: simgrid::s4u::Disk::get_host() const
1194 .. doxygenfunction:: simgrid::s4u::Disk::get_name() const
1195 .. doxygenfunction:: simgrid::s4u::Disk::get_properties() const
1196 .. doxygenfunction:: simgrid::s4u::Disk::get_property(const std::string &key) const
1197 .. doxygenfunction:: simgrid::s4u::Disk::get_read_bandwidth() const
1198 .. doxygenfunction:: simgrid::s4u::Disk::get_write_bandwidth() const
1199 .. doxygenfunction:: simgrid::s4u::Disk::set_property(const std::string &, const std::string &value)
1200 .. doxygenfunction:: simgrid::s4u::Disk::set_sharing_policy
1202 .. group-tab:: Python
1204 .. autoattribute:: simgrid.Disk.name
1205 .. automethod:: simgrid.Disk.set_sharing_policy
1214 .. doxygenfunction:: simgrid::s4u::Disk::io_init(sg_size_t size, s4u::Io::OpType type) const
1215 .. doxygenfunction:: simgrid::s4u::Disk::read(sg_size_t size) const
1216 .. doxygenfunction:: simgrid::s4u::Disk::read_async(sg_size_t size) const
1217 .. doxygenfunction:: simgrid::s4u::Disk::write(sg_size_t size) const
1218 .. doxygenfunction:: simgrid::s4u::Disk::write_async(sg_size_t size) const
1220 .. group-tab:: Python
1222 .. automethod:: simgrid.Disk.read
1223 .. automethod:: simgrid.Disk.read_async
1224 .. automethod:: simgrid.Disk.write
1225 .. automethod:: simgrid.Disk.write_async
1234 .. doxygenfunction:: simgrid::s4u::Disk::on_creation_cb
1235 .. doxygenfunction:: simgrid::s4u::Disk::on_destruction_cb
1236 .. doxygenfunction:: simgrid::s4u::Disk::on_this_destruction_cb
1237 .. doxygenfunction:: simgrid::s4u::Disk::on_onoff_cb
1238 .. doxygenfunction:: simgrid::s4u::Disk::on_this_onoff_cb
1251 .. doxygenclass:: simgrid::s4u::Host
1253 .. group-tab:: Python
1255 .. autoclass:: simgrid.Host
1266 #include <simgrid/s4u/Host.hpp>
1268 Note that there is no HostPtr type, and that you cannot use the RAII
1269 idiom on hosts because SimGrid does not allow (yet) to create nor
1270 destroy resources once the simulation is started.
1272 .. doxygenfunction:: simgrid::s4u::Host::destroy()
1273 .. doxygenfunction:: simgrid::s4u::Host::seal()
1275 .. group-tab:: Python
1279 from simgrid import Host
1281 .. automethod:: simgrid.Host.seal
1287 #include <simgrid/host.h>
1289 .. doxygentypedef:: sg_host_t
1290 .. cpp:type:: const s4u_Host* const_sg_host_t
1292 Pointer to a constant host object.
1301 See also :cpp:func:`simgrid::s4u::Engine::get_all_hosts`.
1303 .. doxygenfunction:: simgrid::s4u::Host::by_name(const std::string &name)
1304 .. doxygenfunction:: simgrid::s4u::Host::by_name_or_null(const std::string &name)
1305 .. doxygenfunction:: simgrid::s4u::Host::current()
1307 .. group-tab:: Python
1309 See also :py:attr:`simgrid.Engine.all_hosts`.
1311 .. automethod:: simgrid.Host.by_name
1312 .. automethod:: simgrid.Host.current
1316 .. doxygenfunction:: sg_host_by_name(const char *name)
1317 .. doxygenfunction:: sg_host_count()
1318 .. doxygenfunction:: sg_host_list()
1320 Modifying characteristics
1321 -------------------------
1327 .. doxygenfunction:: simgrid::s4u::Host::set_core_count(int core_count)
1328 .. doxygenfunction:: simgrid::s4u::Host::set_coordinates(const std::string& coords)
1329 .. doxygenfunction:: simgrid::s4u::Host::set_sharing_policy
1331 .. group-tab:: Python
1333 .. autoattribute:: simgrid.Host.core_count
1335 .. automethod:: simgrid.Host.set_coordinates
1336 .. automethod:: simgrid.Host.set_sharing_policy
1345 .. doxygenfunction:: simgrid::s4u::Host::get_cname() const
1346 .. doxygenfunction:: simgrid::s4u::Host::get_core_count() const
1347 .. doxygenfunction:: simgrid::s4u::Host::get_name() const
1348 .. doxygenfunction:: simgrid::s4u::Host::get_available_speed() const
1349 .. doxygenfunction:: simgrid::s4u::Host::get_load() const
1350 .. doxygenfunction:: simgrid::s4u::Host::get_speed() const
1352 .. group-tab:: Python
1354 .. autoattribute:: simgrid.Host.name
1355 .. autoattribute:: simgrid.Host.core_count
1356 .. autoattribute:: simgrid.Host.load
1357 .. autoattribute:: simgrid.Host.speed
1358 .. autoattribute:: simgrid.Host.available_speed
1362 .. doxygenfunction:: sg_host_core_count(const_sg_host_t host)
1363 .. doxygenfunction:: sg_host_get_name(const_sg_host_t host)
1364 .. doxygenfunction:: sg_host_get_load(const_sg_host_t host)
1365 .. doxygenfunction:: sg_host_get_speed(const_sg_host_t host)
1367 User data and properties
1368 ------------------------
1374 .. doxygenfunction:: simgrid::s4u::Host::get_properties() const
1375 .. doxygenfunction:: simgrid::s4u::Host::get_property(const std::string &key) const
1376 .. doxygenfunction:: simgrid::s4u::Host::set_properties(const std::unordered_map< std::string, std::string > &properties)
1377 .. doxygenfunction:: simgrid::s4u::Host::set_property(const std::string &key, const std::string &value)
1381 .. doxygenfunction:: sg_host_set_property_value(sg_host_t host, const char *name, const char *value)
1382 .. doxygenfunction:: sg_host_get_properties(const_sg_host_t host)
1383 .. doxygenfunction:: sg_host_get_property_value(const_sg_host_t host, const char *name)
1384 .. doxygenfunction:: sg_host_extension_create(void(*deleter)(void *))
1385 .. doxygenfunction:: sg_host_extension_get(const_sg_host_t host, size_t rank)
1387 Retrieving components
1388 ---------------------
1394 .. doxygenfunction:: simgrid::s4u::Host::add_disk(const Disk *disk)
1395 .. doxygenfunction:: simgrid::s4u::Host::get_actor_count() const
1396 .. doxygenfunction:: simgrid::s4u::Host::get_all_actors() const
1397 .. doxygenfunction:: simgrid::s4u::Host::get_disks() const
1398 .. doxygenfunction:: simgrid::s4u::Host::remove_disk(const std::string &disk_name)
1400 .. group-tab:: Python
1402 .. automethod:: simgrid.Host.get_disks
1406 .. doxygenfunction:: sg_host_get_actor_list(const_sg_host_t host, xbt_dynar_t whereto)
1415 .. doxygenfunction:: simgrid::s4u::Host::is_on() const
1416 .. doxygenfunction:: simgrid::s4u::Host::turn_off()
1417 .. doxygenfunction:: simgrid::s4u::Host::turn_on()
1421 .. doxygenfunction:: sg_host_is_on(const_sg_host_t host)
1422 .. doxygenfunction:: sg_host_turn_off(sg_host_t host)
1423 .. doxygenfunction:: sg_host_turn_on(sg_host_t host)
1425 .. _API_s4u_Host_dvfs:
1430 See also the :ref:`relevant examples <s4u_ex_dvfs>`.
1436 .. doxygenfunction:: simgrid::s4u::Host::get_pstate() const
1437 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_count() const
1438 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_speed(unsigned long pstate_index) const
1439 .. doxygenfunction:: simgrid::s4u::Host::set_pstate(unsigned long pstate_index)
1441 .. group-tab:: Python
1443 .. autoattribute:: simgrid.Host.pstate
1444 .. autoattribute:: simgrid.Host.pstate_count
1445 .. automethod:: simgrid.Host.pstate_speed
1449 .. doxygenfunction:: sg_host_get_available_speed(const_sg_host_t host)
1450 .. doxygenfunction:: sg_host_get_nb_pstates(const_sg_host_t host)
1451 .. doxygenfunction:: sg_host_get_pstate(const_sg_host_t host)
1452 .. doxygenfunction:: sg_host_get_pstate_speed(const_sg_host_t host, unsigned long pstate_index)
1453 .. doxygenfunction:: sg_host_set_pstate(sg_host_t host, unsigned long pstate)
1462 .. doxygenfunction:: simgrid::s4u::Host::set_speed_profile(kernel::profile::Profile *p)
1463 .. doxygenfunction:: simgrid::s4u::Host::set_state_profile(kernel::profile::Profile *p)
1465 .. group-tab:: Python
1467 .. automethod:: simgrid.Host.set_speed_profile
1468 .. automethod:: simgrid.Host.set_state_profile
1477 .. doxygenfunction:: simgrid::s4u::Host::exec_async
1478 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops) const
1479 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops, double priority) const
1481 Platform and routing
1482 --------------------
1484 You can also start direct communications between two arbitrary hosts
1485 using :cpp:func:`Comm::sendto() <simgrid::s4u::Comm::sendto()>`.
1491 .. doxygenfunction:: simgrid::s4u::Host::get_englobing_zone() const
1492 .. doxygenfunction:: simgrid::s4u::Host::get_netpoint() const
1493 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< Link * > &links, double *latency) const
1494 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< kernel::resource::StandardLinkImpl * > &links, double *latency) const
1495 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
1496 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, const std::string& read_bandwidth, const std::string& write_bandwidth)
1498 .. group-tab:: Python
1500 .. autoattribute:: simgrid.Host.netpoint
1501 .. automethod:: simgrid.Host.create_disk
1503 .. automethod:: simgrid.Host.route_to
1507 .. doxygenfunction:: sg_host_get_route(const_sg_host_t from, const_sg_host_t to, xbt_dynar_t links)
1508 .. doxygenfunction:: sg_host_get_route_bandwidth(const_sg_host_t from, const_sg_host_t to)
1509 .. doxygenfunction:: sg_host_get_route_latency(const_sg_host_t from, const_sg_host_t to)
1510 .. doxygenfunction:: sg_host_sendto(sg_host_t from, sg_host_t to, double byte_amount)
1519 .. doxygenfunction:: simgrid::s4u::Host::on_creation_cb
1520 .. doxygenfunction:: simgrid::s4u::Host::on_destruction_cb
1521 .. doxygenfunction:: simgrid::s4u::Host::on_this_destruction_cb
1522 .. doxygenfunction:: simgrid::s4u::Host::on_speed_change_cb
1523 .. doxygenfunction:: simgrid::s4u::Host::on_this_speed_change_cb
1524 .. doxygenfunction:: simgrid::s4u::Host::on_onoff_cb
1525 .. doxygenfunction:: simgrid::s4u::Host::on_this_onoff_cb
1526 .. doxygenfunction:: simgrid::s4u::Host::on_exec_state_change_cb
1538 .. doxygenclass:: simgrid::s4u::Link
1539 .. doxygenclass:: simgrid::s4u::SplitDuplexLink
1540 .. doxygenclass:: simgrid::s4u::LinkInRoute
1543 .. group-tab:: Python
1545 .. autoclass:: simgrid.Link
1556 #include <simgrid/s4u/Link.hpp>
1558 Note that there is no LinkPtr type and that you cannot use the RAII
1559 idiom on hosts because SimGrid does not allow (yet) to create nor
1560 destroy resources once the simulation is started.
1562 .. doxygenfunction:: simgrid::s4u::Link::seal()
1564 .. group-tab:: Python
1568 from simgrid import Link
1570 .. automethod:: simgrid.Link.seal
1576 #include <simgrid/link.h>
1578 .. doxygentypedef:: sg_link_t
1579 .. cpp:type:: const s4u_Link* const_sg_link_t
1581 Pointer to a constant link object.
1590 See also :cpp:func:`simgrid::s4u::Engine::get_all_links`.
1592 .. doxygenfunction:: simgrid::s4u::Link::by_name(const std::string &name)
1593 .. doxygenfunction:: simgrid::s4u::Link::by_name_or_null(const std::string &name)
1595 .. group-tab:: Python
1597 See also :py:attr:`simgrid.Engine.all_links`.
1599 .. automethod:: simgrid.Link.by_name
1600 .. autoattribute:: simgrid.Link.name
1604 .. doxygenfunction:: sg_link_by_name(const char *name)
1605 .. doxygenfunction:: sg_link_count()
1606 .. doxygenfunction:: sg_link_list()
1615 .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
1616 .. doxygenfunction:: simgrid::s4u::Link::get_cname() const
1617 .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
1618 .. doxygenfunction:: simgrid::s4u::Link::get_name() const
1619 .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
1620 .. doxygenfunction:: simgrid::s4u::Link::get_concurrency_limit() const
1621 .. doxygenfunction:: simgrid::s4u::Link::get_usage() const
1622 .. doxygenfunction:: simgrid::s4u::Link::is_used() const
1624 .. group-tab:: Python
1626 .. autoattribute:: simgrid.Link.bandwidth
1627 .. autoattribute:: simgrid.Link.latency
1631 .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
1632 .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
1633 .. doxygenfunction:: sg_link_get_name(const_sg_link_t link)
1634 .. doxygenfunction:: sg_link_is_shared(const_sg_link_t link)
1636 Modifying characteristics
1637 -------------------------
1643 .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth(double value)
1644 .. doxygenfunction:: simgrid::s4u::Link::set_latency(double value)
1645 .. doxygenfunction:: simgrid::s4u::Link::set_latency(const std::string& value)
1646 .. doxygenfunction:: simgrid::s4u::Link::set_concurrency_limit(int limit)
1647 .. doxygenfunction:: simgrid::s4u::Link::set_sharing_policy
1649 .. group-tab:: Python
1651 .. automethod:: simgrid.Link.set_bandwidth
1652 .. automethod:: simgrid.Link.set_latency
1653 .. automethod:: simgrid.Link.set_concurrency_limit
1654 .. automethod:: simgrid.Link.set_sharing_policy
1658 .. doxygenfunction:: sg_link_set_bandwidth(sg_link_t link, double value)
1659 .. doxygenfunction:: sg_link_set_latency(sg_link_t link, double value)
1661 User data and properties
1662 ------------------------
1668 .. doxygenfunction:: simgrid::s4u::Link::get_property(const std::string &key) const
1669 .. doxygenfunction:: simgrid::s4u::Link::set_property(const std::string &key, const std::string &value)
1673 .. doxygenfunction:: sg_link_get_data(const_sg_link_t link)
1674 .. doxygenfunction:: sg_link_set_data(sg_link_t link, void *data)
1683 See also :cpp:func:`simgrid::s4u::Link::set_state_profile`.
1685 .. doxygenfunction:: simgrid::s4u::Link::is_on() const
1686 .. doxygenfunction:: simgrid::s4u::Link::turn_off()
1687 .. doxygenfunction:: simgrid::s4u::Link::turn_on()
1689 .. group-tab:: Python
1691 See also :py:func:`simgrid.Link.set_state_profile`.
1693 .. automethod:: simgrid.Link.is_on
1694 .. automethod:: simgrid.Link.turn_off
1695 .. automethod:: simgrid.Link.turn_on
1700 See :ref:`howto_churn` for more details.
1706 .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth_profile(kernel::profile::Profile *profile)
1707 .. doxygenfunction:: simgrid::s4u::Link::set_latency_profile(kernel::profile::Profile *profile)
1708 .. doxygenfunction:: simgrid::s4u::Link::set_state_profile(kernel::profile::Profile *profile)
1710 .. group-tab:: Python
1712 .. automethod:: simgrid.Link.set_bandwidth_profile
1713 .. automethod:: simgrid.Link.set_latency_profile
1714 .. automethod:: simgrid.Link.set_state_profile
1723 .. doxygenfunction:: simgrid::s4u::Link::set_host_wifi_rate
1725 .. group-tab:: Python
1727 .. automethod:: simgrid.Link.set_host_wifi_rate
1736 .. doxygenfunction:: simgrid::s4u::Link::on_bandwidth_change_cb
1737 .. doxygenfunction:: simgrid::s4u::Link::on_this_bandwidth_change_cb
1738 .. doxygenfunction:: simgrid::s4u::Link::on_communication_state_change_cb
1739 .. doxygenfunction:: simgrid::s4u::Link::on_creation_cb
1740 .. doxygenfunction:: simgrid::s4u::Link::on_destruction_cb
1741 .. doxygenfunction:: simgrid::s4u::Link::on_this_destruction_cb
1742 .. doxygenfunction:: simgrid::s4u::Link::on_onoff_cb
1743 .. doxygenfunction:: simgrid::s4u::Link::on_this_onoff_cb
1745 .. _API_s4u_NetZone:
1755 .. doxygenclass:: simgrid::s4u::NetZone
1757 .. group-tab:: Python
1759 .. autoclass:: simgrid.NetZone
1770 #include <simgrid/s4u/NetZone.hpp>
1772 Note that there is no NetZonePtr type and that you cannot use the RAII
1773 idiom on network zones because SimGrid does not allow (yet) to create nor
1774 destroy resources once the simulation is started.
1776 .. doxygenfunction:: simgrid::s4u::NetZone::seal
1778 .. group-tab:: Python
1782 from simgrid import NetZone
1784 .. automethod:: simgrid.NetZone.seal
1790 #include <simgrid/zone.h>
1792 .. doxygentypedef:: sg_netzone_t
1793 .. cpp:type:: const s4u_NetZone* const_sg_netzone_t
1795 Pointer to a constant network zone object.
1804 See :cpp:func:`simgrid::s4u::Engine::get_netzone_root`,
1805 :cpp:func:`simgrid::s4u::Engine::netzone_by_name_or_null` and
1806 :cpp:func:`simgrid::s4u::Engine::get_filtered_netzones`.
1810 .. doxygenfunction:: sg_zone_get_by_name(const char *name)
1811 .. doxygenfunction:: sg_zone_get_root()
1820 .. doxygenfunction:: simgrid::s4u::NetZone::get_cname() const
1821 .. doxygenfunction:: simgrid::s4u::NetZone::get_name() const
1822 .. doxygenfunction:: simgrid::s4u::NetZone::get_netpoint()
1824 .. group-tab:: Python
1826 .. autoattribute:: simgrid.NetZone.name
1827 .. autoattribute:: simgrid.NetZone.netpoint
1831 .. doxygenfunction:: sg_zone_get_name(const_sg_netzone_t zone)
1833 User data and properties
1834 ------------------------
1840 .. doxygenfunction:: simgrid::s4u::NetZone::get_properties() const
1841 .. doxygenfunction:: simgrid::s4u::NetZone::get_property(const std::string &key) const
1842 .. doxygenfunction:: simgrid::s4u::NetZone::set_property(const std::string &key, const std::string &value)
1844 .. group-tab:: Python
1846 .. automethod:: simgrid.NetZone.set_property
1850 .. doxygenfunction:: sg_zone_get_property_value(const_sg_netzone_t as, const char *name)
1851 .. doxygenfunction:: sg_zone_set_property_value(sg_netzone_t netzone, const char *name, const char *value)
1853 Retrieving components
1854 ---------------------
1860 .. doxygenfunction:: simgrid::s4u::NetZone::get_all_hosts() const
1861 .. doxygenfunction:: simgrid::s4u::NetZone::get_host_count() const
1865 .. doxygenfunction:: sg_zone_get_hosts(const_sg_netzone_t zone, xbt_dynar_t whereto)
1874 .. doxygenfunction:: simgrid::s4u::NetZone::add_component(kernel::routing::NetPoint *elm)
1875 .. doxygenfunction:: simgrid::s4u::NetZone::add_route
1876 .. doxygenfunction:: simgrid::s4u::NetZone::add_bypass_route
1877 .. doxygenfunction:: simgrid::s4u::NetZone::get_children() const
1878 .. doxygenfunction:: simgrid::s4u::NetZone::get_parent() const
1879 .. doxygenfunction:: simgrid::s4u::NetZone::set_parent(const NetZone* parent)
1881 .. group-tab:: Python
1883 .. automethod:: simgrid.NetZone.add_route
1884 .. automethod:: simgrid.NetZone.set_parent
1888 .. doxygenfunction:: sg_zone_get_sons(const_sg_netzone_t zone, xbt_dict_t whereto)
1897 .. doxygenfunction:: simgrid::s4u::NetZone::on_creation_cb
1898 .. doxygenfunction:: simgrid::s4u::NetZone::on_seal_cb
1909 .. doxygenfunction:: simgrid::s4u::create_full_zone
1910 .. doxygenfunction:: simgrid::s4u::create_empty_zone
1911 .. doxygenfunction:: simgrid::s4u::create_star_zone
1912 .. doxygenfunction:: simgrid::s4u::create_dijkstra_zone
1913 .. doxygenfunction:: simgrid::s4u::create_floyd_zone
1914 .. doxygenfunction:: simgrid::s4u::create_vivaldi_zone
1915 .. doxygenfunction:: simgrid::s4u::create_wifi_zone
1916 .. doxygenfunction:: simgrid::s4u::create_torus_zone
1917 .. doxygenfunction:: simgrid::s4u::create_fatTree_zone
1918 .. doxygenfunction:: simgrid::s4u::create_dragonfly_zone
1920 .. group-tab:: Python
1922 .. automethod:: simgrid.NetZone.create_full_zone
1923 .. automethod:: simgrid.NetZone.create_empty_zone
1924 .. automethod:: simgrid.NetZone.create_star_zone
1925 .. automethod:: simgrid.NetZone.create_dijkstra_zone
1926 .. automethod:: simgrid.NetZone.create_floyd_zone
1927 .. automethod:: simgrid.NetZone.create_vivaldi_zone
1928 .. automethod:: simgrid.NetZone.create_wifi_zone
1929 .. automethod:: simgrid.NetZone.create_torus_zone
1930 .. automethod:: simgrid.NetZone.create_fatTree_zone
1931 .. automethod:: simgrid.NetZone.create_dragonfly_zone
1940 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<double>& speed_per_pstate)
1941 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, double speed)
1942 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<std::string>& speed_per_pstate)
1943 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::string& speed)
1945 .. group-tab:: Python
1947 .. automethod:: simgrid.NetZone.create_host
1956 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::vector<double>& bandwidths)
1957 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, double bandwidth)
1958 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::vector<std::string>& bandwidthds)
1959 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string& name, const std::string& bandwidth)
1960 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string& name, const std::string& bandwidth)
1961 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string& name, double bandwidth)
1963 .. group-tab:: Python
1965 .. automethod:: simgrid.NetZone.create_link
1966 .. automethod:: simgrid.NetZone.create_split_duplex_link
1975 .. doxygenfunction:: simgrid::s4u::NetZone::create_router(const std::string& name)
1977 .. group-tab:: Python
1979 .. automethod:: simgrid.NetZone.create_router
1981 .. _API_s4u_VirtualMachine:
1983 =======================
1984 class VirtualMachine
1985 =======================
1988 .. doxygenclass:: simgrid::s4u::VirtualMachine
1998 #include <simgrid/s4u/VirtualMachine.hpp>
2000 Note that there is no VirtualMachinePtr type, and that you cannot use the RAII
2001 idiom on virtual machines. There is no good reason for that and should change in the future.
2007 #include <simgrid/vm.h>
2009 .. doxygentypedef:: sg_vm_t
2010 .. cpp:type:: const s4u_VirtualMachine* const_sg_vm_t
2012 Pointer to a constant virtual machine object.
2021 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount)
2022 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount, size_t ramsize)
2023 .. doxygenfunction:: simgrid::s4u::VirtualMachine::destroy
2027 .. doxygenfunction:: sg_vm_create_core
2028 .. doxygenfunction:: sg_vm_create_multicore
2029 .. doxygenfunction:: sg_vm_destroy
2038 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_pm() const
2039 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_ramsize() const
2040 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_state() const
2042 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_bound(double bound)
2043 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_pm(Host *pm)
2044 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_ramsize(size_t ramsize)
2048 .. doxygenfunction:: sg_vm_get_ramsize(const_sg_vm_t vm)
2049 .. doxygenfunction:: sg_vm_set_bound(sg_vm_t vm, double bound)
2050 .. doxygenfunction:: sg_vm_set_ramsize(sg_vm_t vm, size_t size)
2052 .. doxygenfunction:: sg_vm_get_name
2053 .. doxygenfunction:: sg_vm_get_pm
2054 .. doxygenfunction:: sg_vm_is_created
2055 .. doxygenfunction:: sg_vm_is_running
2056 .. doxygenfunction:: sg_vm_is_suspended
2065 .. doxygenfunction:: simgrid::s4u::VirtualMachine::resume()
2066 .. doxygenfunction:: simgrid::s4u::VirtualMachine::shutdown()
2067 .. doxygenfunction:: simgrid::s4u::VirtualMachine::start()
2068 .. doxygenfunction:: simgrid::s4u::VirtualMachine::suspend()
2072 .. doxygenfunction:: sg_vm_start
2073 .. doxygenfunction:: sg_vm_suspend
2074 .. doxygenfunction:: sg_vm_resume
2075 .. doxygenfunction:: sg_vm_shutdown
2084 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_creation_cb
2085 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_destruction_cb
2086 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_destruction_cb
2087 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_end_cb
2088 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_end_cb
2089 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_start_cb
2090 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_start_cb
2091 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_resume_cb
2092 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_resume_cb
2093 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_shutdown_cb
2094 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_shutdown_cb
2095 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_start_cb
2096 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_start_cb
2097 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_started_cb
2098 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_started_cb
2099 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_suspend_cb
2100 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_suspend_cb
2102 .. _API_s4u_Activity:
2112 .. doxygenclass:: simgrid::s4u::Activity
2114 **Known subclasses:**
2115 :ref:`Communications <API_s4u_Comm>` (started on Mailboxes and consuming links),
2116 :ref:`Executions <API_s4u_Exec>` (started on Host and consuming CPU resources)
2117 :ref:`I/O <API_s4u_Io>` (started on and consuming disks).
2118 See also the :ref:`section on activities <s4u_Activities>` above.
2129 #include <simgrid/s4u/Activity.hpp>
2131 .. doxygentypedef:: ActivityPtr
2140 .. doxygenfunction:: simgrid::s4u::Activity::get_cname() const
2141 .. doxygenfunction:: simgrid::s4u::Activity::get_name() const
2142 .. doxygenfunction:: simgrid::s4u::Activity::get_remaining() const
2143 .. doxygenfunction:: simgrid::s4u::Activity::get_state() const
2144 .. doxygenfunction:: simgrid::s4u::Activity::set_remaining(double remains)
2145 .. doxygenfunction:: simgrid::s4u::Activity::set_state(Activity::State state)
2148 Activities life cycle
2149 ---------------------
2155 .. doxygenfunction:: simgrid::s4u::Activity::start
2156 .. doxygenfunction:: simgrid::s4u::Activity::cancel
2157 .. doxygenfunction:: simgrid::s4u::Activity::test
2158 .. doxygenfunction:: simgrid::s4u::Activity::wait
2159 .. doxygenfunction:: simgrid::s4u::Activity::wait_for
2160 .. doxygenfunction:: simgrid::s4u::Activity::wait_until(double time_limit)
2161 .. doxygenfunction:: simgrid::s4u::Activity::vetoable_start()
2163 Suspending and resuming an activity
2164 -----------------------------------
2170 .. doxygenfunction:: simgrid::s4u::Activity::suspend
2171 .. doxygenfunction:: simgrid::s4u::Activity::resume
2172 .. doxygenfunction:: simgrid::s4u::Activity::is_suspended
2184 .. doxygenclass:: simgrid::s4u::Comm
2186 .. group-tab:: Python
2188 .. autoclass:: simgrid.Comm
2199 #include <simgrid/s4u/Comm.hpp>
2201 .. doxygentypedef:: CommPtr
2203 .. group-tab:: Python
2207 from simgrid import Comm
2213 #include <simgrid/comm.h>
2215 .. doxygentypedef:: sg_comm_t
2224 .. doxygenfunction:: simgrid::s4u::Comm::get_dst_data_size() const
2225 .. doxygenfunction:: simgrid::s4u::Comm::get_mailbox() const
2226 .. doxygenfunction:: simgrid::s4u::Comm::get_sender() const
2227 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff)
2228 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff, size_t size)
2229 .. doxygenfunction:: simgrid::s4u::Comm::detach()
2230 .. doxygenfunction:: simgrid::s4u::Comm::detach(const std::function<void(void*)>& clean_function)
2231 .. doxygenfunction:: simgrid::s4u::Comm::set_payload_size(uint64_t bytes)
2232 .. doxygenfunction:: simgrid::s4u::Comm::set_rate(double rate)
2233 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff)
2234 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff, size_t size)
2235 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data_size(size_t size)
2237 .. group-tab:: Python
2239 .. autoattribute:: simgrid.Comm.dst_data_size
2240 .. autoattribute:: simgrid.Comm.mailbox
2241 .. autoattribute:: simgrid.Comm.sender
2242 .. autoattribute:: simgrid.Comm.state_str
2243 .. automethod:: simgrid.Comm.detach
2244 .. automethod:: simgrid.Comm.set_payload_size
2245 .. automethod:: simgrid.Comm.set_rate
2247 Direct host-to-host communication
2248 ---------------------------------
2250 Most communications are created using :ref:`s4u_mailbox`, but you can
2251 also start direct communications as shown below. See also the
2252 :ref:`relevant examples <s4u_ex_comm_host2host>`.
2258 .. doxygenfunction:: simgrid::s4u::Comm::sendto
2259 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init()
2260 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init(Host *from, Host *to)
2261 .. doxygenfunction:: simgrid::s4u::Comm::sendto_async
2263 .. group-tab:: Python
2265 .. automethod:: simgrid.Comm.sendto
2266 .. automethod:: simgrid.Comm.sendto_init
2267 .. automethod:: simgrid.Comm.sendto_async
2276 .. doxygenfunction:: simgrid::s4u::Comm::cancel
2277 .. doxygenfunction:: simgrid::s4u::Comm::start
2278 .. doxygenfunction:: simgrid::s4u::Comm::test
2279 .. doxygenfunction:: simgrid::s4u::Comm::wait
2280 .. doxygenfunction:: simgrid::s4u::Comm::wait_for
2281 .. doxygenfunction:: simgrid::s4u::Comm::wait_until
2283 .. group-tab:: Python
2285 .. automethod:: simgrid.Comm.cancel
2286 .. automethod:: simgrid.Comm.start
2287 .. automethod:: simgrid.Comm.test
2288 .. automethod:: simgrid.Comm.wait
2289 .. automethod:: simgrid.Comm.wait_for
2290 .. automethod:: simgrid.Comm.wait_until
2294 .. doxygenfunction:: sg_comm_test
2295 .. doxygenfunction:: sg_comm_wait
2297 Suspending and resuming a communication
2298 ---------------------------------------
2304 .. doxygenfunction:: simgrid::s4u::Comm::suspend
2305 .. doxygenfunction:: simgrid::s4u::Comm::resume
2306 .. doxygenfunction:: simgrid::s4u::Comm::is_suspended
2308 .. group-tab:: Python
2310 .. automethod:: simgrid.Comm.suspend
2311 .. automethod:: simgrid.Comm.resume
2312 .. autoattribute:: simgrid.Comm.is_suspended
2321 .. doxygenfunction:: simgrid::s4u::Comm::on_start_cb
2322 .. doxygenfunction:: simgrid::s4u::Comm::on_this_start_cb
2323 .. doxygenfunction:: simgrid::s4u::Comm::on_completion_cb
2324 .. doxygenfunction:: simgrid::s4u::Comm::on_this_completion_cb
2325 .. doxygenfunction:: simgrid::s4u::Comm::on_recv_cb
2326 .. doxygenfunction:: simgrid::s4u::Comm::on_send_cb
2327 .. doxygenfunction:: simgrid::s4u::Comm::on_suspended_cb
2328 .. doxygenfunction:: simgrid::s4u::Comm::on_resumed_cb
2329 .. doxygenfunction:: simgrid::s4u::Comm::on_veto_cb
2341 .. doxygenclass:: simgrid::s4u::Exec
2343 .. group-tab:: Python
2345 .. autoclass:: simgrid.Exec
2349 .. doxygentypedef:: sg_exec_t
2350 .. doxygentypedef:: const_sg_exec_t
2361 #include <simgrid/s4u/Exec.hpp>
2363 .. doxygentypedef:: ExecPtr
2365 .. group-tab:: Python
2369 from simgrid import Exec
2375 #include <simgrid/exec.h>
2384 .. doxygenfunction:: simgrid::s4u::Exec::get_cost() const
2385 .. doxygenfunction:: simgrid::s4u::Exec::get_finish_time() const
2386 .. doxygenfunction:: simgrid::s4u::Exec::get_host() const
2387 .. doxygenfunction:: simgrid::s4u::Exec::get_host_number() const
2388 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining
2389 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining_ratio
2390 .. doxygenfunction:: simgrid::s4u::Exec::get_start_time() const
2391 .. doxygenfunction:: simgrid::s4u::Exec::set_bound(double bound)
2392 .. doxygenfunction:: simgrid::s4u::Exec::set_host
2393 .. doxygenfunction:: simgrid::s4u::Exec::set_priority(double priority)
2395 .. group-tab:: Python
2397 .. autoattribute:: simgrid.Exec.host
2398 .. autoattribute:: simgrid.Exec.remaining
2399 .. autoattribute:: simgrid.Exec.remaining_ratio
2403 .. doxygenfunction:: sg_exec_set_bound(sg_exec_t exec, double bound)
2404 .. doxygenfunction:: sg_exec_get_name(const_sg_exec_t exec)
2405 .. doxygenfunction:: sg_exec_set_name(sg_exec_t exec, const char* name)
2406 .. doxygenfunction:: sg_exec_set_host(sg_exec_t exec, sg_host_t new_host)
2407 .. doxygenfunction:: sg_exec_get_remaining(const_sg_exec_t exec)
2408 .. doxygenfunction:: sg_exec_get_remaining_ratio(const_sg_exec_t exec)
2417 .. doxygenfunction:: simgrid::s4u::Exec::cancel
2418 .. doxygenfunction:: simgrid::s4u::Exec::start
2419 .. doxygenfunction:: simgrid::s4u::Exec::test
2420 .. doxygenfunction:: simgrid::s4u::Exec::wait
2422 .. group-tab:: Python
2424 .. automethod:: simgrid.Exec.cancel
2425 .. automethod:: simgrid.Exec.start
2426 .. automethod:: simgrid.Exec.test
2427 .. automethod:: simgrid.Exec.wait
2431 .. doxygenfunction:: sg_exec_start(sg_exec_t exec)
2432 .. doxygenfunction:: sg_exec_cancel(sg_exec_t exec);
2433 .. doxygenfunction:: sg_exec_test(sg_exec_t exec);
2434 .. doxygenfunction:: sg_exec_wait(sg_exec_t exec);
2436 Suspending and resuming an execution
2437 ------------------------------------
2443 .. doxygenfunction:: simgrid::s4u::Exec::suspend
2444 .. doxygenfunction:: simgrid::s4u::Exec::resume
2445 .. doxygenfunction:: simgrid::s4u::Exec::is_suspended
2447 .. group-tab:: Python
2449 .. automethod:: simgrid.Exec.suspend
2450 .. automethod:: simgrid.Exec.resume
2451 .. autoattribute:: simgrid.Exec.is_suspended
2460 .. doxygenfunction:: simgrid::s4u::Exec::on_start_cb
2461 .. doxygenfunction:: simgrid::s4u::Exec::on_this_start_cb
2462 .. doxygenfunction:: simgrid::s4u::Exec::on_completion_cb
2463 .. doxygenfunction:: simgrid::s4u::Exec::on_this_completion_cb
2465 .. doxygenfunction:: simgrid::s4u::Exec::on_suspended_cb
2466 .. doxygenfunction:: simgrid::s4u::Exec::on_resumed_cb
2467 .. doxygenfunction:: simgrid::s4u::Exec::on_veto_cb
2479 .. doxygenclass:: simgrid::s4u::Io
2481 .. group-tab:: Python
2483 .. autoclass:: simgrid.Io
2494 #include <simgrid/s4u/Io.hpp>
2496 .. doxygentypedef:: IoPtr
2505 .. doxygenfunction:: simgrid::s4u::Io::get_performed_ioops() const
2506 .. doxygenfunction:: simgrid::s4u::Io::get_remaining
2515 .. doxygenfunction:: simgrid::s4u::Io::cancel
2516 .. doxygenfunction:: simgrid::s4u::Io::start
2517 .. doxygenfunction:: simgrid::s4u::Io::test
2518 .. doxygenfunction:: simgrid::s4u::Io::wait
2520 .. group-tab:: Python
2522 .. automethod:: simgrid.Io.test
2523 .. automethod:: simgrid.Io.wait
2532 .. doxygenfunction:: simgrid::s4u::Io::on_start_cb
2533 .. doxygenfunction:: simgrid::s4u::Io::on_this_start_cb
2534 .. doxygenfunction:: simgrid::s4u::Io::on_completion_cb
2535 .. doxygenfunction:: simgrid::s4u::Io::on_this_completion_cb
2537 .. doxygenfunction:: simgrid::s4u::Io::on_suspended_cb
2538 .. doxygenfunction:: simgrid::s4u::Io::on_resumed_cb
2539 .. doxygenfunction:: simgrid::s4u::Io::on_veto_cb
2541 .. _API_s4u_ActivitySet:
2543 ====================
2545 ====================
2551 .. doxygenclass:: simgrid::s4u::ActivitySet
2553 .. group-tab:: Python
2555 .. autoclass:: simgrid.ActivitySet
2559 .. doxygentypedef:: sg_activityset_t
2560 .. doxygentypedef:: const_sg_activityset_t
2571 #include <simgrid/s4u/ActivitySet.hpp>
2573 .. doxygentypedef:: ActivitySetPtr
2575 .. group-tab:: Python
2579 from simgrid import ActivitySet
2585 #include <simgrid/activity_set.h>
2587 .. doxygenfunction:: sg_activity_set_init
2588 .. doxygenfunction:: sg_activity_set_delete
2597 .. doxygenfunction:: simgrid::s4u::ActivitySet::push
2598 .. doxygenfunction:: simgrid::s4u::ActivitySet::erase
2599 .. doxygenfunction:: simgrid::s4u::ActivitySet::empty
2600 .. doxygenfunction:: simgrid::s4u::ActivitySet::size
2602 .. group-tab:: Python
2604 .. automethod:: simgrid.ActivitySet.push()
2605 .. automethod:: simgrid.ActivitySet.erase()
2606 .. automethod:: simgrid.ActivitySet.empty()
2607 .. automethod:: simgrid.ActivitySet.size()
2611 .. doxygenfunction:: sg_activity_set_push
2612 .. doxygenfunction:: sg_activity_set_erase
2613 .. doxygenfunction:: sg_activity_set_empty
2614 .. doxygenfunction:: sg_activity_set_size
2616 Interacting with the set
2617 ------------------------
2623 .. doxygenfunction:: simgrid::s4u::ActivitySet::test_any
2624 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_all
2625 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_all_for
2626 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_any
2627 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_any_for
2629 .. group-tab:: Python
2631 .. automethod:: simgrid.ActivitySet.test_any()
2632 .. automethod:: simgrid.ActivitySet.wait_all()
2633 .. automethod:: simgrid.ActivitySet.wait_all_for()
2634 .. automethod:: simgrid.ActivitySet.wait_any()
2635 .. automethod:: simgrid.ActivitySet.wait_any_for()
2639 .. doxygenfunction:: sg_activity_set_test_any
2640 .. doxygenfunction:: sg_activity_set_wait_all
2641 .. doxygenfunction:: sg_activity_set_wait_all_for
2642 .. doxygenfunction:: sg_activity_set_wait_any
2643 .. doxygenfunction:: sg_activity_set_wait_any_for
2644 .. doxygenfunction:: sg_activity_unref
2646 Dealing with failed activities
2647 ------------------------------
2653 .. doxygenfunction:: simgrid::s4u::ActivitySet::get_failed_activity()
2654 .. doxygenfunction:: simgrid::s4u::ActivitySet::has_failed_activities()
2666 .. doxygenclass:: simgrid::s4u::Task
2668 **Known subclasses:**
2669 :ref:`Communication Tasks <API_s4u_CommTask>`,
2670 :ref:`Executions Tasks <API_s4u_ExecTask>`,
2671 :ref:`I/O Tasks <API_s4u_IoTask>`.
2672 See also the :ref:`section on activities <s4u_Tasks>` above.
2683 #include <simgrid/s4u/Task.hpp>
2685 .. doxygentypedef:: TaskPtr
2694 .. doxygenfunction:: simgrid::s4u::Task::get_cname() const
2695 .. doxygenfunction:: simgrid::s4u::Task::get_name() const
2696 .. doxygenfunction:: simgrid::s4u::Task::get_count() const
2697 .. doxygenfunction:: simgrid::s4u::Task::get_amount() const
2698 .. doxygenfunction:: simgrid::s4u::Task::get_parallelism_degree() const
2699 .. doxygenfunction:: simgrid::s4u::Task::set_name(std::string name)
2700 .. doxygenfunction:: simgrid::s4u::Task::set_amount(double amount)
2701 .. doxygenfunction:: simgrid::s4u::Task::set_parallelism_degree(int n)
2709 .. doxygenfunction:: simgrid::s4u::Task::enqueue_firings(int n)
2711 Managing Dependencies
2712 ---------------------
2716 .. doxygenfunction:: simgrid::s4u::Task::add_successor(TaskPtr t)
2717 .. doxygenfunction:: simgrid::s4u::Task::remove_successor(TaskPtr t)
2718 .. doxygenfunction:: simgrid::s4u::Task::remove_all_successors()
2719 .. doxygenfunction:: simgrid::s4u::Task::get_successors() const
2723 .. doxygenclass:: simgrid::s4u::Token
2728 .. doxygenfunction:: simgrid::s4u::Task::get_next_token_from(TaskPtr t)
2729 .. doxygenfunction:: simgrid::s4u::Task::set_token(std::shared_ptr<Token> token)
2737 .. doxygenfunction:: simgrid::s4u::Task::on_start_cb
2738 .. doxygenfunction:: simgrid::s4u::Task::on_this_start_cb
2739 .. doxygenfunction:: simgrid::s4u::Task::on_completion_cb
2740 .. doxygenfunction:: simgrid::s4u::Task::on_this_completion_cb
2742 .. _API_s4u_CommTask:
2751 .. doxygenclass:: simgrid::s4u::CommTask
2762 #include <simgrid/s4u/Task.hpp>
2764 .. doxygentypedef:: CommTaskPtr
2773 .. doxygenfunction:: simgrid::s4u::CommTask::get_source() const
2774 .. doxygenfunction:: simgrid::s4u::CommTask::get_destination() const
2775 .. doxygenfunction:: simgrid::s4u::CommTask::get_bytes() const
2776 .. doxygenfunction:: simgrid::s4u::CommTask::set_source(Host* source);
2777 .. doxygenfunction:: simgrid::s4u::CommTask::set_destination(Host* destination);
2778 .. doxygenfunction:: simgrid::s4u::CommTask::set_bytes(double bytes)
2781 .. _API_s4u_ExecTask:
2790 .. doxygenclass:: simgrid::s4u::ExecTask
2801 #include <simgrid/s4u/Task.hpp>
2803 .. doxygentypedef:: ExecTaskPtr
2812 .. doxygenfunction:: simgrid::s4u::ExecTask::get_host() const
2813 .. doxygenfunction:: simgrid::s4u::ExecTask::get_flops() const
2814 .. doxygenfunction:: simgrid::s4u::ExecTask::set_host(Host* host);
2815 .. doxygenfunction:: simgrid::s4u::ExecTask::set_flops(double flops);
2826 .. doxygenclass:: simgrid::s4u::IoTask
2837 #include <simgrid/s4u/Task.hpp>
2839 .. doxygentypedef:: IoTaskPtr
2848 .. doxygenfunction:: simgrid::s4u::IoTask::get_disk() const
2849 .. doxygenfunction:: simgrid::s4u::IoTask::get_bytes() const
2850 .. doxygenfunction:: simgrid::s4u::IoTask::get_op_type() const
2851 .. doxygenfunction:: simgrid::s4u::IoTask::set_disk(Disk* disk);
2852 .. doxygenfunction:: simgrid::s4u::IoTask::set_bytes(double bytes);
2853 .. doxygenfunction:: simgrid::s4u::IoTask::set_op_type(Io::OpType type);
2855 .. _API_s4u_Synchronizations:
2857 =======================
2858 Synchronization Objects
2859 =======================
2871 .. doxygenclass:: simgrid::s4u::Mutex
2873 .. group-tab:: Python
2875 .. autoclass:: simgrid.Mutex
2886 #include <simgrid/s4u/Mutex.hpp>
2888 .. doxygentypedef:: MutexPtr
2890 .. doxygenfunction:: simgrid::s4u::Mutex::create
2892 .. group-tab:: Python
2894 .. code-block:: Python
2896 from simgrid import Mutex
2899 # Use a context manager to acquire and automatically release the mutex
2900 # when leaving the scope.
2902 # Access shared resource ...
2905 .. automethod:: simgrid.Mutex.__init__
2911 #include <simgrid/mutex.h>
2913 .. doxygentypedef:: sg_mutex_t
2914 .. cpp:type:: const s4u_Mutex* const_sg_mutex_t
2916 Pointer to a constant mutex object.
2918 .. doxygenfunction:: sg_mutex_init()
2919 .. doxygenfunction:: sg_mutex_destroy(const_sg_mutex_t mutex)
2928 .. doxygenfunction:: simgrid::s4u::Mutex::lock()
2929 .. doxygenfunction:: simgrid::s4u::Mutex::try_lock()
2930 .. doxygenfunction:: simgrid::s4u::Mutex::unlock()
2932 .. group-tab:: Python
2934 .. automethod:: simgrid.Mutex.lock
2935 .. automethod:: simgrid.Mutex.try_lock
2936 .. automethod:: simgrid.Mutex.unlock
2940 .. doxygenfunction:: sg_mutex_lock(sg_mutex_t mutex)
2941 .. doxygenfunction:: sg_mutex_try_lock(sg_mutex_t mutex)
2942 .. doxygenfunction:: sg_mutex_unlock(sg_mutex_t mutex)
2944 .. _API_s4u_Barrier:
2954 .. doxygenclass:: simgrid::s4u::Barrier
2956 .. group-tab:: Python
2958 .. autoclass:: simgrid.Barrier
2966 #include <simgrid/s4u/Barrier.hpp>
2968 .. doxygentypedef:: BarrierPtr
2970 .. doxygenfunction:: simgrid::s4u::Barrier::create(unsigned int expected_actors)
2971 .. doxygenfunction:: simgrid::s4u::Barrier::wait()
2973 .. group-tab:: Python
2975 .. code-block:: Python
2977 from simgrid import Barrier
2978 barrier = Barrier(2)
2980 .. automethod:: simgrid.Barrier.__init__
2981 .. automethod:: simgrid.Barrier.wait
2987 #include <simgrid/barrier.hpp>
2989 .. doxygentypedef:: sg_bar_t
2991 .. doxygenfunction:: sg_barrier_init(unsigned int count)
2992 .. doxygenfunction:: sg_barrier_destroy(sg_bar_t bar)
2993 .. doxygenfunction:: sg_barrier_wait(sg_bar_t bar)
2996 .. _API_s4u_ConditionVariable:
2998 ==========================
2999 Condition variable
3000 ==========================
3002 .. doxygenclass:: simgrid::s4u::ConditionVariable
3013 #include <simgrid/s4u/ConditionVariable.hpp>
3015 .. doxygentypedef:: ConditionVariablePtr
3017 .. doxygenfunction:: simgrid::s4u::ConditionVariable::create()
3023 #include <simgrid/cond.h>
3025 .. doxygentypedef:: sg_cond_t
3026 .. doxygentypedef:: const_sg_cond_t
3027 .. doxygenfunction:: sg_cond_init
3028 .. doxygenfunction:: sg_cond_destroy
3030 Waiting and notifying
3031 ---------------------
3037 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_all()
3038 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_one()
3039 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(s4u::MutexPtr lock)
3040 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< s4u::Mutex > &lock)
3041 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< Mutex > &lock, P pred)
3042 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration)
3043 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration, P pred)
3044 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration)
3045 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration, P pred)
3046 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time)
3047 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time, P pred)
3048 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time)
3049 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time, P pred)
3053 .. doxygenfunction:: sg_cond_notify_all
3054 .. doxygenfunction:: sg_cond_notify_one
3055 .. doxygenfunction:: sg_cond_wait
3056 .. doxygenfunction:: sg_cond_wait_for
3058 .. _API_s4u_Semaphore:
3068 .. doxygenclass:: simgrid::s4u::Semaphore
3070 .. group-tab:: Python
3072 .. autoclass:: simgrid.Semaphore
3083 #include <simgrid/s4u/Semaphore.hpp>
3085 .. doxygentypedef:: SemaphorePtr
3086 .. doxygenfunction:: simgrid::s4u::Semaphore::create(unsigned int initial_capacity)
3088 .. group-tab:: Python
3090 .. code-block:: Python
3092 from simgrid import Semaphore
3093 semaphore = Semaphore(1)
3094 # Automatically acquire the semaphore, and release it after leaving the scope.
3096 # Do something with the shared resource
3099 .. automethod:: simgrid.Semaphore.__init__
3105 #include <simgrid/semaphore.h>
3107 .. doxygentypedef:: sg_sem_t
3108 .. cpp:type:: const s4u_Semaphore* const_sg_sem_t
3110 Pointer to a constant semaphore object.
3112 .. doxygenfunction:: sg_sem_init(int initial_value)
3113 .. doxygenfunction:: sg_sem_destroy(const_sg_sem_t sem)
3122 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire()
3123 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire_timeout(double timeout)
3124 .. doxygenfunction:: simgrid::s4u::Semaphore::get_capacity() const
3125 .. doxygenfunction:: simgrid::s4u::Semaphore::release()
3126 .. doxygenfunction:: simgrid::s4u::Semaphore::would_block() const
3128 .. group-tab:: Python
3130 .. automethod:: simgrid.Semaphore.acquire
3131 .. automethod:: simgrid.Semaphore.acquire_timeout
3132 .. autoattribute:: simgrid.Semaphore.capacity
3133 .. automethod:: simgrid.Semaphore.release
3134 .. autoattribute:: simgrid.Semaphore.would_block
3138 .. doxygenfunction:: sg_sem_acquire(sg_sem_t sem)
3139 .. doxygenfunction:: sg_sem_acquire_timeout(sg_sem_t sem, double timeout)
3140 .. doxygenfunction:: sg_sem_get_capacity(const_sg_sem_t sem)
3141 .. doxygenfunction:: sg_sem_release(sg_sem_t sem)
3142 .. doxygenfunction:: sg_sem_would_block(const_sg_sem_t sem)
3152 .. doxygenclass:: simgrid::Exception
3154 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3156 .. doxygenclass:: simgrid::CancelException
3157 .. doxygenclass:: simgrid::HostFailureException
3158 .. doxygenclass:: simgrid::NetworkFailureException
3159 .. doxygenclass:: simgrid::StorageFailureException
3160 .. doxygenclass:: simgrid::TimeoutException
3161 .. doxygenclass:: simgrid::VmFailureException
3163 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3164 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3165 SimGrid from a python notebook and want to handle the problem accordingly.
3167 .. doxygenclass:: simgrid::AssertionError
3168 .. doxygenclass:: simgrid::ParseError
3169 .. doxygenclass:: simgrid::TracingError
3171 .. group-tab:: Python
3173 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3175 .. autoclass:: simgrid.CancelException
3176 .. autoclass:: simgrid.HostFailureException
3177 .. autoclass:: simgrid.NetworkFailureException
3178 .. autoclass:: simgrid.StorageFailureException
3179 .. autoclass:: simgrid.TimeoutException
3180 .. autoclass:: simgrid.VmFailureException
3182 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3183 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3184 SimGrid from a python notebook and want to handle the problem accordingly.
3186 .. autoclass:: simgrid.AssertionError
3190 .. doxygenenum:: sg_error_t