SimulationTimestampTypes.h

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