Action.h

 
#ifndef WRENCH_ACTION_H
#define WRENCH_ACTION_H
 
#include <memory>
#include <string>
#include <set>
#include <stack>
#include <iostream>
 
namespace wrench {
 
    class CompoundJob;
    class FailureCause;
    class ActionExecutor;
 
    class Action : public std::enable_shared_from_this<Action> {
 
    public:
 
        enum State {
            NOT_READY,
            READY,
            STARTED,
            COMPLETED,
            KILLED,
            FAILED
        };
 
        const std::string &getName() const;
        std::shared_ptr<CompoundJob> getJob() const;
        Action::State getState() const;
        std::string getStateAsString() const;
        static std::string stateToString(Action::State state);
 
        double getStartDate() const;
        double getEndDate() const;
        std::shared_ptr<FailureCause> getFailureCause() const;
 
        std::set<std::shared_ptr<Action>> getChildren();
 
        std::set<std::shared_ptr<Action>> getParents();
 
        virtual unsigned long getMinNumCores() const;
        virtual unsigned long getMaxNumCores() const;
        virtual double getMinRAMFootprint() const;
 
        virtual bool usesScratch() const;
 
        void setPriority(double priority);
        double getPriority() const;
 
        void setSimulateComputationAsSleep(bool simulate_computation_as_sleep);
        void setThreadCreationOverhead(double overhead_in_seconds);
 
        static std::string getActionTypeAsString(const std::shared_ptr<Action>& action);
 
        struct ActionExecution {
            double start_date = -1.0;
            double end_date = -1.0;
            Action::State state;
            std::string execution_host;
            std::string physical_execution_host;
            unsigned long num_cores_allocated = 0;
            double ram_allocated = 0;
            std::shared_ptr<FailureCause> failure_cause;
        };
 
        std::stack<Action::ActionExecution> &getExecutionHistory();
 
        std::shared_ptr<Action> getSharedPtr() { return this->shared_from_this(); }
 
    protected:
 
        friend class CompoundJob;
        friend class ActionExecutor;
        friend class ActionExecutionService;
        friend class BareMetalComputeService; // this is a bit unfortunate (to call setFailureCause - perhaps go through CompoundJob?)
        friend class BatchComputeService; // this is a bit unfortunate (to call setFailureCause - perhaps go through CompoundJob?)
 
        void newExecution(Action::State state);
 
        void setStartDate(double date);
        void setEndDate(double date);
        void setState(Action::State new_state);
        void setExecutionHost(std::string host);
        void setNumCoresAllocated(unsigned long num_cores);
        void setRAMAllocated(double ram);
        void setFailureCause(std::shared_ptr<FailureCause> failure_cause);
 
        virtual ~Action() = default;
 
        Action(const std::string& name, const std::string& prefix, std::shared_ptr<CompoundJob> job);
 
        virtual void execute(std::shared_ptr<ActionExecutor> action_executor) = 0;
        virtual void terminate(std::shared_ptr<ActionExecutor> action_executor) = 0;
 
        void updateState();
 
        double thread_creation_overhead;
        bool simulate_computation_as_sleep;
 
    private:
 
        std::set<Action*> parents;
        std::set<Action*> children;
 
        double priority;
 
        std::string name;
        std::weak_ptr<CompoundJob> job;
 
        std::map<std::string, std::string> service_specific_arguments;
 
        static unsigned long getNewUniqueNumber();
 
        std::stack<ActionExecution> execution_history;
 
    };
}
 
#endif //WRENCH_ACTION_H