S4U_Simulation.h

 
#ifndef WRENCH_S4U_SIMULATION_H
#define WRENCH_S4U_SIMULATION_H
 
#include <set>
#include <simgrid/s4u.hpp>
#include <simgrid/kernel/routing/ClusterZone.hpp>
 
namespace wrench {
 
 
    /***********************/
    /***********************/
 
    class S4U_Simulation {
 
    public:
        static constexpr double DEFAULT_RAM = (1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0); // 1 PiB
 
    public:
        void initialize(int *argc, char **argv);
        void setupPlatform(std::string&);
        void runSimulation();
        static double getClock();
        static std::string getHostName();
        static bool hostExists(std::string hostname);
        static bool linkExists(std::string linkname);
        static std::vector<std::string> getRoute(std::string &src_host, std::string &dst_host);
        static unsigned int getHostNumCores(std::string hostname);
        static unsigned int getNumCores();
        static double getHostFlopRate(std::string hostname);
        static bool isHostOn(std::string hostname);
        static void turnOffHost(std::string hostname);
        static void turnOnHost(std::string hostname);
        static bool isLinkOn(std::string linkname);
        static void turnOffLink(std::string linkname);
        static void turnOnLink(std::string linkname);
        static double getFlopRate();
        static double getHostMemoryCapacity(std::string hostname);
        static double getMemoryCapacity();
        static void compute(double);
        static void sleep(double);
        static void computeZeroFlop();
        static void writeToDisk(double num_bytes, std::string hostname, std::string mount_point);
        static void readFromDisk(double num_bytes, std::string hostname, std::string mount_point);
        static void readFromDiskAndWriteToDiskConcurrently(double num_bytes_to_read, double num_bytes_to_write,
                                                                           std::string hostname,
                                                                           std::string read_mount_point,
                                                                           std::string write_mount_point);
 
        static double getDiskCapacity(std::string hostname, std::string mount_point);
        static std::vector<std::string> getDisks(std::string hostname);
        static bool hostHasMountPoint(std::string hostname, std::string mount_point);
 
        void checkLinkBandwidths();
 
        static void yield();
        static std::string getHostProperty(std::string hostname, std::string property_name);
 
        //start energy related calls
        static double getEnergyConsumedByHost(const std::string &hostname);
//      static double getTotalEnergyConsumed(const std::vector<std::string> &hostnames);
        static void setPstate(const std::string &hostname, int pstate);
        static int getNumberofPstates(const std::string &hostname);
        static int getCurrentPstate(const std::string &hostname);
        static double getMinPowerConsumption(const std::string &hostname);
        static double getMaxPowerConsumption(const std::string &hostname);
        static std::vector<int> getListOfPstates(const std::string &hostname);
        //end energy related calls
 
        bool isInitialized();
        bool isPlatformSetup();
        static std::vector<std::string> getAllHostnames();
        static std::vector<std::string> getAllLinknames();
        static double getLinkBandwidth(std::string name);
        static double getLinkUsage(std::string name);
        static std::map<std::string, std::vector<std::string>> getAllHostnamesByCluster();
        void shutdown();
 
    private:
        static double getHostMemoryCapacity(simgrid::s4u::Host *host);
        simgrid::s4u::Engine *engine;
        bool initialized = false;
        bool platform_setup = false;
 
    };
 
    /***********************/
    /***********************/
};
 
#endif //WRENCH_S4U_SIMULATION_H