SimulationTimestampTypes.h

 
#ifndef WRENCH_SIMULATIONTIMESTAMPTYPES_H
#define WRENCH_SIMULATIONTIMESTAMPTYPES_H
 
 
#include "wrench/workflow/WorkflowTask.h"
#include <unordered_map>
 
using namespace std;
/***********************/
/***********************/
 
typedef std::tuple<void *, void *, void *> File;
typedef std::tuple<std::string, std::string, int> DiskAccess;
 
namespace std {
    template <>
    struct hash<File>{
    public :
        size_t operator()(const File &file ) const
        {
            return std::hash<void *>()(std::get<0>(file)) ^ std::hash<void *>()(std::get<1>(file)) ^ std::hash<void *>()(std::get<2>(file));
        }
    };
 
    template <>
    struct hash<DiskAccess>{
    public :
        size_t operator()(const DiskAccess &diskAccess ) const
        {
            return std::hash<std::string>()(std::get<0>(diskAccess)) ^ std::hash<std::string>()(std::get<1>(diskAccess)) ^ std::hash<int>()(std::get<2>(diskAccess));
        }
    };
};
 
/***********************/
/***********************/
 
namespace wrench {
 
 
    class WorkflowTask;
    class StorageService;
    class FileLocation;
 
 
 
    class SimulationTimestampType {
    public:
        SimulationTimestampType();
        double getDate();
 
    private:
        friend  class SimulationOutput;
        void setDate(double date);
        double date = -0.1;
    };
 
    class SimulationTimestampPair : public SimulationTimestampType {
    public:
        /***********************/
        /***********************/
        SimulationTimestampPair();
        SimulationTimestampPair(SimulationTimestampPair *endpoint);
        virtual ~SimulationTimestampPair() = default;
        /***********************/
        /***********************/
 
        virtual SimulationTimestampPair *getEndpoint();
 
    protected:
        SimulationTimestampPair *endpoint = nullptr;
    };
 
    class SimulationTimestampTask : public SimulationTimestampPair {
 
    public:
 
        WorkflowTask *getTask();
        SimulationTimestampTask *getEndpoint() override;
 
    protected:
        static std::map<std::string, SimulationTimestampTask *> pending_task_timestamps;
        void setEndpoints();
        explicit SimulationTimestampTask(WorkflowTask *);
 
    private:
        friend class SimulationOutput;
        WorkflowTask *task;
    };
 
    class SimulationTimestampTaskStart : public SimulationTimestampTask {
    private:
        friend class SimulationOutput;
        explicit SimulationTimestampTaskStart(WorkflowTask *task);
    };
 
    class SimulationTimestampTaskFailure : public SimulationTimestampTask {
    private:
        friend class SimulationOutput;
        explicit SimulationTimestampTaskFailure(WorkflowTask *task);
    };
 
    class SimulationTimestampTaskCompletion : public SimulationTimestampTask {
    private:
        friend class SimulationOutput;
        explicit SimulationTimestampTaskCompletion(WorkflowTask *);
    };
 
     class SimulationTimestampTaskTermination : public SimulationTimestampTask {
     private:
         friend class SimulationOutput;
         explicit SimulationTimestampTaskTermination(WorkflowTask *);
     };
 
    class SimulationTimestampFileReadStart;
 
 
    class SimulationTimestampFileRead : public SimulationTimestampPair {
    public:
 
        SimulationTimestampFileRead *getEndpoint() override;
        WorkflowFile *getFile();
        FileLocation *getSource();
        StorageService *getService();
        WorkflowTask *getTask();
 
    protected:
        WorkflowFile *file;
 
        FileLocation *source;
 
        StorageService *service;
 
         WorkflowTask *task;
 
        static std::unordered_multimap<File, std::pair<SimulationTimestampFileRead *, WorkflowTask *>> pending_file_reads;
 
        void setEndpoints();
        friend class SimulationOutput;
        SimulationTimestampFileRead(WorkflowFile *file, FileLocation *src, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileReadFailure;
    class SimulationTimestampFileReadCompletion;
 
    class SimulationTimestampFileReadStart : public SimulationTimestampFileRead {
    public:
        friend class SimulationOutput;
        SimulationTimestampFileReadStart(WorkflowFile *file, FileLocation *src, StorageService *service, WorkflowTask *task = nullptr);
 
        friend class SimulationTimestampFileReadFailure;
        friend class SimulationTimestampFileReadCompletion;
    };
 
    class SimulationTimestampFileReadFailure : public SimulationTimestampFileRead {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileReadFailure(WorkflowFile *file, FileLocation *src, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileReadCompletion : public SimulationTimestampFileRead {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileReadCompletion(WorkflowFile *file, FileLocation *src, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileWriteStart;
 
 
    class SimulationTimestampFileWrite : public SimulationTimestampPair {
    public:
 
        SimulationTimestampFileWrite *getEndpoint() override;
        WorkflowFile *getFile();
        FileLocation *getDestination();
        StorageService *getService();
        WorkflowTask *getTask();
 
    protected:
        WorkflowFile *file;
 
        FileLocation *destination;
 
        StorageService *service;
 
         WorkflowTask *task;
 
        static std::unordered_multimap<File, std::pair<SimulationTimestampFileWrite *, WorkflowTask *>> pending_file_writes;
 
        void setEndpoints();
 
        friend class SimulationOutput;
        SimulationTimestampFileWrite(WorkflowFile *file, FileLocation *dst, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileWriteFailure;
    class SimulationTimestampFileWriteCompletion;
 
    class SimulationTimestampFileWriteStart : public SimulationTimestampFileWrite {
    private:
        friend class SimulationOutput;
        friend class SimulationTimestampFileWriteFailure;
        friend class SimulationTimestampFileWriteCompletion;
        SimulationTimestampFileWriteStart(WorkflowFile *file, FileLocation *dst, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileWriteFailure : public SimulationTimestampFileWrite {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileWriteFailure(WorkflowFile *file, FileLocation *dst, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileWriteCompletion : public SimulationTimestampFileWrite {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileWriteCompletion(WorkflowFile *file, FileLocation *dst, StorageService *service, WorkflowTask *task = nullptr);
    };
 
    class SimulationTimestampFileCopyStart;
    class FileLocation;
 
    class SimulationTimestampFileCopy : public SimulationTimestampPair {
    public:
 
        SimulationTimestampFileCopy *getEndpoint() override;
        WorkflowFile *getFile();
        std::shared_ptr<FileLocation> getSource();
        std::shared_ptr<FileLocation> getDestination();
 
    protected:
        SimulationTimestampFileCopy(WorkflowFile *file, std::shared_ptr<FileLocation>  src, std::shared_ptr<FileLocation> dst);
 
        WorkflowFile *file;
 
        std::shared_ptr<FileLocation> source;
 
        std::shared_ptr<FileLocation> destination;
 
         static std::unordered_multimap<File, SimulationTimestampFileCopy *> pending_file_copies;
 
        void setEndpoints();
    };
 
    class SimulationTimestampFileCopyFailure;
    class SimulationTimestampFileCopyCompletion;
 
    class SimulationTimestampFileCopyStart : public SimulationTimestampFileCopy {
    private:
        friend class SimulationOutput;
        friend class SimulationTimestampFileCopyFailure;
        friend class SimulationTimestampFileCopyCompletion;
        SimulationTimestampFileCopyStart(WorkflowFile *file, std::shared_ptr<FileLocation> src, std::shared_ptr<FileLocation> dst);
    };
 
    class SimulationTimestampFileCopyFailure : public SimulationTimestampFileCopy {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileCopyFailure(WorkflowFile *file, std::shared_ptr<FileLocation>  src, std::shared_ptr<FileLocation> dst);
    };
 
    class SimulationTimestampFileCopyCompletion : public SimulationTimestampFileCopy {
    private:
        friend class SimulationOutput;
        SimulationTimestampFileCopyCompletion(WorkflowFile *file, std::shared_ptr<FileLocation>  src, std::shared_ptr<FileLocation> dst);
    };
 
    class SimulationTimestampDiskReadStart;
 
 
    class SimulationTimestampDiskRead : public SimulationTimestampPair {
    public:
 
        SimulationTimestampDiskRead *getEndpoint() override;
        double getBytes();
        std::string getHostname();
        std::string getMount();
        int getCounter();
 
    protected:
        std::string hostname;
 
        std::string mount;
 
        double bytes;
 
        int counter;
 
 
        static std::unordered_multimap<DiskAccess, SimulationTimestampDiskRead *> pending_disk_reads;
 
        void setEndpoints();
        friend class SimulationOutput;
        SimulationTimestampDiskRead(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampDiskReadFailure;
    class SimulationTimestampDiskReadCompletion;
 
    class SimulationTimestampDiskReadStart : public SimulationTimestampDiskRead {
    public:
        friend class SimulationOutput;
        SimulationTimestampDiskReadStart(std::string hostname, std::string mount, double bytes, int counter);
 
        friend class SimulationTimestampDiskReadFailure;
        friend class SimulationTimestampDiskReadCompletion;
    };
 
    class SimulationTimestampDiskReadFailure : public SimulationTimestampDiskRead {
    private:
        friend class SimulationOutput;
        SimulationTimestampDiskReadFailure(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampDiskReadCompletion : public SimulationTimestampDiskRead {
    private:
        friend class SimulationOutput;
        SimulationTimestampDiskReadCompletion(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampDiskWriteStart;
 
 
    class SimulationTimestampDiskWrite : public SimulationTimestampPair {
    public:
 
        SimulationTimestampDiskWrite *getEndpoint() override;
        double getBytes();
        std::string getHostname();
        std::string getMount();
        int getCounter();
 
    protected:
 
        std::string hostname;
 
        std::string mount;
 
        double bytes;
 
        int counter;
 
        static std::unordered_multimap<DiskAccess, SimulationTimestampDiskWrite *> pending_disk_writes;
 
        void setEndpoints();
        friend class SimulationOutput;
        SimulationTimestampDiskWrite(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampDiskWriteFailure;
    class SimulationTimestampDiskWriteCompletion;
 
    class SimulationTimestampDiskWriteStart : public SimulationTimestampDiskWrite {
    public:
        friend class SimulationOutput;
        SimulationTimestampDiskWriteStart(std::string hostname, std::string mount, double bytes, int counter);
 
        friend class SimulationTimestampDiskWriteFailure;
        friend class SimulationTimestampDiskWriteCompletion;
    };
 
    class SimulationTimestampDiskWriteFailure : public SimulationTimestampDiskWrite {
    private:
        friend class SimulationOutput;
        SimulationTimestampDiskWriteFailure(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampDiskWriteCompletion : public SimulationTimestampDiskWrite {
    private:
        friend class SimulationOutput;
        SimulationTimestampDiskWriteCompletion(std::string hostname, std::string mount, double bytes, int counter);
    };
 
    class SimulationTimestampPstateSet : public SimulationTimestampType {
    public:
        std::string getHostname();
        int getPstate();
 
    private:
        friend class SimulationOutput;
        SimulationTimestampPstateSet(std::string hostname, int pstate);
        std::string hostname;
        int pstate;
    };
 
    class SimulationTimestampEnergyConsumption: public SimulationTimestampType {
    public:
        std::string getHostname();
        double getConsumption();
 
    private:
        friend class SimulationOutput;
        SimulationTimestampEnergyConsumption(std::string hostname, double joules);
        std::string hostname;
        double joules;
    };
 
    class SimulationTimestampLinkUsage: public SimulationTimestampType {
    public:
        std::string getLinkname();
        double getUsage();
 
    private:
        friend class SimulationOutput;
        SimulationTimestampLinkUsage(std::string linkname, double bytes_per_second);
        std::string linkname;
        double bytes_per_second;
    };
};
 
#endif //WRENCH_SIMULATIONTIMESTAMPTYPES_H