ComputeService.h

 
#ifndef SIMULATION_COMPUTESERVICE_H
#define SIMULATION_COMPUTESERVICE_H
 
#include <map>
 
#include <iostream>
#include <cfloat>
#include <climits>
 
#include "wrench/services/Service.h"
#include "wrench/workflow/job/WorkflowJob.h"
#include "wrench/workflow/job/StandardJob.h"
#include "wrench/workflow/job/PilotJob.h"
 
namespace wrench {
 
    class Simulation;
 
    class StorageService;
 
    class ComputeService : public Service {
 
        /***********************/
        /***********************/
 
        friend class StandardJobExecutorTest;
        friend class Simulation;
 
        /***********************/
        /***********************/
 
 
    public:
 
        static constexpr unsigned long ALL_CORES = ULONG_MAX;
 
        static constexpr double ALL_RAM = DBL_MAX;
 
        /***********************/
        /***********************/
 
        virtual ~ComputeService() {}
 
        void stop() override;
 
//        void submitJob(WorkflowJob *job, const std::map<std::string, std::string>& = {});
 
        void terminateJob(std::shared_ptr<WorkflowJob> job);
 
        bool supportsStandardJobs();
 
        bool supportsPilotJobs();
 
        bool hasScratch();
 
        unsigned long getNumHosts();
 
        std::vector<std::string> getHosts();
 
        std::map<std::string, unsigned long> getPerHostNumCores();
 
        unsigned long getTotalNumCores();
 
        std::map<std::string, unsigned long> getPerHostNumIdleCores();
 
        virtual unsigned long getTotalNumIdleCores();
 
        virtual bool isThereAtLeastOneHostWithIdleResources(unsigned long num_cores, double ram);
 
        std::map<std::string, double> getMemoryCapacity();
 
        std::map<std::string, double> getPerHostAvailableMemoryCapacity();
 
        std::map<std::string, double> getCoreFlopRate();
 
        double getTTL();
 
        double getTotalScratchSpaceSize();
 
        double getFreeScratchSpaceSize();
 
 
        /***********************/
        /***********************/
 
        /***********************/
        /***********************/
 
        virtual void
        submitStandardJob(std::shared_ptr<StandardJob> job, const std::map<std::string, std::string> &service_specific_arguments) = 0;
 
        virtual void submitPilotJob(std::shared_ptr<PilotJob> job, const std::map<std::string, std::string> &service_specific_arguments) = 0;
 
        virtual void terminateStandardJob(std::shared_ptr<StandardJob> job) = 0;
 
        virtual void terminatePilotJob(std::shared_ptr<PilotJob> job) = 0;
 
        std::shared_ptr<StorageService> getScratch();
 
 
        ComputeService(const std::string &hostname,
                       std::string service_name,
                       std::string mailbox_name_prefix,
                       std::string scratch_space_mount_point);
 
    protected:
 
        friend class JobManager;
 
        void submitJob(std::shared_ptr<WorkflowJob> job, const std::map<std::string, std::string>& = {});
 
        ComputeService(const std::string &hostname,
                       std::string service_name,
                       std::string mailbox_name_prefix,
                       std::shared_ptr<StorageService> scratch_space);
 
        std::shared_ptr<StorageService> scratch_space_storage_service;
 
        /***********************/
        /***********************/
 
        /***********************/
        /***********************/
 
        std::shared_ptr<StorageService> getScratchSharedPtr();
 
        /***********************/
        /***********************/
 
    private:
 
 
        std::shared_ptr<StorageService> scratch_space_storage_service_shared_ptr;
 
        std::map<std::string, std::map<std::string, double>> getServiceResourceInformation();
 
    };
 
 
};
 
#endif //SIMULATION_COMPUTESERVICE_H