#include <utility>
#include <vector>
-#include <boost/intrusive_ptr.hpp>
-
#include <xbt/Extendable.hpp>
-#include <xbt/base.h>
#include <xbt/functional.hpp>
#include <xbt/string.hpp>
#include <simgrid/chrono.hpp>
-#include <simgrid/simix.h>
#include <simgrid/s4u/forward.hpp>
namespace simgrid {
Actor(Actor const&) = delete;
Actor& operator=(Actor const&) = delete;
- // ***** Reference count (delegated to pimpl_) *****
- friend void intrusive_ptr_add_ref(Actor* actor)
- {
- xbt_assert(actor != nullptr);
- SIMIX_process_ref(actor->pimpl_);
- }
- friend void intrusive_ptr_release(Actor* actor)
- {
- xbt_assert(actor != nullptr);
- SIMIX_process_unref(actor->pimpl_);
- }
+ // ***** Reference count *****
+ friend void intrusive_ptr_add_ref(Actor * actor);
+ friend void intrusive_ptr_release(Actor * actor);
// ***** Actor creation *****
/** Retrieve a reference to myself */
*/
static ActorPtr createActor(const char* name, s4u::Host* host, std::function<void()> code);
+ static ActorPtr createActor(const char* name, s4u::Host* host, std::function<void(std::vector<std::string>*)> code,
+ std::vector<std::string>* args)
+ {
+ return createActor(name, host, [code](std::vector<std::string>* args) { code(args); }, args);
+ }
+
/** Create an actor using code
*
* Using this constructor, move-only type can be used. The consequence is
static ActorPtr createActor(const char* name, s4u::Host* host, const char* function, std::vector<std::string> args);
// ***** Methods *****
+ /** This actor will be automatically terminated when the last non-daemon process finishes **/
+ void daemonize();
/** Retrieves the name of that actor as a C string */
const char* cname();
* This blocks the calling actor until the actor on which we call join() is terminated
*/
void join();
-
+
// Static methods on all actors:
/** Ask kindly to all actors to die. Only the issuer will survive. */
* @brief Static methods working on the current actor (see @ref s4u::Actor) */
namespace this_actor {
- /** Block the actor sleeping for that amount of seconds (may throws hostFailure) */
- XBT_PUBLIC(void) sleep_for(double duration);
- XBT_PUBLIC(void) sleep_until(double timeout);
+XBT_PUBLIC(bool) isMaestro();
- template<class Rep, class Period>
- inline void sleep_for(std::chrono::duration<Rep, Period> duration)
- {
- auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
- this_actor::sleep_for(seconds.count());
+/** Block the actor sleeping for that amount of seconds (may throws hostFailure) */
+XBT_PUBLIC(void) sleep_for(double duration);
+XBT_PUBLIC(void) sleep_until(double timeout);
+
+template <class Rep, class Period> inline void sleep_for(std::chrono::duration<Rep, Period> duration)
+{
+ auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
+ this_actor::sleep_for(seconds.count());
}
template<class Duration>
inline void sleep_until(const SimulationTimePoint<Duration>& timeout_time)
* See \ref Comm for the full communication API (including non blocking communications).
*/
XBT_PUBLIC(void*) recv(MailboxPtr chan);
+ XBT_PUBLIC(void*) recv(MailboxPtr chan, double timeout);
XBT_PUBLIC(CommPtr) irecv(MailboxPtr chan, void** data);
/** Block the actor until it delivers a message of the given simulated size to the given mailbox