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 .. doxygentypedef:: xbt_main_func_t
476 .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, char *const *argv)
477 .. doxygenfunction:: sg_actor_init(const char *name, sg_host_t host)
478 .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char *const *argv)
479 .. doxygenfunction:: sg_actor_set_stacksize
481 .. doxygenfunction:: sg_actor_attach(const char *name, void *data, sg_host_t host, xbt_dict_t properties)
482 .. doxygenfunction:: sg_actor_detach()
491 .. doxygenfunction:: simgrid::s4u::Actor::by_pid(aid_t pid)
492 .. doxygenfunction:: simgrid::s4u::Actor::self()
494 .. group-tab:: Python
496 .. automethod:: simgrid.Actor.by_pid
497 .. automethod:: simgrid.Actor.self
501 .. doxygenfunction:: sg_actor_by_pid(aid_t pid)
502 .. doxygenfunction:: sg_actor_self()
503 .. doxygenfunction:: sg_actor_list()
512 .. doxygenfunction:: simgrid::s4u::Actor::get_cname
513 .. doxygenfunction:: simgrid::s4u::Actor::get_name
514 .. doxygenfunction:: simgrid::s4u::Actor::get_pid
515 .. doxygenfunction:: simgrid::s4u::Actor::get_ppid
516 .. doxygenfunction:: simgrid::s4u::Actor::get_properties() const
517 .. doxygenfunction:: simgrid::s4u::Actor::get_property(const std::string &key) const
518 .. doxygenfunction:: simgrid::s4u::Actor::set_property(const std::string &key, const std::string &value)
520 .. doxygenfunction:: simgrid::s4u::Actor::get_host
521 .. doxygenfunction:: simgrid::s4u::Actor::set_host
523 .. doxygenfunction:: simgrid::s4u::Actor::get_refcount
524 .. doxygenfunction:: simgrid::s4u::Actor::get_impl
526 .. group-tab:: Python
528 .. autoattribute:: simgrid.Actor.name
529 .. autoattribute:: simgrid.Actor.host
530 .. autoattribute:: simgrid.Actor.pid
531 .. autoattribute:: simgrid.Actor.ppid
535 .. doxygenfunction:: sg_actor_get_name(const_sg_actor_t actor)
536 .. doxygenfunction:: sg_actor_get_pid(const_sg_actor_t actor)
537 .. doxygenfunction:: sg_actor_get_ppid(const_sg_actor_t actor)
538 .. doxygenfunction:: sg_actor_get_properties(const_sg_actor_t actor)
539 .. doxygenfunction:: sg_actor_get_property_value(const_sg_actor_t actor, const char *name)
541 .. doxygenfunction:: sg_actor_get_host(const_sg_actor_t actor)
542 .. doxygenfunction:: sg_actor_set_host(sg_actor_t actor, sg_host_t host)
544 .. doxygenfunction:: sg_actor_get_data(const_sg_actor_t actor)
545 .. doxygenfunction:: sg_actor_set_data(sg_actor_t actor, void *userdata)
547 Suspending and resuming actors
548 ------------------------------
554 .. doxygenfunction:: simgrid::s4u::Actor::suspend()
555 .. doxygenfunction:: simgrid::s4u::Actor::resume()
556 .. doxygenfunction:: simgrid::s4u::Actor::is_suspended
558 .. group-tab:: Python
560 .. automethod:: simgrid.Actor.resume
561 .. automethod:: simgrid.Actor.suspend
562 .. automethod:: simgrid.Actor.is_suspended
566 .. doxygenfunction:: sg_actor_suspend(sg_actor_t actor)
567 .. doxygenfunction:: sg_actor_resume(sg_actor_t actor)
568 .. doxygenfunction:: sg_actor_is_suspended(const_sg_actor_t actor)
570 Specifying when actors should terminate
571 ---------------------------------------
577 .. doxygenfunction:: simgrid::s4u::Actor::kill()
578 .. doxygenfunction:: simgrid::s4u::Actor::kill_all()
579 .. doxygenfunction:: simgrid::s4u::Actor::set_kill_time(double time)
580 .. doxygenfunction:: simgrid::s4u::Actor::get_kill_time
582 .. doxygenfunction:: simgrid::s4u::Actor::restart()
583 .. doxygenfunction:: simgrid::s4u::Actor::daemonize()
584 .. doxygenfunction:: simgrid::s4u::Actor::is_daemon
586 .. group-tab:: Python
588 .. automethod:: simgrid.Actor.kill
589 .. automethod:: simgrid.Actor.kill_all
591 .. automethod:: simgrid.Actor.daemonize
592 .. automethod:: simgrid.Actor.is_daemon
596 .. doxygenfunction:: sg_actor_kill(sg_actor_t actor)
597 .. doxygenfunction:: sg_actor_kill_all()
598 .. doxygenfunction:: sg_actor_set_kill_time(sg_actor_t actor, double kill_time)
600 .. doxygenfunction:: sg_actor_restart(sg_actor_t actor)
601 .. doxygenfunction:: sg_actor_daemonize(sg_actor_t actor)
602 .. doxygenfunction:: sg_actor_is_daemon
604 .. _API_s4u_Actor_end:
606 Reacting to the end of actors
607 -----------------------------
613 .. doxygenfunction:: simgrid::s4u::Actor::on_exit
614 .. doxygenfunction:: simgrid::s4u::Actor::join() const
615 .. doxygenfunction:: simgrid::s4u::Actor::join(double timeout) const
616 .. doxygenfunction:: simgrid::s4u::Actor::set_auto_restart(bool autorestart)
617 .. doxygenfunction:: simgrid::s4u::Actor::get_restart_count
619 .. group-tab:: Python
621 .. automethod:: simgrid.Actor.join
625 .. doxygenfunction:: sg_actor_on_exit
626 .. doxygenfunction:: sg_actor_join(const_sg_actor_t actor, double timeout)
627 .. doxygenfunction:: sg_actor_set_auto_restart(sg_actor_t actor, int auto_restart)
636 .. doxygenfunction:: simgrid::s4u::Actor::on_creation_cb
637 .. doxygenfunction:: simgrid::s4u::Actor::on_suspend_cb
638 .. doxygenfunction:: simgrid::s4u::Actor::on_this_suspend_cb
639 .. doxygenfunction:: simgrid::s4u::Actor::on_host_change_cb
640 .. doxygenfunction:: simgrid::s4u::Actor::on_this_host_change_cb
641 .. doxygenfunction:: simgrid::s4u::Actor::on_resume_cb
642 .. doxygenfunction:: simgrid::s4u::Actor::on_this_resume_cb
643 .. doxygenfunction:: simgrid::s4u::Actor::on_sleep_cb
644 .. doxygenfunction:: simgrid::s4u::Actor::on_this_sleep_cb
645 .. doxygenfunction:: simgrid::s4u::Actor::on_wake_up_cb
646 .. doxygenfunction:: simgrid::s4u::Actor::on_this_wake_up_cb
647 .. doxygenfunction:: simgrid::s4u::Actor::on_termination_cb
648 .. doxygenfunction:: simgrid::s4u::Actor::on_this_termination_cb
649 .. doxygenfunction:: simgrid::s4u::Actor::on_destruction_cb
650 .. doxygenfunction:: simgrid::s4u::Actor::on_this_destruction_cb
652 .. _API_s4u_this_actor:
658 These functions can be used in your user code to interact with the actor
659 currently running (the one retrieved with :cpp:func:`simgrid::s4u::Actor::self`).
660 Using these functions can greatly improve the code readability.
669 .. doxygenfunction:: simgrid::s4u::this_actor::get_cname()
670 .. doxygenfunction:: simgrid::s4u::this_actor::get_name()
671 .. doxygenfunction:: simgrid::s4u::this_actor::get_pid()
672 .. doxygenfunction:: simgrid::s4u::this_actor::get_ppid()
673 .. doxygenfunction:: simgrid::s4u::this_actor::is_maestro()
675 .. doxygenfunction:: simgrid::s4u::this_actor::get_host()
676 .. doxygenfunction:: simgrid::s4u::this_actor::set_host(Host *new_host)
678 .. group-tab:: Python
680 .. autofunction:: simgrid.this_actor.get_host
681 .. autofunction:: simgrid.this_actor.set_host
683 .. autofunction:: simgrid.this_actor.get_pid
684 .. autofunction:: simgrid.this_actor.get_ppid
688 .. doxygenfunction:: sg_actor_self_get_data()
689 .. doxygenfunction:: sg_actor_self_set_data(void *data)
690 .. doxygenfunction:: sg_actor_self_get_name()
691 .. doxygenfunction:: sg_actor_self_get_pid()
692 .. doxygenfunction:: sg_actor_self_get_ppid()
693 .. doxygenfunction:: sg_host_self()
694 .. doxygenfunction:: sg_host_self_get_name()
696 Suspending and resuming
697 -----------------------
703 .. doxygenfunction:: simgrid::s4u::this_actor::suspend()
704 .. doxygenfunction:: simgrid::s4u::this_actor::yield()
706 .. group-tab:: Python
708 .. autofunction:: simgrid.this_actor.suspend
709 .. autofunction:: simgrid.this_actor.yield_
713 .. doxygenfunction:: sg_actor_yield()
722 Please refer to :ref:`the relevant documentation <logging_prog>`.
724 .. group-tab:: Python
726 .. autofunction:: simgrid.this_actor.debug
727 .. autofunction:: simgrid.this_actor.info
728 .. autofunction:: simgrid.this_actor.warning
729 .. autofunction:: simgrid.this_actor.error
738 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(double duration)
739 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_for(std::chrono::duration< Rep, Period > duration)
740 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(const SimulationTimePoint< Duration > &wakeup_time)
741 .. doxygenfunction:: simgrid::s4u::this_actor::sleep_until(double wakeup_time)
743 .. group-tab:: Python
745 .. autofunction:: simgrid.this_actor.sleep_for
746 .. autofunction:: simgrid.this_actor.sleep_until
750 .. doxygenfunction:: sg_actor_sleep_for(double duration)
752 Simulating executions
753 ---------------------
755 Simulate the execution of some code on this actor. You can either simulate
756 parallel or sequential code and you can either block upon the termination of
757 the execution, or start an asynchronous activity.
763 .. doxygenfunction:: simgrid::s4u::this_actor::exec_async
764 .. 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)
765 .. doxygenfunction:: simgrid::s4u::this_actor::exec_init(double flops_amounts)
766 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop)
767 .. doxygenfunction:: simgrid::s4u::this_actor::execute(double flop, double priority)
768 .. 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)
769 .. doxygenfunction:: simgrid::s4u::this_actor::thread_execute
771 .. group-tab:: Python
773 .. autofunction:: simgrid.this_actor.exec_async
774 .. autofunction:: simgrid.this_actor.exec_init
775 .. autofunction:: simgrid.this_actor.execute
779 .. doxygenfunction:: sg_actor_execute(double flops)
780 .. doxygenfunction:: sg_actor_execute_with_priority(double flops, double priority)
781 .. doxygenfunction:: sg_actor_exec_init(double computation_amount)
782 .. doxygenfunction:: sg_actor_exec_async(double computation_amount)
783 .. doxygenfunction:: sg_actor_parallel_exec_init(int host_nb, const sg_host_t* host_list, double* flops_amount, double* bytes_amount);
792 .. doxygenfunction:: simgrid::s4u::this_actor::exit()
793 .. doxygenfunction:: simgrid::s4u::this_actor::on_exit(const std::function< void(bool)> &fun)
795 .. group-tab:: Python
797 .. autofunction:: simgrid.this_actor.exit
798 .. autofunction:: simgrid.this_actor.on_exit
802 See also :cpp:func:`sg_actor_on_exit`.
804 .. doxygenfunction:: sg_actor_exit
816 .. doxygenclass:: simgrid::s4u::Engine
818 .. group-tab:: Python
820 .. autoclass:: simgrid.Engine
829 .. doxygenfunction:: simgrid::s4u::Engine::Engine(int *argc, char **argv)
830 .. doxygenfunction:: simgrid::s4u::Engine::is_initialized()
831 .. doxygenfunction:: simgrid::s4u::Engine::get_instance()
833 .. group-tab:: Python
835 .. automethod:: simgrid.Engine.__init__
836 .. autoattribute:: simgrid.Engine.instance
840 .. doxygenfunction:: simgrid_init
849 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &str)
850 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, bool value)
851 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, double value)
852 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, int value)
853 .. doxygenfunction:: simgrid::s4u::Engine::set_config(const std::string &name, const std::string &value)
855 .. doxygenfunction:: simgrid::s4u::Engine::load_deployment
856 .. doxygenfunction:: simgrid::s4u::Engine::load_platform
857 .. doxygenfunction:: simgrid::s4u::Engine::flatify_platform
858 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name)
859 .. doxygenfunction:: simgrid::s4u::Engine::register_actor(const std::string &name, F code)
860 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const std::function< void(int, char **)> &code)
861 .. doxygenfunction:: simgrid::s4u::Engine::register_default(const kernel::actor::ActorCodeFactory &factory)
863 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(int, char **)> &code)
864 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const std::function< void(std::vector< std::string >)> &code)
865 .. doxygenfunction:: simgrid::s4u::Engine::register_function(const std::string &name, const kernel::actor::ActorCodeFactory &factory)
867 .. group-tab:: Python
869 .. automethod:: simgrid.Engine.load_deployment
870 .. automethod:: simgrid.Engine.load_platform
871 .. automethod:: simgrid.Engine.register_actor
875 .. doxygenfunction:: simgrid_load_deployment
876 .. doxygenfunction:: simgrid_load_platform
877 .. doxygenfunction:: simgrid_register_default
878 .. doxygenfunction:: simgrid_register_function
888 .. doxygenfunction:: simgrid::s4u::Engine::get_clock()
889 .. doxygenfunction:: simgrid::s4u::Engine::run
890 .. doxygenfunction:: simgrid::s4u::Engine::run_until
892 .. group-tab:: Python
894 .. autoattribute:: simgrid.Engine.clock
895 .. automethod:: simgrid.Engine.run
896 .. automethod:: simgrid.Engine.run_until
900 .. doxygenfunction:: simgrid_get_clock
901 .. doxygenfunction:: simgrid_run
902 .. doxygenfunction:: simgrid_run_until
911 .. doxygenfunction:: simgrid::s4u::Engine::get_actor_count
912 .. doxygenfunction:: simgrid::s4u::Engine::get_all_actors
913 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_actors
917 .. doxygenfunction:: sg_actor_count()
926 .. doxygenfunction:: simgrid::s4u::Engine::get_all_hosts
927 .. doxygenfunction:: simgrid::s4u::Engine::get_host_count
928 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_hosts
929 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name
930 .. doxygenfunction:: simgrid::s4u::Engine::host_by_name_or_null
932 .. group-tab:: Python
934 .. autoattribute:: simgrid.Engine.all_hosts
935 .. automethod:: simgrid.Engine.host_by_name
939 See also :cpp:func:`sg_host_list` and :cpp:func:`sg_host_count`.
948 .. doxygenfunction:: simgrid::s4u::Engine::get_all_links
949 .. doxygenfunction:: simgrid::s4u::Engine::get_link_count
950 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_links
951 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name
952 .. doxygenfunction:: simgrid::s4u::Engine::link_by_name_or_null
954 .. group-tab:: Python
956 .. autoattribute:: simgrid.Engine.all_links
958 Interacting with the routing
959 ----------------------------
965 .. doxygenfunction:: simgrid::s4u::Engine::get_all_netpoints
966 .. doxygenfunction:: simgrid::s4u::Engine::get_filtered_netzones
967 .. doxygenfunction:: simgrid::s4u::Engine::get_netzone_root
968 .. doxygenfunction:: simgrid::s4u::Engine::netpoint_by_name_or_null
969 .. doxygenfunction:: simgrid::s4u::Engine::netzone_by_name_or_null
971 .. group-tab:: Python
973 .. autoattribute:: simgrid.Engine.all_netpoints
974 .. autoattribute:: simgrid.Engine.netzone_root
975 .. automethod:: simgrid.Engine.netpoint_by_name
976 .. automethod:: simgrid.Engine.netzone_by_name
985 .. doxygenfunction:: simgrid::s4u::Engine::on_deadlock_cb
986 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_created_cb
987 .. doxygenfunction:: simgrid::s4u::Engine::on_platform_creation_cb
988 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_start_cb
989 .. doxygenfunction:: simgrid::s4u::Engine::on_simulation_end_cb
990 .. doxygenfunction:: simgrid::s4u::Engine::on_time_advance_cb
1002 .. doxygenclass:: simgrid::s4u::Mailbox
1004 .. group-tab:: Python
1006 .. autoclass:: simgrid.Mailbox
1008 Please also refer to the :ref:`full doc on s4u::Mailbox <s4u_mailbox>`.
1019 #include <simgrid/s4u/Mailbox.hpp>
1021 Note that there is no MailboxPtr type and that you cannot use the RAII
1022 idiom on mailboxes because they are internal objects to the simulation
1023 engine. Once created, there is no way to destroy a mailbox before the end
1026 .. doxygenfunction:: simgrid::s4u::Mailbox::by_name(const std::string &name)
1028 .. group-tab:: Python
1032 #include <simgrid/mailbox.h>
1034 .. automethod:: simgrid.Mailbox.by_name
1040 #include <simgrid/s4u/mailbox.h>
1042 .. doxygentypedef:: sg_mailbox_t
1043 .. doxygentypedef:: const_sg_mailbox_t
1045 .. doxygenfunction:: sg_mailbox_by_name(const char *alias)
1054 .. doxygenfunction:: simgrid::s4u::Mailbox::get_cname
1055 .. doxygenfunction:: simgrid::s4u::Mailbox::get_name
1057 .. group-tab:: Python
1059 .. autoattribute:: simgrid.Mailbox.name
1068 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes)
1069 .. doxygenfunction:: simgrid::s4u::Mailbox::put(void *payload, uint64_t simulated_size_in_bytes, double timeout)
1070 .. doxygenfunction:: simgrid::s4u::Mailbox::put_async(void *data, uint64_t simulated_size_in_bytes)
1071 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init()
1072 .. doxygenfunction:: simgrid::s4u::Mailbox::put_init(void *data, uint64_t simulated_size_in_bytes)
1074 .. group-tab:: Python
1076 .. automethod:: simgrid.Mailbox.put
1077 .. automethod:: simgrid.Mailbox.put_async
1078 .. automethod:: simgrid.Mailbox.put_init
1082 .. doxygenfunction:: sg_mailbox_put(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1083 .. doxygenfunction:: sg_mailbox_put_init(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1084 .. doxygenfunction:: sg_mailbox_put_async(sg_mailbox_t mailbox, void *payload, long simulated_size_in_bytes)
1094 .. doxygenfunction:: simgrid::s4u::Mailbox::empty
1095 .. doxygenfunction:: simgrid::s4u::Mailbox::front
1096 .. doxygenfunction:: simgrid::s4u::Mailbox::get()
1097 .. doxygenfunction:: simgrid::s4u::Mailbox::get(double timeout)
1098 .. doxygenfunction:: simgrid::s4u::Mailbox::get_async(T **data)
1099 .. doxygenfunction:: simgrid::s4u::Mailbox::get_init()
1100 .. doxygenfunction:: simgrid::s4u::Mailbox::iprobe(int type, const std::function<bool(void *, void *, kernel::activity::CommImpl *)>& match_fun, void *data)
1101 .. doxygenfunction:: simgrid::s4u::Mailbox::listen
1102 .. doxygenfunction:: simgrid::s4u::Mailbox::ready
1104 .. group-tab:: Python
1106 .. automethod:: simgrid.Mailbox.get
1107 .. automethod:: simgrid.Mailbox.get_async
1108 .. autoattribute:: simgrid.Mailbox.ready
1112 .. doxygenfunction:: sg_mailbox_get(sg_mailbox_t mailbox)
1113 .. doxygenfunction:: sg_mailbox_get_async(sg_mailbox_t mailbox, void **data)
1114 .. doxygenfunction:: sg_mailbox_get_name(const_sg_mailbox_t mailbox)
1115 .. doxygenfunction:: sg_mailbox_listen(const char *alias)
1120 See :ref:`s4u_receiving_actor`.
1126 .. doxygenfunction:: simgrid::s4u::Mailbox::get_receiver
1127 .. doxygenfunction:: simgrid::s4u::Mailbox::set_receiver(ActorPtr actor)
1131 .. doxygenfunction:: sg_mailbox_set_receiver(const char *alias)
1133 .. _API_s4u_Resource:
1149 .. doxygenclass:: simgrid::s4u::Disk
1151 .. group-tab:: Python
1153 .. autoclass:: simgrid.Disk
1157 .. doxygentypedef:: sg_disk_t
1158 .. doxygentypedef:: const_sg_disk_t
1169 #include <simgrid/s4u/Disk.hpp>
1171 Note that there is no DiskPtr type and that you cannot use the RAII
1172 idiom on disks because SimGrid does not allow (yet) to create nor
1173 destroy resources once the simulation is started.
1175 .. doxygenfunction:: simgrid::s4u::Disk::seal()
1177 .. group-tab:: Python
1181 from simgrid import Disk
1183 .. automethod:: simgrid.Disk.seal
1193 .. doxygenfunction:: simgrid::s4u::Disk::get_cname() const
1194 .. doxygenfunction:: simgrid::s4u::Disk::get_host() const
1195 .. doxygenfunction:: simgrid::s4u::Disk::get_name() const
1196 .. doxygenfunction:: simgrid::s4u::Disk::get_properties() const
1197 .. doxygenfunction:: simgrid::s4u::Disk::get_property(const std::string &key) const
1198 .. doxygenfunction:: simgrid::s4u::Disk::get_read_bandwidth() const
1199 .. doxygenfunction:: simgrid::s4u::Disk::get_write_bandwidth() const
1200 .. doxygenfunction:: simgrid::s4u::Disk::set_property(const std::string &, const std::string &value)
1201 .. doxygenfunction:: simgrid::s4u::Disk::set_sharing_policy
1203 .. doxygenenum:: simgrid::s4u::Disk::Operation
1204 .. doxygenenum:: simgrid::s4u::Disk::SharingPolicy
1206 .. group-tab:: Python
1208 .. autoattribute:: simgrid.Disk.name
1209 .. automethod:: simgrid.Disk.set_sharing_policy
1211 .. autoclass:: simgrid.Disk.Operation
1212 .. autoclass:: simgrid.Disk.SharingPolicy
1221 .. doxygenfunction:: simgrid::s4u::Disk::io_init(sg_size_t size, s4u::Io::OpType type) const
1222 .. doxygenfunction:: simgrid::s4u::Disk::read(sg_size_t size) const
1223 .. doxygenfunction:: simgrid::s4u::Disk::read_async(sg_size_t size) const
1224 .. doxygenfunction:: simgrid::s4u::Disk::write(sg_size_t size) const
1225 .. doxygenfunction:: simgrid::s4u::Disk::write_async(sg_size_t size) const
1227 .. group-tab:: Python
1229 .. automethod:: simgrid.Disk.read
1230 .. automethod:: simgrid.Disk.read_async
1231 .. automethod:: simgrid.Disk.write
1232 .. automethod:: simgrid.Disk.write_async
1241 .. doxygenfunction:: simgrid::s4u::Disk::on_creation_cb
1242 .. doxygenfunction:: simgrid::s4u::Disk::on_destruction_cb
1243 .. doxygenfunction:: simgrid::s4u::Disk::on_this_destruction_cb
1244 .. doxygenfunction:: simgrid::s4u::Disk::on_onoff_cb
1245 .. doxygenfunction:: simgrid::s4u::Disk::on_this_onoff_cb
1258 .. doxygenclass:: simgrid::s4u::Host
1260 .. group-tab:: Python
1262 .. autoclass:: simgrid.Host
1273 #include <simgrid/s4u/Host.hpp>
1275 Note that there is no HostPtr type, and that you cannot use the RAII
1276 idiom on hosts because SimGrid does not allow (yet) to create nor
1277 destroy resources once the simulation is started.
1279 .. doxygenfunction:: simgrid::s4u::Host::destroy()
1280 .. doxygenfunction:: simgrid::s4u::Host::seal()
1282 .. group-tab:: Python
1286 from simgrid import Host
1288 .. automethod:: simgrid.Host.seal
1294 #include <simgrid/host.h>
1296 .. doxygentypedef:: sg_host_t
1297 .. cpp:type:: const s4u_Host* const_sg_host_t
1299 Pointer to a constant host object.
1308 See also :cpp:func:`simgrid::s4u::Engine::get_all_hosts`.
1310 .. doxygenfunction:: simgrid::s4u::Host::by_name(const std::string &name)
1311 .. doxygenfunction:: simgrid::s4u::Host::by_name_or_null(const std::string &name)
1312 .. doxygenfunction:: simgrid::s4u::Host::current()
1314 .. group-tab:: Python
1316 See also :py:attr:`simgrid.Engine.all_hosts`.
1318 .. automethod:: simgrid.Host.by_name
1319 .. automethod:: simgrid.Host.current
1323 .. doxygenfunction:: sg_host_by_name(const char *name)
1324 .. doxygenfunction:: sg_host_count()
1325 .. doxygenfunction:: sg_host_list()
1327 Modifying characteristics
1328 -------------------------
1334 .. doxygenfunction:: simgrid::s4u::Host::set_core_count(int core_count)
1335 .. doxygenfunction:: simgrid::s4u::Host::set_coordinates(const std::string& coords)
1336 .. doxygenfunction:: simgrid::s4u::Host::set_sharing_policy
1338 .. group-tab:: Python
1340 .. autoattribute:: simgrid.Host.core_count
1342 .. automethod:: simgrid.Host.set_coordinates
1343 .. automethod:: simgrid.Host.set_sharing_policy
1352 .. doxygenfunction:: simgrid::s4u::Host::get_cname() const
1353 .. doxygenfunction:: simgrid::s4u::Host::get_core_count() const
1354 .. doxygenfunction:: simgrid::s4u::Host::get_name() const
1355 .. doxygenfunction:: simgrid::s4u::Host::get_available_speed() const
1356 .. doxygenfunction:: simgrid::s4u::Host::get_load() const
1357 .. doxygenfunction:: simgrid::s4u::Host::get_speed() const
1359 .. group-tab:: Python
1361 .. autoattribute:: simgrid.Host.name
1362 .. autoattribute:: simgrid.Host.core_count
1363 .. autoattribute:: simgrid.Host.load
1364 .. autoattribute:: simgrid.Host.speed
1365 .. autoattribute:: simgrid.Host.available_speed
1369 .. doxygenfunction:: sg_host_core_count(const_sg_host_t host)
1370 .. doxygenfunction:: sg_host_get_name(const_sg_host_t host)
1371 .. doxygenfunction:: sg_host_get_load(const_sg_host_t host)
1372 .. doxygenfunction:: sg_host_get_speed(const_sg_host_t host)
1374 User data and properties
1375 ------------------------
1381 .. doxygenfunction:: simgrid::s4u::Host::get_properties() const
1382 .. doxygenfunction:: simgrid::s4u::Host::get_property(const std::string &key) const
1383 .. doxygenfunction:: simgrid::s4u::Host::set_properties(const std::unordered_map< std::string, std::string > &properties)
1384 .. doxygenfunction:: simgrid::s4u::Host::set_property(const std::string &key, const std::string &value)
1388 .. doxygenfunction:: sg_host_set_property_value(sg_host_t host, const char *name, const char *value)
1389 .. doxygenfunction:: sg_host_get_properties(const_sg_host_t host)
1390 .. doxygenfunction:: sg_host_get_property_value(const_sg_host_t host, const char *name)
1391 .. doxygenfunction:: sg_host_extension_create(void(*deleter)(void *))
1392 .. doxygenfunction:: sg_host_extension_get(const_sg_host_t host, size_t rank)
1394 Retrieving components
1395 ---------------------
1401 .. doxygenfunction:: simgrid::s4u::Host::add_disk(const Disk *disk)
1402 .. doxygenfunction:: simgrid::s4u::Host::get_actor_count() const
1403 .. doxygenfunction:: simgrid::s4u::Host::get_all_actors() const
1404 .. doxygenfunction:: simgrid::s4u::Host::get_disks() const
1405 .. doxygenfunction:: simgrid::s4u::Host::remove_disk(const std::string &disk_name)
1407 .. group-tab:: Python
1409 .. automethod:: simgrid.Host.get_disks
1413 .. doxygenfunction:: sg_host_get_actor_list(const_sg_host_t host, xbt_dynar_t whereto)
1422 .. doxygenfunction:: simgrid::s4u::Host::is_on() const
1423 .. doxygenfunction:: simgrid::s4u::Host::turn_off()
1424 .. doxygenfunction:: simgrid::s4u::Host::turn_on()
1428 .. doxygenfunction:: sg_host_is_on(const_sg_host_t host)
1429 .. doxygenfunction:: sg_host_turn_off(sg_host_t host)
1430 .. doxygenfunction:: sg_host_turn_on(sg_host_t host)
1432 .. _API_s4u_Host_dvfs:
1437 See also the :ref:`relevant examples <s4u_ex_dvfs>`.
1443 .. doxygenfunction:: simgrid::s4u::Host::get_pstate() const
1444 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_count() const
1445 .. doxygenfunction:: simgrid::s4u::Host::get_pstate_speed(unsigned long pstate_index) const
1446 .. doxygenfunction:: simgrid::s4u::Host::set_pstate(unsigned long pstate_index)
1448 .. group-tab:: Python
1450 .. autoattribute:: simgrid.Host.pstate
1451 .. autoattribute:: simgrid.Host.pstate_count
1452 .. automethod:: simgrid.Host.pstate_speed
1456 .. doxygenfunction:: sg_host_get_available_speed(const_sg_host_t host)
1457 .. doxygenfunction:: sg_host_get_nb_pstates(const_sg_host_t host)
1458 .. doxygenfunction:: sg_host_get_pstate(const_sg_host_t host)
1459 .. doxygenfunction:: sg_host_get_pstate_speed(const_sg_host_t host, unsigned long pstate_index)
1460 .. doxygenfunction:: sg_host_set_pstate(sg_host_t host, unsigned long pstate)
1469 .. doxygenfunction:: simgrid::s4u::Host::set_speed_profile(kernel::profile::Profile *p)
1470 .. doxygenfunction:: simgrid::s4u::Host::set_state_profile(kernel::profile::Profile *p)
1472 .. group-tab:: Python
1474 .. automethod:: simgrid.Host.set_speed_profile
1475 .. automethod:: simgrid.Host.set_state_profile
1484 .. doxygenfunction:: simgrid::s4u::Host::exec_async
1485 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops) const
1486 .. doxygenfunction:: simgrid::s4u::Host::execute(double flops, double priority) const
1488 Platform and routing
1489 --------------------
1491 You can also start direct communications between two arbitrary hosts
1492 using :cpp:func:`Comm::sendto() <simgrid::s4u::Comm::sendto()>`.
1498 .. doxygenfunction:: simgrid::s4u::Host::get_englobing_zone() const
1499 .. doxygenfunction:: simgrid::s4u::Host::get_netpoint() const
1500 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< Link * > &links, double *latency) const
1501 .. doxygenfunction:: simgrid::s4u::Host::route_to(const Host *dest, std::vector< kernel::resource::StandardLinkImpl * > &links, double *latency) const
1502 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
1503 .. doxygenfunction:: simgrid::s4u::Host::create_disk(const std::string& name, const std::string& read_bandwidth, const std::string& write_bandwidth)
1505 .. group-tab:: Python
1507 .. autoattribute:: simgrid.Host.netpoint
1508 .. automethod:: simgrid.Host.create_disk
1510 .. automethod:: simgrid.Host.route_to
1514 .. doxygenfunction:: sg_host_get_route(const_sg_host_t from, const_sg_host_t to, xbt_dynar_t links)
1515 .. doxygenfunction:: sg_host_get_route_bandwidth(const_sg_host_t from, const_sg_host_t to)
1516 .. doxygenfunction:: sg_host_get_route_latency(const_sg_host_t from, const_sg_host_t to)
1517 .. doxygenfunction:: sg_host_sendto(sg_host_t from, sg_host_t to, double byte_amount)
1526 .. doxygenfunction:: simgrid::s4u::Host::on_creation_cb
1527 .. doxygenfunction:: simgrid::s4u::Host::on_destruction_cb
1528 .. doxygenfunction:: simgrid::s4u::Host::on_this_destruction_cb
1529 .. doxygenfunction:: simgrid::s4u::Host::on_speed_change_cb
1530 .. doxygenfunction:: simgrid::s4u::Host::on_this_speed_change_cb
1531 .. doxygenfunction:: simgrid::s4u::Host::on_onoff_cb
1532 .. doxygenfunction:: simgrid::s4u::Host::on_this_onoff_cb
1533 .. doxygenfunction:: simgrid::s4u::Host::on_exec_state_change_cb
1545 .. doxygenclass:: simgrid::s4u::Link
1546 .. doxygenclass:: simgrid::s4u::SplitDuplexLink
1547 .. doxygenclass:: simgrid::s4u::LinkInRoute
1550 .. group-tab:: Python
1552 .. autoclass:: simgrid.Link
1563 #include <simgrid/s4u/Link.hpp>
1565 Note that there is no LinkPtr type and that you cannot use the RAII
1566 idiom on hosts because SimGrid does not allow (yet) to create nor
1567 destroy resources once the simulation is started.
1569 .. doxygenfunction:: simgrid::s4u::Link::seal()
1571 .. group-tab:: Python
1575 from simgrid import Link
1577 .. automethod:: simgrid.Link.seal
1583 #include <simgrid/link.h>
1585 .. doxygentypedef:: sg_link_t
1586 .. doxygentypedef:: const_sg_link_t
1595 See also :cpp:func:`simgrid::s4u::Engine::get_all_links`.
1597 .. doxygenfunction:: simgrid::s4u::Link::by_name(const std::string &name)
1598 .. doxygenfunction:: simgrid::s4u::Link::by_name_or_null(const std::string &name)
1600 .. group-tab:: Python
1602 See also :py:attr:`simgrid.Engine.all_links`.
1604 .. automethod:: simgrid.Link.by_name
1605 .. autoattribute:: simgrid.Link.name
1609 .. doxygenfunction:: sg_link_by_name(const char *name)
1610 .. doxygenfunction:: sg_link_count()
1611 .. doxygenfunction:: sg_link_list()
1620 .. doxygenfunction:: simgrid::s4u::Link::get_cname() const
1621 .. doxygenfunction:: simgrid::s4u::Link::get_name() const
1622 .. doxygenfunction:: simgrid::s4u::Link::get_load() const
1623 .. doxygenfunction:: simgrid::s4u::Link::is_used() const
1625 .. group-tab:: Python
1627 .. autoattribute:: simgrid.Link.name
1631 .. doxygenfunction:: sg_link_get_name(const_sg_link_t link)
1632 .. doxygenfunction:: sg_link_is_shared(const_sg_link_t link)
1641 .. doxygenfunction:: simgrid::s4u::Link::get_bandwidth() const
1642 .. doxygenfunction:: simgrid::s4u::Link::get_latency() const
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)
1647 .. group-tab:: Python
1649 .. autoattribute:: simgrid.Link.bandwidth
1650 .. autoattribute:: simgrid.Link.latency
1651 .. automethod:: simgrid.Link.set_bandwidth
1652 .. automethod:: simgrid.Link.set_latency
1656 .. doxygenfunction:: sg_link_get_bandwidth(const_sg_link_t link)
1657 .. doxygenfunction:: sg_link_get_latency(const_sg_link_t link)
1658 .. doxygenfunction:: sg_link_set_bandwidth(sg_link_t link, double value)
1659 .. doxygenfunction:: sg_link_set_latency(sg_link_t link, double value)
1668 .. doxygenenum:: simgrid::s4u::Link::SharingPolicy
1670 .. doxygenfunction:: simgrid::s4u::Link::get_sharing_policy() const
1671 .. doxygenfunction:: simgrid::s4u::Link::set_sharing_policy
1673 .. doxygenfunction:: simgrid::s4u::Link::get_concurrency_limit() const
1674 .. doxygenfunction:: simgrid::s4u::Link::set_concurrency_limit(int limit)
1676 .. group-tab:: Python
1678 .. automethod:: simgrid.Link.set_concurrency_limit
1679 .. automethod:: simgrid.Link.set_sharing_policy
1684 User data and properties
1685 ------------------------
1691 .. doxygenfunction:: simgrid::s4u::Link::get_property(const std::string &key) const
1692 .. doxygenfunction:: simgrid::s4u::Link::set_property(const std::string &key, const std::string &value)
1696 .. doxygenfunction:: sg_link_get_data(const_sg_link_t link)
1697 .. doxygenfunction:: sg_link_set_data(sg_link_t link, void *data)
1706 See also :cpp:func:`simgrid::s4u::Link::set_state_profile`.
1708 .. doxygenfunction:: simgrid::s4u::Link::is_on() const
1709 .. doxygenfunction:: simgrid::s4u::Link::turn_off()
1710 .. doxygenfunction:: simgrid::s4u::Link::turn_on()
1712 .. group-tab:: Python
1714 See also :py:func:`simgrid.Link.set_state_profile`.
1716 .. automethod:: simgrid.Link.is_on
1717 .. automethod:: simgrid.Link.turn_off
1718 .. automethod:: simgrid.Link.turn_on
1723 See :ref:`howto_churn` for more details.
1729 .. doxygenfunction:: simgrid::s4u::Link::set_bandwidth_profile(kernel::profile::Profile *profile)
1730 .. doxygenfunction:: simgrid::s4u::Link::set_latency_profile(kernel::profile::Profile *profile)
1731 .. doxygenfunction:: simgrid::s4u::Link::set_state_profile(kernel::profile::Profile *profile)
1733 .. group-tab:: Python
1735 .. automethod:: simgrid.Link.set_bandwidth_profile
1736 .. automethod:: simgrid.Link.set_latency_profile
1737 .. automethod:: simgrid.Link.set_state_profile
1746 .. doxygenfunction:: simgrid::s4u::Link::set_host_wifi_rate
1748 .. group-tab:: Python
1750 .. automethod:: simgrid.Link.set_host_wifi_rate
1759 .. doxygenfunction:: simgrid::s4u::Link::on_bandwidth_change_cb
1760 .. doxygenfunction:: simgrid::s4u::Link::on_this_bandwidth_change_cb
1761 .. doxygenfunction:: simgrid::s4u::Link::on_communication_state_change_cb
1762 .. doxygenfunction:: simgrid::s4u::Link::on_creation_cb
1763 .. doxygenfunction:: simgrid::s4u::Link::on_destruction_cb
1764 .. doxygenfunction:: simgrid::s4u::Link::on_this_destruction_cb
1765 .. doxygenfunction:: simgrid::s4u::Link::on_onoff_cb
1766 .. doxygenfunction:: simgrid::s4u::Link::on_this_onoff_cb
1768 .. _API_s4u_NetZone:
1778 .. doxygenclass:: simgrid::s4u::NetZone
1780 .. group-tab:: Python
1782 .. autoclass:: simgrid.NetZone
1793 #include <simgrid/s4u/NetZone.hpp>
1795 Note that there is no NetZonePtr type and that you cannot use the RAII
1796 idiom on network zones because SimGrid does not allow (yet) to create nor
1797 destroy resources once the simulation is started.
1799 .. doxygenfunction:: simgrid::s4u::NetZone::seal
1801 .. group-tab:: Python
1805 from simgrid import NetZone
1807 .. automethod:: simgrid.NetZone.seal
1813 #include <simgrid/zone.h>
1815 .. doxygentypedef:: sg_netzone_t
1816 .. cpp:type:: const s4u_NetZone* const_sg_netzone_t
1818 Pointer to a constant network zone object.
1827 See :cpp:func:`simgrid::s4u::Engine::get_netzone_root`,
1828 :cpp:func:`simgrid::s4u::Engine::netzone_by_name_or_null` and
1829 :cpp:func:`simgrid::s4u::Engine::get_filtered_netzones`.
1833 .. doxygenfunction:: sg_zone_get_by_name(const char *name)
1834 .. doxygenfunction:: sg_zone_get_root()
1843 .. doxygenfunction:: simgrid::s4u::NetZone::get_cname() const
1844 .. doxygenfunction:: simgrid::s4u::NetZone::get_name() const
1845 .. doxygenfunction:: simgrid::s4u::NetZone::get_netpoint
1847 .. group-tab:: Python
1849 .. autoattribute:: simgrid.NetZone.name
1850 .. autoattribute:: simgrid.NetZone.netpoint
1854 .. doxygenfunction:: sg_zone_get_name(const_sg_netzone_t zone)
1856 User data and properties
1857 ------------------------
1863 .. doxygenfunction:: simgrid::s4u::NetZone::get_properties() const
1864 .. doxygenfunction:: simgrid::s4u::NetZone::get_property(const std::string &key) const
1865 .. doxygenfunction:: simgrid::s4u::NetZone::set_property(const std::string &key, const std::string &value)
1867 .. group-tab:: Python
1869 .. automethod:: simgrid.NetZone.set_property
1873 .. doxygenfunction:: sg_zone_get_property_value(const_sg_netzone_t as, const char *name)
1874 .. doxygenfunction:: sg_zone_set_property_value(sg_netzone_t netzone, const char *name, const char *value)
1876 Retrieving components
1877 ---------------------
1883 .. doxygenfunction:: simgrid::s4u::NetZone::get_all_hosts() const
1884 .. doxygenfunction:: simgrid::s4u::NetZone::get_host_count() const
1888 .. doxygenfunction:: sg_zone_get_hosts(const_sg_netzone_t zone, xbt_dynar_t whereto)
1897 .. doxygenfunction:: simgrid::s4u::NetZone::add_component(kernel::routing::NetPoint *elm)
1898 .. doxygenfunction:: simgrid::s4u::NetZone::add_route(const Host *src, const Host *dst, const std::vector< LinkInRoute > &link_list, bool symmetrical=true)
1899 .. doxygenfunction:: simgrid::s4u::NetZone::add_route(const Host *src, const Host *dst, const std::vector< const Link * > &links)
1900 .. doxygenfunction:: simgrid::s4u::NetZone::add_route(const NetZone *src, const NetZone *dst, const std::vector< LinkInRoute > &link_list, bool symmetrical=true)
1901 .. doxygenfunction:: simgrid::s4u::NetZone::add_route(const NetZone *src, const NetZone *dst, const std::vector< const Link * > &links)
1902 .. doxygenfunction:: simgrid::s4u::NetZone::get_children() const
1903 .. doxygenfunction:: simgrid::s4u::NetZone::get_parent() const
1904 .. doxygenfunction:: simgrid::s4u::NetZone::set_parent(const NetZone* parent)
1906 .. group-tab:: Python
1908 .. automethod:: simgrid.NetZone.add_route
1909 .. automethod:: simgrid.NetZone.set_parent
1913 .. doxygenfunction:: sg_zone_get_sons(const_sg_netzone_t zone, xbt_dict_t whereto)
1922 .. doxygenfunction:: simgrid::s4u::NetZone::on_creation_cb
1923 .. doxygenfunction:: simgrid::s4u::NetZone::on_seal_cb
1934 .. doxygenfunction:: simgrid::s4u::create_full_zone
1935 .. doxygenfunction:: simgrid::s4u::create_empty_zone
1936 .. doxygenfunction:: simgrid::s4u::create_star_zone
1937 .. doxygenfunction:: simgrid::s4u::create_dijkstra_zone
1938 .. doxygenfunction:: simgrid::s4u::create_floyd_zone
1939 .. doxygenfunction:: simgrid::s4u::create_vivaldi_zone
1940 .. doxygenfunction:: simgrid::s4u::create_wifi_zone
1941 .. doxygenfunction:: simgrid::s4u::create_torus_zone
1942 .. doxygenfunction:: simgrid::s4u::create_fatTree_zone
1943 .. doxygenfunction:: simgrid::s4u::create_dragonfly_zone
1945 .. group-tab:: Python
1947 .. automethod:: simgrid.NetZone.create_full_zone
1948 .. automethod:: simgrid.NetZone.create_empty_zone
1949 .. automethod:: simgrid.NetZone.create_star_zone
1950 .. automethod:: simgrid.NetZone.create_dijkstra_zone
1951 .. automethod:: simgrid.NetZone.create_floyd_zone
1952 .. automethod:: simgrid.NetZone.create_vivaldi_zone
1953 .. automethod:: simgrid.NetZone.create_wifi_zone
1954 .. automethod:: simgrid.NetZone.create_torus_zone
1955 .. automethod:: simgrid.NetZone.create_fatTree_zone
1956 .. automethod:: simgrid.NetZone.create_dragonfly_zone
1965 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<double>& speed_per_pstate)
1966 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, double speed)
1967 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::vector<std::string>& speed_per_pstate)
1968 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string& name, const std::string& speed)
1969 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string &name, const std::string &speed)
1970 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string &name, const std::vector< double > &speed_per_pstate)
1971 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string &name, const std::vector< std::string > &speed_per_pstate)
1972 .. doxygenfunction:: simgrid::s4u::NetZone::create_host(const std::string &name, double speed)
1974 .. group-tab:: Python
1976 .. automethod:: simgrid.NetZone.create_host
1985 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string &name, const std::vector< double > &bandwidths)
1986 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string &name, double bandwidth)
1987 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string &name, const std::vector< std::string > &bandwidths)
1988 .. doxygenfunction:: simgrid::s4u::NetZone::create_link(const std::string &name, const std::string &bandwidth)
1989 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string &name, const std::string &bandwidth)
1990 .. doxygenfunction:: simgrid::s4u::NetZone::create_split_duplex_link(const std::string &name, double bandwidth)
1992 .. group-tab:: Python
1994 .. automethod:: simgrid.NetZone.create_link
1995 .. automethod:: simgrid.NetZone.create_split_duplex_link
2004 .. doxygenfunction:: simgrid::s4u::NetZone::create_router(const std::string& name)
2006 .. group-tab:: Python
2008 .. automethod:: simgrid.NetZone.create_router
2010 .. _API_s4u_VirtualMachine:
2012 =======================
2013 class VirtualMachine
2014 =======================
2017 .. doxygenclass:: simgrid::s4u::VirtualMachine
2027 #include <simgrid/s4u/VirtualMachine.hpp>
2029 Note that there is no VirtualMachinePtr type, and that you cannot use the RAII
2030 idiom on virtual machines. There is no good reason for that and should change in the future.
2036 #include <simgrid/vm.h>
2038 .. doxygentypedef:: sg_vm_t
2039 .. cpp:type:: const s4u_VirtualMachine* const_sg_vm_t
2041 Pointer to a constant virtual machine object.
2050 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount)
2051 .. doxygenfunction:: simgrid::s4u::Host::create_vm(const std::string &name, int core_amount, size_t ramsize)
2052 .. doxygenfunction:: simgrid::s4u::VirtualMachine::destroy
2056 .. doxygenfunction:: sg_vm_create_core
2057 .. doxygenfunction:: sg_vm_create_multicore
2058 .. doxygenfunction:: sg_vm_destroy
2067 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_pm() const
2068 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_ramsize() const
2069 .. doxygenfunction:: simgrid::s4u::VirtualMachine::get_state() const
2071 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_bound(double bound)
2072 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_pm(Host *pm)
2073 .. doxygenfunction:: simgrid::s4u::VirtualMachine::set_ramsize(size_t ramsize)
2077 .. doxygenfunction:: sg_vm_get_ramsize(const_sg_vm_t vm)
2078 .. doxygenfunction:: sg_vm_set_bound(sg_vm_t vm, double bound)
2079 .. doxygenfunction:: sg_vm_set_ramsize(sg_vm_t vm, size_t size)
2081 .. doxygenfunction:: sg_vm_get_name
2082 .. doxygenfunction:: sg_vm_get_pm
2083 .. doxygenfunction:: sg_vm_is_created
2084 .. doxygenfunction:: sg_vm_is_running
2085 .. doxygenfunction:: sg_vm_is_suspended
2094 .. doxygenfunction:: simgrid::s4u::VirtualMachine::resume()
2095 .. doxygenfunction:: simgrid::s4u::VirtualMachine::shutdown()
2096 .. doxygenfunction:: simgrid::s4u::VirtualMachine::start()
2097 .. doxygenfunction:: simgrid::s4u::VirtualMachine::suspend()
2101 .. doxygenfunction:: sg_vm_start
2102 .. doxygenfunction:: sg_vm_suspend
2103 .. doxygenfunction:: sg_vm_resume
2104 .. doxygenfunction:: sg_vm_shutdown
2113 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_creation_cb
2114 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_destruction_cb
2115 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_destruction_cb
2116 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_end_cb
2117 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_end_cb
2118 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_migration_start_cb
2119 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_migration_start_cb
2120 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_resume_cb
2121 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_resume_cb
2122 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_shutdown_cb
2123 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_shutdown_cb
2124 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_start_cb
2125 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_start_cb
2126 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_started_cb
2127 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_started_cb
2128 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_suspend_cb
2129 .. doxygenfunction:: simgrid::s4u::VirtualMachine::on_this_suspend_cb
2131 .. _API_s4u_Activity:
2141 .. doxygenclass:: simgrid::s4u::Activity
2143 **Known subclasses:**
2144 :ref:`Communications <API_s4u_Comm>` (started on Mailboxes and consuming links),
2145 :ref:`Executions <API_s4u_Exec>` (started on Host and consuming CPU resources)
2146 :ref:`I/O <API_s4u_Io>` (started on and consuming disks).
2147 See also the :ref:`section on activities <s4u_Activities>` above.
2158 #include <simgrid/s4u/Activity.hpp>
2160 .. doxygentypedef:: ActivityPtr
2164 .. doxygentypedef:: sg_activity_t
2165 .. doxygentypedef:: const_sg_activity_t
2174 .. doxygenfunction:: simgrid::s4u::Activity::get_cname() const
2175 .. doxygenfunction:: simgrid::s4u::Activity::get_name() const
2176 .. doxygenfunction:: simgrid::s4u::Activity::get_remaining() const
2177 .. doxygenfunction:: simgrid::s4u::Activity::get_state() const
2178 .. doxygenfunction:: simgrid::s4u::Activity::set_remaining(double remains)
2179 .. doxygenfunction:: simgrid::s4u::Activity::set_state(Activity::State state)
2182 Activities life cycle
2183 ---------------------
2189 .. doxygenfunction:: simgrid::s4u::Activity::start
2190 .. doxygenfunction:: simgrid::s4u::Activity::cancel
2191 .. doxygenfunction:: simgrid::s4u::Activity::test
2192 .. doxygenfunction:: simgrid::s4u::Activity::wait
2193 .. doxygenfunction:: simgrid::s4u::Activity::wait_for
2194 .. doxygenfunction:: simgrid::s4u::Activity::wait_until(double time_limit)
2196 Suspending and resuming an activity
2197 -----------------------------------
2203 .. doxygenfunction:: simgrid::s4u::Activity::suspend
2204 .. doxygenfunction:: simgrid::s4u::Activity::resume
2205 .. doxygenfunction:: simgrid::s4u::Activity::is_suspended
2217 .. doxygenclass:: simgrid::s4u::Comm
2219 .. group-tab:: Python
2221 .. autoclass:: simgrid.Comm
2232 #include <simgrid/s4u/Comm.hpp>
2234 .. doxygentypedef:: CommPtr
2236 .. group-tab:: Python
2240 from simgrid import Comm
2246 #include <simgrid/comm.h>
2248 .. doxygentypedef:: sg_comm_t
2257 .. doxygenfunction:: simgrid::s4u::Comm::get_dst_data_size() const
2258 .. doxygenfunction:: simgrid::s4u::Comm::get_mailbox() const
2259 .. doxygenfunction:: simgrid::s4u::Comm::get_sender() const
2260 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff)
2261 .. doxygenfunction:: simgrid::s4u::Comm::set_dst_data(void **buff, size_t size)
2262 .. doxygenfunction:: simgrid::s4u::Comm::detach()
2263 .. doxygenfunction:: simgrid::s4u::Comm::detach(const std::function<void(void*)>& clean_function)
2264 .. doxygenfunction:: simgrid::s4u::Comm::set_payload_size(uint64_t bytes)
2265 .. doxygenfunction:: simgrid::s4u::Comm::set_rate(double rate)
2266 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff)
2267 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data(void *buff, size_t size)
2268 .. doxygenfunction:: simgrid::s4u::Comm::set_src_data_size(size_t size)
2270 .. group-tab:: Python
2272 .. autoattribute:: simgrid.Comm.dst_data_size
2273 .. autoattribute:: simgrid.Comm.mailbox
2274 .. autoattribute:: simgrid.Comm.sender
2275 .. autoattribute:: simgrid.Comm.state_str
2276 .. automethod:: simgrid.Comm.detach
2277 .. automethod:: simgrid.Comm.set_payload_size
2278 .. automethod:: simgrid.Comm.set_rate
2280 Direct host-to-host communication
2281 ---------------------------------
2283 Most communications are created using :ref:`s4u_mailbox`, but you can
2284 also start direct communications as shown below. See also the
2285 :ref:`relevant examples <s4u_ex_comm_host2host>`.
2291 .. doxygenfunction:: simgrid::s4u::Comm::sendto
2292 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init()
2293 .. doxygenfunction:: simgrid::s4u::Comm::sendto_init(Host *from, Host *to)
2294 .. doxygenfunction:: simgrid::s4u::Comm::sendto_async
2296 .. group-tab:: Python
2298 .. automethod:: simgrid.Comm.sendto
2299 .. automethod:: simgrid.Comm.sendto_init
2300 .. automethod:: simgrid.Comm.sendto_async
2309 .. doxygenfunction:: simgrid::s4u::Comm::cancel
2310 .. doxygenfunction:: simgrid::s4u::Comm::start
2311 .. doxygenfunction:: simgrid::s4u::Comm::test
2312 .. doxygenfunction:: simgrid::s4u::Comm::wait
2313 .. doxygenfunction:: simgrid::s4u::Comm::wait_for
2314 .. doxygenfunction:: simgrid::s4u::Comm::wait_until
2316 .. group-tab:: Python
2318 .. automethod:: simgrid.Comm.cancel
2319 .. automethod:: simgrid.Comm.start
2320 .. automethod:: simgrid.Comm.test
2321 .. automethod:: simgrid.Comm.wait
2322 .. automethod:: simgrid.Comm.wait_for
2323 .. automethod:: simgrid.Comm.wait_until
2327 .. doxygenfunction:: sg_comm_test
2328 .. doxygenfunction:: sg_comm_wait
2330 Suspending and resuming a communication
2331 ---------------------------------------
2337 .. doxygenfunction:: simgrid::s4u::Comm::suspend
2338 .. doxygenfunction:: simgrid::s4u::Comm::resume
2339 .. doxygenfunction:: simgrid::s4u::Comm::is_suspended
2341 .. group-tab:: Python
2343 .. automethod:: simgrid.Comm.suspend
2344 .. automethod:: simgrid.Comm.resume
2345 .. autoattribute:: simgrid.Comm.is_suspended
2354 .. doxygenfunction:: simgrid::s4u::Comm::on_completion_cb
2355 .. doxygenfunction:: simgrid::s4u::Comm::on_start_cb
2356 .. doxygenfunction:: simgrid::s4u::Comm::on_recv_cb
2357 .. doxygenfunction:: simgrid::s4u::Comm::on_send_cb
2358 .. doxygenfunction:: simgrid::s4u::Comm::on_suspended_cb
2359 .. doxygenfunction:: simgrid::s4u::Comm::on_suspend_cb
2360 .. doxygenfunction:: simgrid::s4u::Comm::on_resume_cb
2361 .. doxygenfunction:: simgrid::s4u::Comm::on_resumed_cb
2362 .. doxygenfunction:: simgrid::s4u::Comm::on_veto_cb
2363 .. doxygenfunction:: simgrid::s4u::Comm::on_this_completion_cb
2364 .. doxygenfunction:: simgrid::s4u::Comm::on_this_recv_cb
2365 .. doxygenfunction:: simgrid::s4u::Comm::on_this_resume_cb
2366 .. doxygenfunction:: simgrid::s4u::Comm::on_this_send_cb
2367 .. doxygenfunction:: simgrid::s4u::Comm::on_this_start_cb
2368 .. doxygenfunction:: simgrid::s4u::Comm::on_this_suspended_cb
2369 .. doxygenfunction:: simgrid::s4u::Comm::on_this_veto_cb
2381 .. doxygenclass:: simgrid::s4u::Exec
2383 .. group-tab:: Python
2385 .. autoclass:: simgrid.Exec
2389 .. doxygentypedef:: sg_exec_t
2390 .. doxygentypedef:: const_sg_exec_t
2401 #include <simgrid/s4u/Exec.hpp>
2403 .. doxygentypedef:: ExecPtr
2405 .. group-tab:: Python
2409 from simgrid import Exec
2415 #include <simgrid/exec.h>
2424 .. doxygenfunction:: simgrid::s4u::Exec::get_cost() const
2425 .. doxygenfunction:: simgrid::s4u::Exec::get_finish_time() const
2426 .. doxygenfunction:: simgrid::s4u::Exec::get_host() const
2427 .. doxygenfunction:: simgrid::s4u::Exec::get_host_number() const
2428 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining
2429 .. doxygenfunction:: simgrid::s4u::Exec::get_remaining_ratio
2430 .. doxygenfunction:: simgrid::s4u::Exec::get_start_time() const
2431 .. doxygenfunction:: simgrid::s4u::Exec::set_bound(double bound)
2432 .. doxygenfunction:: simgrid::s4u::Exec::set_host
2433 .. doxygenfunction:: simgrid::s4u::Exec::set_priority(double priority)
2435 .. group-tab:: Python
2437 .. autoattribute:: simgrid.Exec.host
2438 .. autoattribute:: simgrid.Exec.remaining
2439 .. autoattribute:: simgrid.Exec.remaining_ratio
2443 .. doxygenfunction:: sg_exec_set_bound(sg_exec_t exec, double bound)
2444 .. doxygenfunction:: sg_exec_get_name(const_sg_exec_t exec)
2445 .. doxygenfunction:: sg_exec_set_name(sg_exec_t exec, const char* name)
2446 .. doxygenfunction:: sg_exec_set_host(sg_exec_t exec, sg_host_t new_host)
2447 .. doxygenfunction:: sg_exec_get_remaining(const_sg_exec_t exec)
2448 .. doxygenfunction:: sg_exec_get_remaining_ratio(const_sg_exec_t exec)
2457 .. doxygenfunction:: simgrid::s4u::Exec::cancel
2458 .. doxygenfunction:: simgrid::s4u::Exec::start
2459 .. doxygenfunction:: simgrid::s4u::Exec::test
2460 .. doxygenfunction:: simgrid::s4u::Exec::wait
2462 .. group-tab:: Python
2464 .. automethod:: simgrid.Exec.cancel
2465 .. automethod:: simgrid.Exec.start
2466 .. automethod:: simgrid.Exec.test
2467 .. automethod:: simgrid.Exec.wait
2471 .. doxygenfunction:: sg_exec_start(sg_exec_t exec)
2472 .. doxygenfunction:: sg_exec_cancel(sg_exec_t exec);
2473 .. doxygenfunction:: sg_exec_test(sg_exec_t exec);
2474 .. doxygenfunction:: sg_exec_wait(sg_exec_t exec);
2476 Suspending and resuming an execution
2477 ------------------------------------
2483 .. doxygenfunction:: simgrid::s4u::Exec::suspend
2484 .. doxygenfunction:: simgrid::s4u::Exec::resume
2485 .. doxygenfunction:: simgrid::s4u::Exec::is_suspended
2487 .. group-tab:: Python
2489 .. automethod:: simgrid.Exec.suspend
2490 .. automethod:: simgrid.Exec.resume
2491 .. autoattribute:: simgrid.Exec.is_suspended
2500 .. doxygenfunction:: simgrid::s4u::Exec::on_start_cb
2501 .. doxygenfunction:: simgrid::s4u::Exec::on_this_start_cb
2502 .. doxygenfunction:: simgrid::s4u::Exec::on_completion_cb
2503 .. doxygenfunction:: simgrid::s4u::Exec::on_this_completion_cb
2505 .. doxygenfunction:: simgrid::s4u::Exec::on_suspended_cb
2506 .. doxygenfunction:: simgrid::s4u::Exec::on_resumed_cb
2507 .. doxygenfunction:: simgrid::s4u::Exec::on_veto_cb
2508 .. doxygenfunction:: simgrid::s4u::Exec::on_this_veto_cb
2520 .. doxygenclass:: simgrid::s4u::Io
2522 .. group-tab:: Python
2524 .. autoclass:: simgrid.Io
2535 #include <simgrid/s4u/Io.hpp>
2537 .. doxygentypedef:: IoPtr
2546 .. doxygenfunction:: simgrid::s4u::Io::get_performed_ioops() const
2547 .. doxygenfunction:: simgrid::s4u::Io::get_remaining
2556 .. doxygenfunction:: simgrid::s4u::Io::cancel
2557 .. doxygenfunction:: simgrid::s4u::Io::start
2558 .. doxygenfunction:: simgrid::s4u::Io::test
2559 .. doxygenfunction:: simgrid::s4u::Io::wait
2561 .. group-tab:: Python
2563 .. automethod:: simgrid.Io.test
2564 .. automethod:: simgrid.Io.wait
2573 .. doxygenfunction:: simgrid::s4u::Io::on_start_cb
2574 .. doxygenfunction:: simgrid::s4u::Io::on_this_start_cb
2575 .. doxygenfunction:: simgrid::s4u::Io::on_completion_cb
2576 .. doxygenfunction:: simgrid::s4u::Io::on_this_completion_cb
2578 .. doxygenfunction:: simgrid::s4u::Io::on_suspended_cb
2579 .. doxygenfunction:: simgrid::s4u::Io::on_resumed_cb
2580 .. doxygenfunction:: simgrid::s4u::Io::on_veto_cb
2581 .. doxygenfunction:: simgrid::s4u::Io::on_this_veto_cb
2583 .. _API_s4u_ActivitySet:
2585 ====================
2587 ====================
2593 .. doxygenclass:: simgrid::s4u::ActivitySet
2595 .. group-tab:: Python
2597 .. autoclass:: simgrid.ActivitySet
2601 .. doxygentypedef:: sg_activity_set_t
2602 .. doxygentypedef:: const_sg_activity_set_t
2613 #include <simgrid/s4u/ActivitySet.hpp>
2615 .. doxygentypedef:: ActivitySetPtr
2617 .. group-tab:: Python
2621 from simgrid import ActivitySet
2627 #include <simgrid/activity_set.h>
2629 .. doxygenfunction:: sg_activity_set_init
2630 .. doxygenfunction:: sg_activity_set_delete
2639 .. doxygenfunction:: simgrid::s4u::ActivitySet::push
2640 .. doxygenfunction:: simgrid::s4u::ActivitySet::erase
2641 .. doxygenfunction:: simgrid::s4u::ActivitySet::empty
2642 .. doxygenfunction:: simgrid::s4u::ActivitySet::size
2644 .. group-tab:: Python
2646 .. automethod:: simgrid.ActivitySet.push()
2647 .. automethod:: simgrid.ActivitySet.erase()
2648 .. automethod:: simgrid.ActivitySet.empty()
2649 .. automethod:: simgrid.ActivitySet.size()
2653 .. doxygenfunction:: sg_activity_set_push
2654 .. doxygenfunction:: sg_activity_set_erase
2655 .. doxygenfunction:: sg_activity_set_empty
2656 .. doxygenfunction:: sg_activity_set_size
2658 Interacting with the set
2659 ------------------------
2665 .. doxygenfunction:: simgrid::s4u::ActivitySet::test_any
2666 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_all
2667 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_all_for
2668 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_any
2669 .. doxygenfunction:: simgrid::s4u::ActivitySet::wait_any_for
2671 .. group-tab:: Python
2673 .. automethod:: simgrid.ActivitySet.test_any()
2674 .. automethod:: simgrid.ActivitySet.wait_all()
2675 .. automethod:: simgrid.ActivitySet.wait_all_for()
2676 .. automethod:: simgrid.ActivitySet.wait_any()
2677 .. automethod:: simgrid.ActivitySet.wait_any_for()
2681 .. doxygenfunction:: sg_activity_set_test_any
2682 .. doxygenfunction:: sg_activity_set_wait_all
2683 .. doxygenfunction:: sg_activity_set_wait_all_for
2684 .. doxygenfunction:: sg_activity_set_wait_any
2685 .. doxygenfunction:: sg_activity_set_wait_any_for
2686 .. doxygenfunction:: sg_activity_unref
2688 Dealing with failed activities
2689 ------------------------------
2695 .. doxygenfunction:: simgrid::s4u::ActivitySet::get_failed_activity()
2696 .. doxygenfunction:: simgrid::s4u::ActivitySet::has_failed_activities()
2708 .. doxygenclass:: simgrid::s4u::Task
2710 **Known subclasses:**
2711 :ref:`Communication Tasks <API_s4u_CommTask>`,
2712 :ref:`Executions Tasks <API_s4u_ExecTask>`,
2713 :ref:`I/O Tasks <API_s4u_IoTask>`.
2714 See also the :ref:`section on activities <s4u_Tasks>` above.
2725 #include <simgrid/s4u/Task.hpp>
2727 .. doxygentypedef:: TaskPtr
2736 .. doxygenfunction:: simgrid::s4u::Task::get_cname() const
2737 .. doxygenfunction:: simgrid::s4u::Task::get_name() const
2738 .. doxygenfunction:: simgrid::s4u::Task::get_count(std::string instance) const
2739 .. doxygenfunction:: simgrid::s4u::Task::get_amount(std::string instance) const
2740 .. doxygenfunction:: simgrid::s4u::Task::get_queued_firings(std::string instance) const
2741 .. doxygenfunction:: simgrid::s4u::Task::get_running_count(std::string instance) const
2742 .. doxygenfunction:: simgrid::s4u::Task::get_parallelism_degree(std::string instance) const
2743 .. doxygenfunction:: simgrid::s4u::Task::set_name(std::string name)
2751 .. doxygenfunction:: simgrid::s4u::Task::enqueue_firings(int n)
2752 .. doxygenfunction:: simgrid::s4u::Task::set_amount(double amount, std::string instance)
2753 .. doxygenfunction:: simgrid::s4u::Task::set_parallelism_degree(int n, std::string instance)
2755 Managing Dependencies
2756 ---------------------
2761 .. doxygenfunction:: simgrid::s4u::Task::add_successor(TaskPtr t)
2762 .. doxygenfunction:: simgrid::s4u::Task::remove_successor(TaskPtr t)
2763 .. doxygenfunction:: simgrid::s4u::Task::remove_all_successors()
2764 .. doxygenfunction:: simgrid::s4u::Task::get_successors() const
2769 .. doxygenclass:: simgrid::s4u::Token
2774 .. doxygenfunction:: simgrid::s4u::Task::get_token_from(TaskPtr t) const
2775 .. doxygenfunction:: simgrid::s4u::Task::get_tokens_from(TaskPtr t) const
2776 .. doxygenfunction:: simgrid::s4u::Task::deque_token_from(TaskPtr t)
2777 .. doxygenfunction:: simgrid::s4u::Task::set_token(std::shared_ptr<Token> token)
2785 .. doxygenfunction:: simgrid::s4u::Task::on_start_cb
2786 .. doxygenfunction:: simgrid::s4u::Task::on_this_start_cb
2787 .. doxygenfunction:: simgrid::s4u::Task::on_completion_cb
2788 .. doxygenfunction:: simgrid::s4u::Task::on_this_completion_cb
2790 .. _API_s4u_CommTask:
2799 .. doxygenclass:: simgrid::s4u::CommTask
2810 #include <simgrid/s4u/Task.hpp>
2812 .. doxygentypedef:: CommTaskPtr
2821 .. doxygenfunction:: simgrid::s4u::CommTask::get_source() const
2822 .. doxygenfunction:: simgrid::s4u::CommTask::get_destination() const
2823 .. doxygenfunction:: simgrid::s4u::CommTask::get_bytes() const
2824 .. doxygenfunction:: simgrid::s4u::CommTask::set_source(Host* source);
2825 .. doxygenfunction:: simgrid::s4u::CommTask::set_destination(Host* destination);
2826 .. doxygenfunction:: simgrid::s4u::CommTask::set_bytes(double bytes)
2829 .. _API_s4u_ExecTask:
2838 .. doxygenclass:: simgrid::s4u::ExecTask
2849 #include <simgrid/s4u/Task.hpp>
2851 .. doxygentypedef:: ExecTaskPtr
2860 .. doxygenfunction:: simgrid::s4u::ExecTask::get_host(std::string instance) const
2861 .. doxygenfunction:: simgrid::s4u::ExecTask::get_flops(std::string instance) const
2862 .. doxygenfunction:: simgrid::s4u::ExecTask::set_host(Host* host, std::string instance);
2863 .. doxygenfunction:: simgrid::s4u::ExecTask::set_flops(double flops, std::string instance);
2864 .. doxygenfunction:: simgrid::s4u::ExecTask::add_instances(int n);
2865 .. doxygenfunction:: simgrid::s4u::ExecTask::remove_instances(int n);
2876 .. doxygenclass:: simgrid::s4u::IoTask
2887 #include <simgrid/s4u/Task.hpp>
2889 .. doxygentypedef:: IoTaskPtr
2898 .. doxygenfunction:: simgrid::s4u::IoTask::get_disk() const
2899 .. doxygenfunction:: simgrid::s4u::IoTask::get_bytes() const
2900 .. doxygenfunction:: simgrid::s4u::IoTask::get_op_type() const
2901 .. doxygenfunction:: simgrid::s4u::IoTask::set_disk(Disk* disk);
2902 .. doxygenfunction:: simgrid::s4u::IoTask::set_bytes(double bytes);
2903 .. doxygenfunction:: simgrid::s4u::IoTask::set_op_type(Io::OpType type);
2905 .. _API_s4u_Synchronizations:
2907 =======================
2908 Synchronization Objects
2909 =======================
2921 .. doxygenclass:: simgrid::s4u::Mutex
2923 .. group-tab:: Python
2925 .. autoclass:: simgrid.Mutex
2936 #include <simgrid/s4u/Mutex.hpp>
2938 .. doxygentypedef:: MutexPtr
2940 .. doxygenfunction:: simgrid::s4u::Mutex::create
2942 .. group-tab:: Python
2944 .. code-block:: Python
2946 from simgrid import Mutex
2949 # Use a context manager to acquire and automatically release the mutex
2950 # when leaving the scope.
2952 # Access shared resource ...
2955 .. automethod:: simgrid.Mutex.__init__
2961 #include <simgrid/mutex.h>
2963 .. doxygentypedef:: sg_mutex_t
2964 .. cpp:type:: const s4u_Mutex* const_sg_mutex_t
2966 Pointer to a constant mutex object.
2968 .. doxygenfunction:: sg_mutex_init()
2969 .. doxygenfunction:: sg_mutex_destroy(const_sg_mutex_t mutex)
2978 .. doxygenfunction:: simgrid::s4u::Mutex::lock()
2979 .. doxygenfunction:: simgrid::s4u::Mutex::try_lock()
2980 .. doxygenfunction:: simgrid::s4u::Mutex::unlock()
2982 .. group-tab:: Python
2984 .. automethod:: simgrid.Mutex.lock
2985 .. automethod:: simgrid.Mutex.try_lock
2986 .. automethod:: simgrid.Mutex.unlock
2990 .. doxygenfunction:: sg_mutex_lock(sg_mutex_t mutex)
2991 .. doxygenfunction:: sg_mutex_try_lock(sg_mutex_t mutex)
2992 .. doxygenfunction:: sg_mutex_unlock(sg_mutex_t mutex)
2994 .. _API_s4u_Barrier:
3004 .. doxygenclass:: simgrid::s4u::Barrier
3006 .. group-tab:: Python
3008 .. autoclass:: simgrid.Barrier
3016 #include <simgrid/s4u/Barrier.hpp>
3018 .. doxygentypedef:: BarrierPtr
3020 .. doxygenfunction:: simgrid::s4u::Barrier::create(unsigned int expected_actors)
3021 .. doxygenfunction:: simgrid::s4u::Barrier::wait()
3022 .. doxygenfunction:: simgrid::s4u::Barrier::to_string()
3024 .. group-tab:: Python
3026 .. code-block:: Python
3028 from simgrid import Barrier
3029 barrier = Barrier(2)
3031 .. automethod:: simgrid.Barrier.__init__
3032 .. automethod:: simgrid.Barrier.wait
3038 #include <simgrid/barrier.hpp>
3040 .. doxygentypedef:: sg_bar_t
3042 .. doxygenfunction:: sg_barrier_init(unsigned int count)
3043 .. doxygenfunction:: sg_barrier_destroy(sg_bar_t bar)
3044 .. doxygenfunction:: sg_barrier_wait(sg_bar_t bar)
3047 .. _API_s4u_ConditionVariable:
3049 ==========================
3050 Condition variable
3051 ==========================
3053 .. doxygenclass:: simgrid::s4u::ConditionVariable
3064 #include <simgrid/s4u/ConditionVariable.hpp>
3066 .. doxygentypedef:: ConditionVariablePtr
3068 .. doxygenfunction:: simgrid::s4u::ConditionVariable::create()
3074 #include <simgrid/cond.h>
3076 .. doxygentypedef:: sg_cond_t
3077 .. doxygentypedef:: const_sg_cond_t
3078 .. doxygenfunction:: sg_cond_init
3079 .. doxygenfunction:: sg_cond_destroy
3081 Waiting and notifying
3082 ---------------------
3088 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_all()
3089 .. doxygenfunction:: simgrid::s4u::ConditionVariable::notify_one()
3090 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(s4u::MutexPtr lock)
3091 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< s4u::Mutex > &lock)
3092 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait(const std::unique_lock< Mutex > &lock, P pred)
3093 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration)
3094 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, double duration, P pred)
3095 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration)
3096 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_for(const std::unique_lock< s4u::Mutex > &lock, std::chrono::duration< Rep, Period > duration, P pred)
3097 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time)
3098 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, const SimulationTimePoint< Duration > &timeout_time, P pred)
3099 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time)
3100 .. doxygenfunction:: simgrid::s4u::ConditionVariable::wait_until(const std::unique_lock< s4u::Mutex > &lock, double timeout_time, P pred)
3104 .. doxygenfunction:: sg_cond_notify_all
3105 .. doxygenfunction:: sg_cond_notify_one
3106 .. doxygenfunction:: sg_cond_wait
3107 .. doxygenfunction:: sg_cond_wait_for
3109 .. _API_s4u_Semaphore:
3119 .. doxygenclass:: simgrid::s4u::Semaphore
3121 .. group-tab:: Python
3123 .. autoclass:: simgrid.Semaphore
3134 #include <simgrid/s4u/Semaphore.hpp>
3136 .. doxygentypedef:: SemaphorePtr
3137 .. doxygenfunction:: simgrid::s4u::Semaphore::create(unsigned int initial_capacity)
3139 .. group-tab:: Python
3141 .. code-block:: Python
3143 from simgrid import Semaphore
3144 semaphore = Semaphore(1)
3145 # Automatically acquire the semaphore, and release it after leaving the scope.
3147 # Do something with the shared resource
3150 .. automethod:: simgrid.Semaphore.__init__
3156 #include <simgrid/semaphore.h>
3158 .. doxygentypedef:: sg_sem_t
3159 .. cpp:type:: const s4u_Semaphore* const_sg_sem_t
3161 Pointer to a constant semaphore object.
3163 .. doxygenfunction:: sg_sem_init(int initial_value)
3164 .. doxygenfunction:: sg_sem_destroy(const_sg_sem_t sem)
3173 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire()
3174 .. doxygenfunction:: simgrid::s4u::Semaphore::acquire_timeout(double timeout)
3175 .. doxygenfunction:: simgrid::s4u::Semaphore::get_capacity() const
3176 .. doxygenfunction:: simgrid::s4u::Semaphore::release()
3177 .. doxygenfunction:: simgrid::s4u::Semaphore::would_block() const
3179 .. group-tab:: Python
3181 .. automethod:: simgrid.Semaphore.acquire
3182 .. automethod:: simgrid.Semaphore.acquire_timeout
3183 .. autoattribute:: simgrid.Semaphore.capacity
3184 .. automethod:: simgrid.Semaphore.release
3185 .. autoattribute:: simgrid.Semaphore.would_block
3189 .. doxygenfunction:: sg_sem_acquire(sg_sem_t sem)
3190 .. doxygenfunction:: sg_sem_acquire_timeout(sg_sem_t sem, double timeout)
3191 .. doxygenfunction:: sg_sem_get_capacity(const_sg_sem_t sem)
3192 .. doxygenfunction:: sg_sem_release(sg_sem_t sem)
3193 .. doxygenfunction:: sg_sem_would_block(const_sg_sem_t sem)
3203 .. doxygenclass:: simgrid::Exception
3205 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3207 .. doxygenclass:: simgrid::CancelException
3208 .. doxygenclass:: simgrid::HostFailureException
3209 .. doxygenclass:: simgrid::NetworkFailureException
3210 .. doxygenclass:: simgrid::StorageFailureException
3211 .. doxygenclass:: simgrid::TimeoutException
3212 .. doxygenclass:: simgrid::VmFailureException
3214 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3215 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3216 SimGrid from a python notebook and want to handle the problem accordingly.
3218 .. doxygenclass:: simgrid::AssertionError
3219 .. doxygenclass:: simgrid::ParseError
3220 .. doxygenclass:: simgrid::TracingError
3222 .. group-tab:: Python
3224 The following exceptions denote a problem in the simulated platform, and it is often useful to catch them.
3226 .. autoclass:: simgrid.CancelException
3227 .. autoclass:: simgrid.HostFailureException
3228 .. autoclass:: simgrid.NetworkFailureException
3229 .. autoclass:: simgrid.StorageFailureException
3230 .. autoclass:: simgrid.TimeoutException
3231 .. autoclass:: simgrid.VmFailureException
3233 The following errors denote a problem in the SimGrid tool itself. Most of the time, you should let these
3234 exception go, so that the simulation stops. But you may want to catch them, for example when you launch
3235 SimGrid from a python notebook and want to handle the problem accordingly.
3237 .. autoclass:: simgrid.AssertionError
3241 .. doxygenenum:: sg_error_t