examples/README.rst

   1 .. S4U (Simgrid for you) is the modern interface of SimGrid, which new project should use.
   2 ..
   3 .. This file follows the ReStructured syntax to be included in the
   4 .. documentation, but it should remain readable directly.
   5
   6
   7 Examples
   8 ********
   9
  10 SimGrid comes with an extensive set of examples, documented on this
  11 page. Most of them only demonstrate one single feature, with some
  12 larger examplars listed below.
  13
  14 The C++ examples can be found under examples/s4u while python examples
  15 are in examples/python. Each such directory contains the source code (also listed
  16 from this page), and the so-called tesh file containing how to call
  17 the binary obtained by compiling this example and also the expected
  18 output. Tesh files are used to turn each of our examples into an
  19 integration test. Some examples also contain other files, on need.
  20
  21 A good way to bootstrap your own project is to copy and combine some
  22 of the provided examples to constitute the skeleton of what you plan
  23 to simulate.
  24
  25 .. _s4u_ex_actors:
  26
  27 ===========================
  28 Actors: the Active Entities
  29 ===========================
  30
  31 Starting and Stoping Actors
  32 ---------------------------
  33
  34   - **Creating actors:**
  35     Most actors are started from the deployment XML file, because this
  36     is a :ref:`better scientific habbit <howto_science>`, but you can
  37     also create them directly from your code.
  38
  39     .. tabs::
  40
  41        .. example-tab:: examples/s4u/actor-create/s4u-actor-create.cpp
  42
  43           You create actors either:
  44
  45           - Directly with :cpp:func:`simgrid::s4u::Actor::create`
  46           - From XML with :cpp:func:`simgrid::s4u::Engine::register_actor` (if your actor is a class)
  47             or :cpp:func:`simgrid::s4u::Engine::register_function` (if your actor is a function)
  48             and then :cpp:func:`simgrid::s4u::Engine::load_deployment`
  49
  50        .. example-tab:: examples/python/actor-create/actor-create.py
  51
  52           You create actors either:
  53
  54           - Directly with :py:func:`simgrid.Actor.create()`
  55           - From XML with :py:func:`simgrid.Engine.register_actor()` and then :py:func:`simgrid.Engine.load_deployment()`
  56
  57        .. example-tab:: examples/c/actor-create/actor-create.c
  58
  59           You create actors either:
  60
  61           - Directly with :cpp:func:`sg_actor_create()` followed by :cpp:func:`sg_actor_start`.
  62           - From XML with :cpp:func:`simgrid_register_function` and then :cpp:func:`simgrid_load_deployment`.
  63
  64        .. example-tab:: examples/python/actor-create/actor-create_d.xml
  65
  66           The following file is used in both C++ and Python.
  67
  68   - **React to the end of actors:** You can attach callbacks to the end of
  69     actors. There is several ways of doing so, depending on whether you want to
  70     attach your callback to a given actor and on how you define the end of a
  71     given actor. User code probably want to react to the termination of an actor
  72     while some plugins want to react to the destruction (memory collection) of
  73     actors.
  74
  75     .. tabs::
  76
  77        .. example-tab:: examples/s4u/actor-exiting/s4u-actor-exiting.cpp
  78
  79           This example shows how to attach a callback to:
  80
  81           - the end of a specific actor: :cpp:func:`simgrid::s4u::this_actor::on_exit()`
  82           - the end of any actor: :cpp:member:`simgrid::s4u::Actor::on_termination()`
  83           - the destruction of any actor: :cpp:member:`simgrid::s4u::Actor::on_destruction()`
  84
  85   - **Kill actors:**
  86     Actors can forcefully stop other actors.
  87
  88     .. tabs::
  89
  90        .. example-tab:: examples/s4u/actor-kill/s4u-actor-kill.cpp
  91
  92           See also :cpp:func:`void simgrid::s4u::Actor::kill(void)`, :cpp:func:`void simgrid::s4u::Actor::kill_all()`,
  93           :cpp:func:`simgrid::s4u::this_actor::exit`.
  94
  95        .. example-tab:: examples/python/actor-kill/actor-kill.py
  96
  97           See also :py:func:`simgrid.Actor.kill`, :py:func:`simgrid.Actor.kill_all`, :py:func:`simgrid.this_actor.exit`.
  98
  99   - **Controling the actor life cycle from the XML:**
 100     You can specify a start time and a kill time in the deployment file.
 101
 102     .. tabs::
 103
 104        .. example-tab:: examples/s4u/actor-lifetime/s4u-actor-lifetime.cpp
 105
 106           This file is not really interesting: the important matter is in the XML file.
 107
 108        .. example-tab:: examples/s4u/actor-lifetime/s4u-actor-lifetime_d.xml
 109
 110           This demonstrates the ``start_time`` and ``kill_time`` attribute of the :ref:`pf_tag_actor` tag.
 111
 112   - **Daemonize actors:**
 113     Some actors may be intended to simulate daemons that run in background. This example show how to transform a regular
 114     actor into a daemon that will be automatically killed once the simulation is over.
 115
 116     .. tabs::
 117
 118        .. example-tab:: examples/s4u/actor-daemon/s4u-actor-daemon.cpp
 119
 120           See also :cpp:func:`simgrid::s4u::Actor::daemonize()` and :cpp:func:`simgrid::s4u::Actor::is_daemon()`.
 121
 122        .. example-tab:: examples/python/actor-daemon/actor-daemon.py
 123
 124           See also :py:func:`simgrid.Actor.daemonize()` and :py:func:`simgrid.Actor.is_daemon()`.
 125
 126 Inter-Actors Interactions
 127 -------------------------
 128
 129 See also the examples on :ref:`inter-actors communications
 130 <s4u_ex_communication>` and the ones on :ref:`classical
 131 synchronization objects <s4u_ex_IPC>`.
 132
 133   - **Suspend and Resume actors:**
 134     Actors can be suspended and resumed during their executions.
 135
 136     .. tabs::
 137
 138        .. example-tab:: examples/s4u/actor-suspend/s4u-actor-suspend.cpp
 139
 140           See also :cpp:func:`simgrid::s4u::this_actor::suspend()`,
 141           :cpp:func:`simgrid::s4u::Actor::suspend()`, :cpp:func:`simgrid::s4u::Actor::resume()` and
 142           :cpp:func:`simgrid::s4u::Actor::is_suspended()`.
 143
 144        .. example-tab:: examples/python/actor-suspend/actor-suspend.py
 145
 146           See also :py:func:`simgrid.this_actor.suspend()`,
 147           :py:func:`simgrid.Actor.suspend()`, :py:func:`simgrid.Actor.resume()` and
 148           :py:func:`simgrid.Actor.is_suspended()`.
 149
 150   - **Migrating Actors:**
 151     Actors can move or be moved from a host to another very easily.
 152
 153     .. tabs::
 154
 155        .. example-tab:: examples/s4u/actor-migrate/s4u-actor-migrate.cpp
 156
 157           See also :cpp:func:`simgrid::s4u::this_actor::migrate()` and :cpp:func:`simgrid::s4u::Actor::migrate()`.
 158
 159        .. example-tab:: examples/python/actor-migrate/actor-migrate.py
 160
 161           See also :py:func:`simgrid.this_actor.migrate()` and :py:func:`simgrid.Actor.migrate()`.
 162
 163   - **Waiting for the termination of an actor:** (joining on it)
 164     You can block the current actor until the end of another actor.
 165
 166     .. tabs::
 167
 168        .. example-tab:: examples/s4u/actor-join/s4u-actor-join.cpp
 169
 170           See also :cpp:func:`simgrid::s4u::Actor::join()`.
 171
 172        .. example-tab:: examples/python/actor-join/actor-join.py
 173
 174           See also :py:func:`simgrid.Actor.join()`.
 175
 176   - **Yielding to other actors**.
 177     The ```yield()``` function interrupts the execution of the current
 178     actor, leaving a chance to the other actors that are ready to run
 179     at this timestamp.
 180
 181     .. tabs::
 182
 183        .. example-tab:: examples/s4u/actor-yield/s4u-actor-yield.cpp
 184
 185           See also :cpp:func:`simgrid::s4u::this_actor::yield()`.
 186
 187        .. example-tab:: examples/python/actor-yield/actor-yield.py
 188
 189           See also :py:func:`simgrid.this_actor.yield_()`.
 190
 191 Traces Replay as a Workload
 192 ---------------------------
 193
 194 This section details how to run trace-driven simulations. It is very
 195 handy when you want to test an algorithm or protocol that only react
 196 to external events. For example, many P2P protocols react to user
 197 requests, but do nothing if there is no such event.
 198
 199 In such situations, you should write your protocol in C++, and separate
 200 the workload that you want to play onto your protocol in a separate
 201 text file. Declare a function handling each type of the events in your
 202 trace, register them using :cpp:func:`xbt_replay_action_register()` in
 203 your main, and then run the simulation.
 204
 205 Then, you can either have one trace file containing all your events,
 206 or a file per simulated process: the former may be easier to work
 207 with, but the second is more efficient on very large traces. Check
 208 also the tesh files in the example directories for details.
 209
 210   - **Communication replay:**
 211     Presents a set of event handlers reproducing classical communication
 212     primitives (asynchronous send/receive at the moment).
 213
 214     .. tabs::
 215
 216        .. example-tab:: examples/s4u/replay-comm/s4u-replay-comm.cpp
 217
 218   - **I/O replay:**
 219     Presents a set of event handlers reproducing classical I/O
 220     primitives (open, read, close).
 221
 222     .. tabs::
 223
 224        .. example-tab:: examples/s4u/replay-io/s4u-replay-io.cpp
 225
 226 ==========================
 227 Activities: what Actors do
 228 ==========================
 229
 230 .. _s4u_ex_communication:
 231
 232 Communications on the Network
 233 -----------------------------
 234
 235  - **Basic asynchronous communications:**
 236    Illustrates how to have non-blocking communications, that are
 237    communications running in the background leaving the process free
 238    to do something else during their completion.
 239
 240    .. tabs::
 241
 242       .. example-tab:: examples/s4u/async-wait/s4u-async-wait.cpp
 243
 244          See also :cpp:func:`simgrid::s4u::Mailbox::put_async()` and :cpp:func:`simgrid::s4u::Comm::wait()`.
 245
 246       .. example-tab:: examples/python/async-wait/async-wait.py
 247
 248          See also :py:func:`simgrid.Mailbox.put_async()` and :py:func:`simgrid.Comm.wait()`.
 249
 250  - **Waiting for all communications in a set:**
 251    The ``wait_all()`` function is useful when you want to block until
 252    all activities in a given set have completed.
 253
 254    .. tabs::
 255
 256       .. example-tab:: examples/s4u/async-waitall/s4u-async-waitall.cpp
 257
 258          See also :cpp:func:`simgrid::s4u::Comm::wait_all()`.
 259
 260       .. example-tab:: examples/python/async-waitall/async-waitall.py
 261
 262          See also :py:func:`simgrid.Comm.wait_all()`.
 263
 264  - **Waiting for the first completed communication in a set:**
 265    The ``wait_any()`` function is useful
 266    when you want to block until one activity of the set completes, no
 267    matter which terminates first.
 268
 269    .. tabs::
 270
 271       .. example-tab:: examples/s4u/async-waitany/s4u-async-waitany.cpp
 272
 273          See also :cpp:func:`simgrid::s4u::Comm::wait_any()`.
 274
 275       .. example-tab:: examples/python/async-waitany/async-waitany.py
 276
 277          See also :py:func:`simgrid.Comm.wait_any()`.
 278
 279       .. example-tab:: examples/c/async-waitany/async-waitany.c
 280
 281          See also :cpp:func:`sg_comm_wait_any`.
 282
 283 .. _s4u_ex_execution:
 284
 285 Executions on the CPU
 286 ---------------------
 287
 288   - **Basic execution:**
 289     The computations done in your program are not reported to the
 290     simulated world, unless you explicitly request the simulator to pause
 291     the actor until a given amount of flops gets computed on its simulated
 292     host. Some executions can be given an higher priority so that they
 293     get more resources.
 294
 295     .. tabs::
 296
 297        .. example-tab:: examples/s4u/exec-basic/s4u-exec-basic.cpp
 298
 299           See also :cpp:func:`void simgrid::s4u::this_actor::execute(double)`
 300           and :cpp:func:`void simgrid::s4u::this_actor::execute(double, double)`.
 301
 302        .. example-tab:: examples/python/exec-basic/exec-basic.py
 303
 304           See also :py:func:`simgrid.this_actor.execute()`.
 305
 306   - **Asynchronous execution:**
 307     You can start asynchronous executions, just like you would fire
 308     background threads.
 309
 310     .. tabs::
 311
 312        .. example-tab:: examples/s4u/exec-async/s4u-exec-async.cpp
 313
 314           See also :cpp:func:`simgrid::s4u::this_actor::exec_init()`,
 315           :cpp:func:`simgrid::s4u::Activity::start()`,
 316           :cpp:func:`simgrid::s4u::Activity::wait()`,
 317           :cpp:func:`simgrid::s4u::Activity::get_remaining()`,
 318           :cpp:func:`simgrid::s4u::Exec::get_remaining_ratio()`,
 319           :cpp:func:`simgrid::s4u::this_actor::exec_async()` and
 320           :cpp:func:`simgrid::s4u::Activity::cancel()`.
 321
 322        .. example-tab:: examples/python/exec-async/exec-async.py
 323
 324           See also :py:func:`simgrid.this_actor::exec_init()`,
 325           :py:func:`simgrid.Activity::start()`,
 326           :py:func:`simgrid.Activity.wait()`,
 327           :py:func:`simgrid.Activity.get_remaining()`,
 328           :py:func:`simgrid.Exec.get_remaining_ratio()`,
 329           :py:func:`simgrid.this_actor.exec_async()` and
 330           :py:func:`simgrid.Activity.cancel()`.
 331
 332   - **Remote execution:**
 333     You can start executions on remote hosts, or even change the host
 334     on which they occur during their execution.
 335
 336     .. tabs::
 337
 338        .. example-tab:: examples/s4u/exec-remote/s4u-exec-remote.cpp
 339
 340           See also :cpp:func:`simgrid::s4u::Exec::set_host()`.
 341
 342        .. example-tab:: examples/python/exec-remote/exec-remote.py
 343
 344           See also :py:func:`simgrid.Exec.set_host()`.
 345
 346   - **Parallel executions:**
 347     These objects are convenient abstractions of parallel
 348     computational kernels that span over several machines, such as a
 349     PDGEM and the other ScaLAPACK routines. Note that this only works
 350     with the "ptask_L07" host model (``--cfg=host/model:ptask_L07``).
 351
 352     .. tabs::
 353
 354        .. example-tab:: examples/s4u/exec-ptask/s4u-exec-ptask.cpp
 355
 356           See also :cpp:func:`simgrid::s4u::this_actor::parallel_execute()`.
 357
 358   - **Using Pstates on a host:**
 359     This example shows how define a set of pstates in the XML. The current pstate
 360     of an host can then be accessed and changed from the program.
 361
 362     .. tabs::
 363
 364        .. example-tab:: examples/s4u/exec-dvfs/s4u-exec-dvfs.cpp
 365
 366           See also :cpp:func:`simgrid::s4u::Host::get_pstate_speed` and :cpp:func:`simgrid::s4u::Host::set_pstate`.
 367
 368        .. example-tab:: examples/python/exec-dvfs/exec-dvfs.py
 369
 370           See also :py:func:`Host.get_pstate_speed` and :py:func:`Host.set_pstate`.
 371
 372        .. example-tab:: examples/platforms/energy_platform.xml
 373
 374 .. _s4u_ex_disk_io:
 375
 376 I/O on Disks and Files
 377 ----------------------
 378
 379 SimGrid provides two levels of abstraction to interact with the
 380 simulated disks. At the simplest level, you simply create read and
 381 write actions on the disk resources.
 382
 383   - **Access to raw disk devices:**
 384     This example illustrates how to simply read and write data on a
 385     simulated disk resource.
 386
 387     .. tabs::
 388
 389        .. example-tab:: examples/s4u/io-disk-raw/s4u-io-disk-raw.cpp
 390
 391        .. example-tab:: examples/platforms/hosts_with_disks.xml
 392
 393           This shows how to declare disks in XML.
 394
 395 The FileSystem plugin provides a more detailed view, with the
 396 classical operations over files: open, move, unlink, and of course
 397 read and write. The file and disk sizes are also dealt with and can
 398 result in short reads and short write, as in reality.
 399
 400   - **File Management:**
 401     This example illustrates the use of operations on files
 402     (read, write, seek, tell, unlink, etc).
 403
 404     .. tabs::
 405
 406        .. example-tab:: examples/s4u/io-file-system/s4u-io-file-system.cpp
 407
 408   - **Remote I/O:**
 409     I/O operations on files can also be done in a remote fashion,
 410     i.e. when the accessed disk is not mounted on the caller's host.
 411
 412     .. tabs::
 413
 414        .. example-tab:: examples/s4u/io-file-remote/s4u-io-file-remote.cpp
 415
 416 .. _s4u_ex_IPC:
 417
 418 Classical synchronization objects
 419 ---------------------------------
 420
 421  - **Barrier:**
 422    Shows how to use :cpp:type:`simgrid::s4u::Barrier` synchronization objects.
 423
 424    .. tabs::
 425
 426       .. example-tab:: examples/s4u/synchro-barrier/s4u-synchro-barrier.cpp
 427
 428  - **Condition variable:**
 429    Shows how to use :cpp:type:`simgrid::s4u::ConditionVariable` synchronization objects.
 430
 431    .. tabs::
 432
 433       .. example-tab:: examples/s4u/synchro-condition-variable/s4u-synchro-condition-variable.cpp
 434
 435  - **Mutex:**
 436    Shows how to use :cpp:type:`simgrid::s4u::Mutex` synchronization objects.
 437
 438    .. tabs::
 439
 440       .. example-tab:: examples/s4u/synchro-mutex/s4u-synchro-mutex.cpp
 441
 442  - **Semaphore:**
 443    Shows how to use :cpp:type:`simgrid::s4u::Semaphore` synchronization objects.
 444
 445    .. tabs::
 446
 447       .. example-tab:: examples/s4u/synchro-semaphore/s4u-synchro-semaphore.cpp
 448
 449 =============================
 450 Interacting with the Platform
 451 =============================
 452
 453  - **User-defined properties:**
 454    You can attach arbitrary information to most platform elements from
 455    the XML file, and then interact with these values from your
 456    program. Note that the changes are not written permanently on disk,
 457    in the XML file nor anywhere else. They only last until the end of
 458    your simulation.
 459
 460    .. tabs::
 461
 462       .. example-tab:: examples/s4u/platform-properties/s4u-platform-properties.cpp
 463
 464          - :cpp:func:`simgrid::s4u::Actor::get_property()` and :cpp:func:`simgrid::s4u::Actor::set_property()`
 465          - :cpp:func:`simgrid::s4u::Host::get_property()` and :cpp:func:`simgrid::s4u::Host::set_property()`
 466          - :cpp:func:`simgrid::s4u::Link::get_property()` and :cpp:func:`simgrid::s4u::Link::set_property()`
 467          - :cpp:func:`simgrid::s4u::NetZone::get_property()` and :cpp:func:`simgrid::s4u::NetZone::set_property()`
 468
 469       .. group-tab:: XML
 470
 471          **Deployment file:**
 472
 473          .. showfile:: examples/s4u/platform-properties/s4u-platform-properties_d.xml
 474             :language: xml
 475
 476          |br|
 477          **Platform file:**
 478
 479          .. showfile:: examples/platforms/prop.xml
 480             :language: xml
 481
 482  - **Retrieving the netzones matching a given criteria:**
 483    Shows how to filter the cluster netzones.
 484
 485    .. tabs::
 486
 487       .. example-tab:: examples/s4u/routing-get-clusters/s4u-routing-get-clusters.cpp
 488
 489  - **Retrieving the list of hosts matching a given criteria:**
 490    Shows how to filter the actors that match a given criteria.
 491
 492    .. tabs::
 493
 494       .. example-tab:: examples/s4u/engine-filtering/s4u-engine-filtering.cpp
 495
 496  - **Specifying state profiles:** shows how to specify when the
 497    resources must be turned off and on again, and how to react to such
 498    failures in your code. See also :ref:`howto_churn`.
 499
 500    .. tabs::
 501
 502       .. example-tab:: examples/s4u/platform-failures/s4u-platform-failures.cpp
 503
 504       .. group-tab:: XML
 505
 506          .. showfile:: examples/platforms/small_platform_failures.xml
 507             :language: xml
 508
 509          .. showfile:: examples/platforms/profiles/jupiter_state.profile
 510
 511          .. showfile:: examples/platforms/profiles/bourassa_state.profile
 512
 513          .. showfile:: examples/platforms/profiles/fafard_state.profile
 514
 515  - **Specifying speed profiles:** shows how to specify an external
 516    load to resources, variating their peak speed over time.
 517
 518    .. tabs::
 519
 520       .. example-tab:: examples/s4u/platform-profile/s4u-platform-profile.cpp
 521
 522       .. group-tab:: XML
 523
 524          .. showfile:: examples/platforms/small_platform_profile.xml
 525             :language: xml
 526
 527          .. showfile:: examples/platforms/profiles/jupiter_speed.profile
 528
 529          .. showfile:: examples/platforms/profiles/link1_bandwidth.profile
 530
 531          .. showfile:: examples/platforms/profiles/link1_latency.profile
 532
 533 =================
 534 Energy Simulation
 535 =================
 536
 537   - **Describing the energy profiles in the platform:**
 538     This platform file contains the energy profile of each links and
 539     hosts, which is necessary to get energy consumption predictions.
 540     As usual, you should not trust our example, and you should strive
 541     to double-check that your instantiation matches your target platform.
 542
 543     .. tabs::
 544
 545        .. example-tab:: examples/platforms/energy_platform.xml
 546
 547   - **Consumption due to the CPU:**
 548     This example shows how to retrieve the amount of energy consumed
 549     by the CPU during computations, and the impact of the pstate.
 550
 551     .. tabs::
 552
 553        .. example-tab:: examples/s4u/energy-exec/s4u-energy-exec.cpp
 554
 555   - **Consumption due to the network:**
 556     This example shows how to retrieve and display the energy consumed
 557     by the network during communications.
 558
 559     .. tabs::
 560
 561        .. example-tab:: examples/s4u/energy-link/s4u-energy-link.cpp
 562
 563   - **Modeling the shutdown and boot of hosts:**
 564     Simple example of model of model for the energy consumption during
 565     the host boot and shutdown periods.
 566
 567     .. tabs::
 568
 569        .. example-tab:: examples/s4u/energy-boot/platform_boot.xml
 570
 571        .. example-tab:: examples/s4u/energy-boot/s4u-energy-boot.cpp
 572
 573 =======================
 574 Tracing and Visualizing
 575 =======================
 576
 577 Tracing can be activated by various configuration options which
 578 are illustrated in these example. See also the
 579 :ref:`full list of options related to tracing <tracing_tracing_options>`.
 580
 581 It is interesting to run the process-create example with the following
 582 options to see the task executions:
 583
 584   - **Platform Tracing:**
 585     This program is a toy example just loading the platform, so that
 586     you can play with the platform visualization. Recommanded options:
 587     ``--cfg=tracing:yes --cfg=tracing/categorized:yes``
 588
 589     .. tabs::
 590
 591        .. example-tab:: examples/s4u/trace-platform/s4u-trace-platform.cpp
 592
 593 ========================
 594 Larger SimGrid Examplars
 595 ========================
 596
 597 This section contains application examples that are somewhat larger
 598 than the previous examples.
 599
 600   - **Ping Pong:**
 601     This simple example just sends one message back and forth.
 602     The tesh file laying in the directory show how to start the simulator binary, highlighting how to pass options to
 603     the simulators (as detailed in Section :ref:`options`).
 604
 605     .. tabs::
 606
 607        .. example-tab:: examples/s4u/app-pingpong/s4u-app-pingpong.cpp
 608
 609   - **Token ring:**
 610     Shows how to implement a classical communication pattern, where a
 611     token is exchanged along a ring to reach every participant.
 612
 613     .. tabs::
 614
 615        .. example-tab:: examples/s4u/app-token-ring/s4u-app-token-ring.cpp
 616
 617   - **Master Workers:**
 618     Another good old example, where one Master process has a bunch of task to dispatch to a set of several Worker
 619     processes.
 620
 621     .. tabs::
 622
 623        .. group-tab:: C++
 624
 625           This example comes in two equivalent variants, one where the actors
 626           are specified as simple functions (which is easier to understand for
 627           newcomers) and one where the actors are specified as classes (which is
 628           more powerful for the users wanting to build their own projects upon
 629           the example).
 630
 631           .. showfile:: examples/s4u/app-masterworkers/s4u-app-masterworkers-class.cpp
 632              :language: cpp
 633
 634           .. showfile:: examples/s4u/app-masterworkers/s4u-app-masterworkers-fun.cpp
 635              :language: cpp
 636
 637 Data diffusion
 638 --------------
 639
 640   - **Bit Torrent:**
 641     Classical protocol for Peer-to-Peer data diffusion.
 642
 643     .. tabs::
 644
 645        .. group-tab:: C++
 646
 647           .. showfile:: examples/s4u/app-bittorrent/s4u-bittorrent.cpp
 648              :language: cpp
 649
 650           .. showfile:: examples/s4u/app-bittorrent/s4u-peer.cpp
 651              :language: cpp
 652
 653           .. showfile:: examples/s4u/app-bittorrent/s4u-tracker.cpp
 654              :language: cpp
 655
 656   - **Chained Send:**
 657     Data broadcast over a ring of processes.
 658
 659     .. tabs::
 660
 661        .. example-tab:: examples/s4u/app-chainsend/s4u-app-chainsend.cpp
 662
 663 Distributed Hash Tables (DHT)
 664 -----------------------------
 665
 666   - **Chord Protocol**
 667     One of the most famous DHT protocol.
 668
 669     .. tabs::
 670
 671        .. group-tab:: C++
 672
 673           .. showfile:: examples/s4u/dht-chord/s4u-dht-chord.cpp
 674              :language: cpp
 675
 676           .. showfile:: examples/s4u/dht-chord/s4u-dht-chord-node.cpp
 677              :language: cpp
 678
 679   - **Kademlia**
 680     Another well-known DHT protocol.
 681
 682     .. tabs::
 683
 684        .. group-tab:: C++
 685
 686           .. showfile:: examples/s4u/dht-kademlia/s4u-dht-kademlia.cpp
 687              :language: cpp
 688
 689           .. showfile:: examples/s4u/dht-kademlia/routing_table.cpp
 690              :language: cpp
 691
 692           .. showfile:: examples/s4u/dht-kademlia/answer.cpp
 693              :language: cpp
 694
 695           .. showfile:: examples/s4u/dht-kademlia/node.cpp
 696              :language: cpp
 697
 698 .. _s4u_ex_clouds:
 699
 700 Simulating Clouds
 701 -----------------
 702
 703   - **Cloud basics**
 704     This example starts some computations both on PMs and VMs, and
 705     migrates some VMs around.
 706
 707     .. tabs::
 708
 709        .. example-tab:: examples/s4u/cloud-simple/s4u-cloud-simple.cpp
 710
 711   - **Migrating VMs**
 712     This example shows how to migrate VMs between PMs.
 713
 714     .. tabs::
 715
 716        .. example-tab:: examples/s4u/cloud-migration/s4u-cloud-migration.cpp
 717
 718 =======================
 719 Model-Checking Examples
 720 =======================
 721
 722 The model-checker can be used to exhaustively search for issues in the
 723 tested application. It must be activated at compile time, but this
 724 mode is rather experimental in SimGrid (as of v3.22). You should not
 725 enable it unless you really want to formally verify your applications:
 726 SimGrid is slower and maybe less robust when MC is enabled.
 727
 728   - **Failing assert**
 729     In this example, two actors send some data to a central server,
 730     which asserts that the messages are always received in the same order.
 731     This is obviously wrong, and the model-checker correctly finds a
 732     counter-example to that assertion.
 733
 734     .. tabs::
 735
 736        .. example-tab:: examples/s4u/mc-failing-assert/s4u-mc-failing-assert.cpp
 737
 738 .. |br| raw:: html
 739
 740    <br />
 741
 742 .. |cpp| image:: /img/lang_cpp.png
 743    :align: middle
 744    :width: 12
 745
 746 .. |py| image:: /img/lang_python.png
 747    :align: middle
 748    :width: 12