examples/s4u/actor-create/s4u-actor-create.cpp

   1 /* Copyright (c) 2006-2018. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 /* This example shows how to declare and start your actors.
   7  *
   8  * The first step is to declare the code of your actors (what they do exactly does not matter to this example) and then
   9  * you ask SimGrid to start your actors. There is three ways of doing so:
  10  *  - Directly, by instantiating your actor as parameter to Actor::create()
  11  *  - By first registering your actors before instantiating it
  12  *  - Through the deployment file.
  13  *
  14  * This example shows all these solutions, even if you obviously should use only one of these solutions to start your
  15  * actors. The most advised solution is to use a deployment file, as it creates a clear separation between your
  16  * application and the settings to test it. This is a better scientific methodology. Actually, starting an actor with
  17  * Actor::create() is mostly useful to start an actor from another actor.
  18  */
  19
  20 #include <simgrid/s4u.hpp>
  21 #include <string>
  22
  23 // This declares a logging channel so that XBT_INFO can be used later
  24 XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor_create, "The logging channel used in this example");
  25
  26 /* Our first class of actors is simply implemented with a function, that takes a single string as parameter.
  27  *
  28  * Later, this actor class is instantiated within the simulation.
  29  */
  30 static void receiver(std::string mailbox_name)
  31 {
  32   simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mailbox_name);
  33
  34   XBT_INFO("Hello s4u, I'm ready to get any message you'd want on %s", mailbox->get_cname());
  35
  36   std::string* msg1 = static_cast<std::string*>(mailbox->get());
  37   std::string* msg2 = static_cast<std::string*>(mailbox->get());
  38   std::string* msg3 = static_cast<std::string*>(mailbox->get());
  39   XBT_INFO("I received '%s', '%s' and '%s'", msg1->c_str(), msg2->c_str(), msg3->c_str());
  40   delete msg1;
  41   delete msg2;
  42   delete msg3;
  43   XBT_INFO("I'm done. See you.");
  44 }
  45
  46 /* Our second class of actors is also a function */
  47 static int forwarder(int argc, char** argv)
  48 {
  49   xbt_assert(argc >= 3, "Actor forwarder requires 2 parameters, but got only %d", argc - 1);
  50   simgrid::s4u::MailboxPtr in  = simgrid::s4u::Mailbox::by_name(argv[1]);
  51   simgrid::s4u::MailboxPtr out = simgrid::s4u::Mailbox::by_name(argv[2]);
  52   std::string* msg             = static_cast<std::string*>(in->get());
  53   XBT_INFO("Forward '%s'.", msg->c_str());
  54   out->put(msg, msg->size());
  55   return 0;
  56 }
  57
  58 /* Declares a third class of actors which sends a message to the mailbox 'mb42'.
  59  * The sent message is what was passed as parameter on creation (or 'GaBuZoMeu' by default)
  60  *
  61  * Later, this actor class is instantiated twice in the simulation.
  62  */
  63 class Sender {
  64 public:
  65   std::string mbox  = "mb42";
  66   std::string msg = "GaBuZoMeu";
  67   explicit Sender() = default; /* Sending the default message */
  68   explicit Sender(std::string arg) : msg(arg) { /* Sending the specified message */}
  69   explicit Sender(std::vector<std::string> args)
  70   {
  71     /* This constructor is used when we start the actor from the deployment file */
  72     /* args[0] is the actor's name, so the first parameter is args[1] */
  73
  74     xbt_assert(args.size() >= 3, "The sender is expecting 2 parameters from the deployment file but got %zu",
  75                args.size() - 1);
  76     msg  = args[1];
  77     mbox = args[2];
  78   }
  79   void operator()() /* This is the main code of the actor */
  80   {
  81     XBT_INFO("Hello s4u, I have something to send");
  82     simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::by_name(mbox);
  83
  84     mailbox->put(new std::string(msg), msg.size());
  85     XBT_INFO("I'm done. See you.");
  86   }
  87 };
  88
  89 /* Here comes the main function of your program */
  90 int main(int argc, char** argv)
  91 {
  92   /* When your program starts, you have to first start a new simulation engine, as follows */
  93   simgrid::s4u::Engine e(&argc, argv);
  94
  95   /* Then you should load a platform file, describing your simulated platform */
  96   e.load_platform("../../platforms/small_platform.xml");
  97
  98   /* And now you have to ask SimGrid to actually start your actors.
  99    *
 100    * The easiest way to do so is to implement the behavior of your actor in a single function,
 101    * as we do here for the receiver actors. This function can take any kind of parameters, as
 102    * long as the last parameters of Actor::create() match what your function expects.
 103    */
 104   simgrid::s4u::Actor::create("receiver", simgrid::s4u::Host::by_name("Fafard"), &receiver, "mb42");
 105
 106   /* If your actor is getting more complex, you probably want to implement it as a class instead,
 107    * as we do here for the sender actors. The main behavior goes into operator()() of the class.
 108    *
 109    * You can then directly start your actor, as follows: */
 110   simgrid::s4u::Actor::create("sender1", simgrid::s4u::Host::by_name("Tremblay"), Sender());
 111   /* If you want to pass parameters to your class, that's very easy: just use your constructors */
 112   simgrid::s4u::Actor::create("sender2", simgrid::s4u::Host::by_name("Jupiter"), Sender("GloubiBoulga"));
 113
 114   /* But starting actors directly is considered as a bad experimental habit, since it ties the code
 115    * you want to test with the experimental scenario. Starting your actors from an external deployment
 116    * file in XML ensures that you can test your code in several scenarios without changing the code itself.
 117    *
 118    * For that, you first need to register your function or your actor as follows.
 119    * Actor classes must have a (std::vector<std::string>) constructor,
 120    * and actor functions must be of type int(*)(int argc, char**argv). */
 121   e.register_actor<Sender>("sender"); // The sender class is passed as a template parameter here
 122   e.register_function("forwarder", &forwarder);
 123   /* Once actors and functions are registered, just load the deployment file */
 124   e.load_deployment("s4u-actor-create_d.xml");
 125
 126   /* Once every actors are started in the engine, the simulation can start */
 127   e.run();
 128
 129   /* Once the simulation is done, the program is ended */
 130   return 0;
 131 }