cpufreq.hpp

#ifndef MAMMUT_CPUFREQ_HPP_
#define MAMMUT_CPUFREQ_HPP_

#include "../communicator.hpp"
#include "../module.hpp"
#include "../topology/topology.hpp"
#include "../utils.hpp"

#include "map"
#include "stddef.h"
#include "stdint.h"
#include "string"
#include "vector"

namespace mammut{
namespace cpufreq{

typedef enum{
    GOVERNOR_CONSERVATIVE,
    GOVERNOR_ONDEMAND,
    GOVERNOR_INTERACTIVE,
    GOVERNOR_USERSPACE,
    GOVERNOR_POWERSAVE,
    GOVERNOR_PERFORMANCE,
    GOVERNOR_NUM
}Governor;

typedef uint32_t Frequency;
typedef double Voltage;
typedef uint32_t DomainId;

typedef std::pair<topology::VirtualCoreId, Frequency> VoltageTableKey;
typedef std::map<VoltageTableKey, Voltage> VoltageTable;
typedef std::map<VoltageTableKey, Voltage>::const_iterator VoltageTableIterator;

struct RollbackPoint{
    DomainId domainId;
    Frequency frequency;
    Frequency lowerBound;
    Frequency upperBound;
    Governor governor;
};

class Domain{
    const DomainId _domainIdentifier;
protected:
    const std::vector<topology::VirtualCore*> _virtualCores;

    Domain(DomainId domainIdentifier, std::vector<topology::VirtualCore*> virtualCores);
public:
    virtual inline ~Domain(){;}

    std::vector<topology::VirtualCore*> getVirtualCores() const;

    std::vector<topology::VirtualCoreId> getVirtualCoresIdentifiers() const;

    bool contains(const topology::VirtualCore* virtualCore) const;

    DomainId getId() const;

    RollbackPoint getRollbackPoint() const;

    void rollback(const RollbackPoint& rollbackPoint) const;

    virtual std::vector<Frequency> getAvailableFrequencies() const = 0;

    virtual std::vector<Governor> getAvailableGovernors() const = 0;

    bool isGovernorAvailable(Governor governor) const;

    virtual Frequency getCurrentFrequency() const = 0;

    virtual Frequency getCurrentFrequencyUserspace() const = 0;

    virtual bool setFrequencyUserspace(Frequency frequency) const = 0;

    bool setHighestFrequencyUserspace() const;

    bool setLowestFrequencyUserspace() const;

    virtual Governor getCurrentGovernor() const = 0;

    virtual bool setGovernor(Governor governor) const = 0;

    virtual void getHardwareFrequencyBounds(Frequency& lowerBound, Frequency& upperBound) const = 0;

    virtual bool getCurrentGovernorBounds(Frequency& lowerBound, Frequency& upperBound) const = 0;

    virtual bool setGovernorBounds(Frequency lowerBound, Frequency upperBound) const = 0;

    virtual int getTransitionLatency() const = 0;

    virtual Voltage getCurrentVoltage() const = 0;


    virtual VoltageTable getVoltageTable(bool onlyPhysicalCores = true) const = 0;

    virtual VoltageTable getVoltageTable(uint numVirtualCores,
                                         bool onlyPhysicalCores) const = 0;
};

class CpuFreq: public Module{
    MAMMUT_MODULE_DECL(CpuFreq)
private:
    bool processMessage(const std::string& messageIdIn, const std::string& messageIn,
                        std::string& messageIdOut, std::string& messageOut);
protected:
    virtual ~CpuFreq(){;}
    static std::vector<topology::VirtualCore*> filterVirtualCores(const std::vector<topology::VirtualCore*>& virtualCores,
                                                      const std::vector<topology::VirtualCoreId>& identifiers);
public:
    virtual std::vector<Domain*> getDomains() const = 0;

    Domain* getDomain(const topology::VirtualCore* virtualCore) const;

    std::vector<Domain*> getDomains(const std::vector<topology::VirtualCore*>& virtualCores) const;

    std::vector<Domain*> getDomains(const topology::PhysicalCore* physicalCore) const;

    std::vector<Domain*> getDomains(const topology::Cpu* cpu) const;

    std::vector<Domain*> getDomainsComplete(const std::vector<topology::VirtualCore*>& virtualCores) const;

    std::vector<RollbackPoint> getRollbackPoints() const;

    void rollback(const std::vector<RollbackPoint>& rollbackPoints) const;

    bool isGovernorAvailable(Governor governor) const;

    virtual bool isBoostingSupported() const = 0;

    virtual bool isBoostingEnabled() const = 0;

    virtual void enableBoosting() const = 0;

    virtual void disableBoosting() const = 0;

    static std::string getGovernorNameFromGovernor(Governor governor);

    static Governor getGovernorFromGovernorName(const std::string& governorName);
};


void loadVoltageTable(VoltageTable& voltageTable, std::string fileName);

void dumpVoltageTable(const VoltageTable& voltageTable, std::string fileName);

}
}

#endif /* MAMMUT_CPUFREQ_HPP_ */