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/job/Job.h"
#include "wrench/job/StandardJob.h"
#include "wrench/job/PilotJob.h"
#include "wrench/job/CompoundJob.h"
 
namespace wrench {
 
    class Simulation;
 
    class StorageService;
 
    class ComputeService : public Service {
 
        /***********************/
        /***********************/
 
        friend class Simulation;
 
        /***********************/
        /***********************/
 
 
    public:
 
        static constexpr unsigned long ALL_CORES = ULONG_MAX;
 
        static constexpr double ALL_RAM = DBL_MAX;
 
        /***********************/
        /***********************/
 
 
        enum TerminationCause {
            TERMINATION_NONE,
            TERMINATION_COMPUTE_SERVICE_TERMINATED,
            TERMINATION_JOB_KILLED,
            TERMINATION_JOB_TIMEOUT
        };
 
 
        virtual ~ComputeService() {}
 
        void stop() override;
 
        virtual void stop(bool send_failure_notifications, ComputeService::TerminationCause termination_cause);
 
        void terminateJob(std::shared_ptr<CompoundJob> job);
 
        virtual bool supportsStandardJobs() = 0;
 
        virtual bool supportsCompoundJobs() = 0;
 
        virtual bool supportsPilotJobs() = 0;
 
        virtual bool hasScratch() const;
 
        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
        submitCompoundJob(std::shared_ptr<CompoundJob> job, const std::map<std::string, std::string> &service_specific_arguments) = 0;
 
 
        virtual void terminateCompoundJob(std::shared_ptr<CompoundJob> job) = 0;
 
        std::shared_ptr<StorageService> getScratch();
 
 
 
        ComputeService(const std::string &hostname,
                       std::string service_name,
                       std::string scratch_space_mount_point);
 
    protected:
 
 
        friend class JobManager;
 
        void submitJob(std::shared_ptr<CompoundJob> job, const std::map<std::string, std::string>& = {});
 
        virtual void validateServiceSpecificArguments(std::shared_ptr<CompoundJob> job,
                                                      std::map<std::string, std::string> &service_specific_args) ;
 
        virtual void validateJobsUseOfScratch(std::map<std::string, std::string> &service_specific_args);
 
        ComputeService(const std::string &hostname,
                       std::string service_name,
                       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, double> getServiceResourceInformation(const std::string &desired_entries);
 
    };
 
 
};
 
#endif //SIMULATION_COMPUTESERVICE_H