S4U_Daemon.h

 
#ifndef WRENCH_SIM4U_DAEMON_H
#define WRENCH_SIM4U_DAEMON_H
 
#include <string>
 
#include <simgrid/s4u.hpp>
#include <iostream>
 
//#define ACTOR_TRACKING_OUTPUT yes
 
 
namespace wrench {
 
    /***********************/
    /***********************/
 
    class Simulation;
 
    class S4U_Daemon {
 
        class LifeSaver {
        public:
            explicit LifeSaver(std::shared_ptr<S4U_Daemon> &reference) : reference(reference) {}
 
            std::shared_ptr<S4U_Daemon> reference;
        };
 
 
 
    public:
 
        static std::unordered_map<aid_t , simgrid::s4u::Mailbox*> map_actor_to_recv_mailbox;
 
        std::string process_name;
//        /** @brief The initial name of the daemon's mailbox */
//        std::string initial_mailbox_name;
//        /** @brief The current name of the daemon's mailbox */
//        std::string mailbox_name;
 
        simgrid::s4u::Mailbox *mailbox;
        simgrid::s4u::Mailbox *recv_mailbox;
 
        std::string hostname;
 
        static simgrid::s4u::Mailbox *getRunningActorRecvMailbox();
 
        S4U_Daemon(std::string hostname, std::string process_name_prefix);
 
        // Daemon without a mailbox (not needed?)
//        S4U_Daemon(std::string hostname, std::string process_name_prefix);
 
        virtual ~S4U_Daemon();
 
        void startDaemon(bool _daemonized, bool _auto_restart);
 
        void createLifeSaver(std::shared_ptr<S4U_Daemon> reference);
 
        virtual void cleanup(bool has_returned_from_main, int return_value);
 
        virtual int main() = 0;
 
        bool hasReturnedFromMain();
        int getReturnValue();
        bool isDaemonized();
        bool isSetToAutoRestart();
        void setupOnExitFunction();
 
        std::pair<bool, int> join();
 
        void suspendActor();
 
        void resumeActor();
 
 
        std::string getName();
 
        enum State {
                    UP,
                    DOWN,
                    SUSPENDED,
        };
 
        S4U_Daemon::State getState();
 
        LifeSaver *life_saver = nullptr;
 
        void acquireDaemonLock();
 
        void releaseDaemonLock();
 
        Simulation *getSimulation();
 
        void setSimulation(Simulation *simulation);
 
    protected:
        Simulation *simulation;
 
 
        State state;
 
        friend class S4U_DaemonActor;
        void runMainMethod();
 
        bool killActor();
 
 
 
        unsigned int num_starts = 0;
 
    private:
 
 
        // Lock used typically to prevent kill() from killing the actor
        // while it's in the middle of doing something critical
        simgrid::s4u::MutexPtr daemon_lock;
 
        simgrid::s4u::ActorPtr s4u_actor;
 
        bool has_returned_from_main = false; // Set to true after main returns
        int return_value = 0; // Set to the value returned by main
        bool daemonized; // Set to true if daemon is daemonized
        bool auto_restart; // Set to true if daemon is supposed to auto-restart
 
 
#ifdef ACTOR_TRACKING_OUTPUT
        std::string process_name_prefix;
#endif
 
    };
 
    /***********************/
    /***********************/
};
 
 
#endif //WRENCH_SIM4U_DAEMONWITHMAILBOX_H