StandardJob.h

 
#ifndef WRENCH_STANDARDJOB_H
#define WRENCH_STANDARDJOB_H
 
 
#include <map>
#include <set>
#include <vector>
#include <wrench/workflow/Workflow.h>
#include <wrench/workflow/WorkflowTask.h>
#include <wrench/data_file/DataFile.h>
 
#include "Job.h"
 
#include "wrench/services/storage/storage_helpers/FileLocation.h"
 
namespace wrench {
 
    /***********************/
    /***********************/
 
    class DataFile;
    class WorkflowTask;
    class Action;
 
    class StandardJob : public Job, public std::enable_shared_from_this<StandardJob> {
 
    public:
 
        enum State {
                    NOT_SUBMITTED,
                    PENDING,
                    RUNNING,
                    COMPLETED,
                    FAILED,
                    TERMINATED
        };
 
        std::vector<std::shared_ptr<WorkflowTask>> getTasks();
 
        unsigned long getMinimumRequiredNumCores() const;
 
        unsigned long getMinimumRequiredMemory() const;
 
        unsigned long getNumCompletedTasks() const;
 
        unsigned long getNumTasks() const;
 
        StandardJob::State getState();
 
        bool usesScratch();
 
        std::map<std::shared_ptr<DataFile>, std::vector<std::shared_ptr<FileLocation>>> getFileLocations();
 
 
        std::vector<std::shared_ptr<WorkflowTask>> tasks;
 
        double total_flops;
 
        std::map<std::shared_ptr<DataFile>, std::vector<std::shared_ptr<FileLocation>>> file_locations;
 
        std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  , std::shared_ptr<FileLocation>  >> pre_file_copies;
        std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  , std::shared_ptr<FileLocation>  >> post_file_copies;
        std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  >> cleanup_file_deletions;
 
        std::shared_ptr<StandardJob> getSharedPtr() { return this->shared_from_this(); }
 
        /***********************/
        /***********************/
 
        /***********************/
        /***********************/
 
        double getPreJobOverheadInSeconds();
        void setPreJobOverheadInSeconds(double overhead);
        double getPostJobOverheadInSeconds();
        void setPostJobOverheadInSeconds(double overhead);
 
 
    private:
 
        friend class BareMetalComputeService;
        friend class JobManager;
        friend class ExecutionEvent;
 
        StandardJob(std::shared_ptr<JobManager> job_manager,
                    std::vector<std::shared_ptr<WorkflowTask>> tasks, std::map<std::shared_ptr<DataFile>, std::vector<std::shared_ptr<FileLocation>>> &file_locations,
                    std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  , std::shared_ptr<FileLocation>>> &pre_file_copies,
                    std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  , std::shared_ptr<FileLocation>>> &post_file_copies,
                    std::vector<std::tuple<std::shared_ptr<DataFile>, std::shared_ptr<FileLocation>  >> &cleanup_file_deletions);
 
        void createUnderlyingCompoundJob(const std::shared_ptr<ComputeService>& compute_service);
        void processCompoundJobOutcome(std::map<std::shared_ptr<WorkflowTask>, WorkflowTask::State> &state_changes,
                                       std::set<std::shared_ptr<WorkflowTask>> &failure_count_increments,
                                       std::shared_ptr<FailureCause> &job_failure_cause,
                                       Simulation *simulation);
        void applyTaskUpdates(std::map<std::shared_ptr<WorkflowTask>, WorkflowTask::State> &state_changes,
                                std::set<std::shared_ptr<WorkflowTask>> &failure_count_increments);
 
        void analyzeActions(std::vector<std::shared_ptr<Action>> actions,
                                         bool *at_least_one_failed,
                                         bool *at_least_one_killed,
                                         std::shared_ptr<FailureCause> *failure_cause,
                                         double *earliest_start_date,
                                         double *latest_end_date,
                                         double *earliest_failure_date);
 
 
        State state;
        double pre_overhead = 0.0;
        double post_overhead = 0.0;
 
        std::shared_ptr<CompoundJob> compound_job;
        std::shared_ptr<Action> pre_overhead_action = nullptr;
        std::shared_ptr<Action> post_overhead_action = nullptr;
        std::vector<std::shared_ptr<Action>> pre_file_copy_actions;
        std::map<std::shared_ptr<WorkflowTask>, std::vector<std::shared_ptr<Action>>> task_file_read_actions;
        std::map<std::shared_ptr<WorkflowTask>, std::shared_ptr<Action>> task_compute_actions;
        std::map<std::shared_ptr<WorkflowTask>, std::vector<std::shared_ptr<Action>>> task_file_write_actions;
        std::vector<std::shared_ptr<Action>> post_file_copy_actions;
        std::vector<std::shared_ptr<Action>> cleanup_actions;
        std::shared_ptr<Action> scratch_cleanup = nullptr;
    };
 
    /***********************/
    /***********************/
 
};
 
#endif //WRENCH_MULTITASKJOB_H