energy.hpp

#ifndef MAMMUT_ENERGY_HPP_
#define MAMMUT_ENERGY_HPP_

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

namespace mammut{
namespace energy{

typedef double Joules;
class JoulesCpu;

typedef enum{
    COUNTER_CPUS = 0,// Power measured at CPU level
    COUNTER_PLUG, // Power measured at the plug
}CounterType;

/*
 * ! \class Counter
 *   \brief A generic energy counter.
 *
 *   A generic energy counter.
 */
class Counter{
public:
    virtual ~Counter(){;}

    virtual Joules getJoules() = 0;

    virtual void reset() = 0;

    virtual bool init() = 0;

    virtual CounterType getType() = 0;
};

/*
 * ! \class CounterPlug
 *   \brief A plug energy counter.
 *
 *   A plug energy counter.
 */
class CounterPlug: public Counter{
public:
    virtual Joules getJoules() = 0;
    virtual void reset() = 0;
    virtual bool init() = 0;
    CounterType getType(){return COUNTER_PLUG;}
};

/*
 * ! \class CounterCpus
 *   \brief A CPUs energy counter.
 *
 *   A CPUs energy counter.
 */
class CounterCpus: public Counter{
protected:
    topology::Topology* _topology;
    std::vector<topology::Cpu*> _cpus;
    CounterCpus(topology::Topology* topology);
public:
    const std::vector<topology::Cpu*>& getCpus(){return _cpus;}

    virtual JoulesCpu getJoulesComponents(topology::CpuId cpuId) = 0;

    JoulesCpu getJoulesComponents(topology::Cpu* cpu);

    virtual JoulesCpu getJoulesComponentsAll();

    virtual Joules getJoulesCpu(topology::CpuId cpuId) = 0;

    Joules getJoulesCpu(topology::Cpu* cpu);

    virtual Joules getJoulesCpuAll();

    virtual Joules getJoulesCores(topology::CpuId cpuId) = 0;

    Joules getJoulesCores(topology::Cpu* cpu);

    virtual Joules getJoulesCoresAll();

    virtual bool hasJoulesGraphic() = 0;

    virtual Joules getJoulesGraphic(topology::CpuId cpuId) = 0;

    Joules getJoulesGraphic(topology::Cpu* cpu);

    virtual Joules getJoulesGraphicAll();

    virtual bool hasJoulesDram() = 0;

    virtual Joules getJoulesDram(topology::CpuId cpuId) = 0;

    Joules getJoulesDram(topology::Cpu* cpu);

    virtual Joules getJoulesDramAll();

    Joules getJoules();
    virtual void reset() = 0;
    virtual bool init() = 0;
    virtual ~CounterCpus(){;}
    CounterType getType(){return COUNTER_CPUS;}
};

class Energy: public Module{
    MAMMUT_MODULE_DECL(Energy)
private:
    CounterPlug* _counterPlug;
    CounterCpus* _counterCpus;
    Energy();
    Energy(Communicator* const communicator);
    ~Energy();
    bool processMessage(const std::string& messageIdIn, const std::string& messageIn,
                        std::string& messageIdOut, std::string& messageOut);
public:
    Counter* getCounter() const;

    std::vector<CounterType> getCountersTypes() const;

    Counter* getCounter(CounterType type) const;
};


class JoulesCpu{
    friend std::ostream& operator<<(std::ostream& os, const JoulesCpu& obj);
public:
    Joules cpu;
    Joules cores;
    Joules graphic;
    Joules dram;

    JoulesCpu():cpu(0), cores(0), graphic(0), dram(0){;}

    JoulesCpu(Joules cpu, Joules cores, Joules graphic, Joules dram):
        cpu(cpu), cores(cores), graphic(graphic), dram(dram){;}

    void zero(){cpu = 0; cores = 0; graphic = 0; dram = 0;}

    void swap(JoulesCpu& x){
        using std::swap;

        swap(cpu, x.cpu);
        swap(cores, x.cores);
        swap(graphic, x.graphic);
        swap(dram, x.dram);
    }

    JoulesCpu& operator=(JoulesCpu rhs){
        swap(rhs);
        return *this;
    }

    JoulesCpu& operator+=(const JoulesCpu& rhs){
        cpu += rhs.cpu;
        cores += rhs.cores;
        graphic += rhs.graphic;
        dram += rhs.dram;
        return *this;
    }

    JoulesCpu& operator-=(const JoulesCpu& rhs){
        cpu -= rhs.cpu;
        cores -= rhs.cores;
        graphic -= rhs.graphic;
        dram -= rhs.dram;
        return *this;
    }

    JoulesCpu& operator*=(const JoulesCpu& rhs){
        cpu *= rhs.cpu;
        cores *= rhs.cores;
        graphic *= rhs.graphic;
        dram *= rhs.dram;
        return *this;
    }

    JoulesCpu& operator/=(const JoulesCpu& rhs){
        cpu /= rhs.cpu;
        cores /= rhs.cores;
        graphic /= rhs.graphic;
        dram /= rhs.dram;
        return *this;
    }

    JoulesCpu operator/=(double x){
        cpu /= x;
        cores /= x;
        graphic /= x;
        dram /= x;
        return *this;
    }

    JoulesCpu operator*=(double x){
        cpu *= x;
        cores *= x;
        graphic *= x;
        dram *= x;
        return *this;
    }
};

inline JoulesCpu operator+(const JoulesCpu& lhs, const JoulesCpu& rhs){
    JoulesCpu r = lhs;
    r += rhs;
    return r;
}

inline JoulesCpu operator-(const JoulesCpu& lhs, const JoulesCpu& rhs){
    JoulesCpu r = lhs;
    r -= rhs;
    return r;
}

inline JoulesCpu operator*(const JoulesCpu& lhs, const JoulesCpu& rhs){
    JoulesCpu r = lhs;
    r *= rhs;
    return r;
}

inline JoulesCpu operator/(const JoulesCpu& lhs, const JoulesCpu& rhs){
    JoulesCpu r = lhs;
    r /= rhs;
    return r;
}

inline JoulesCpu operator/(const JoulesCpu& lhs, double x){
    JoulesCpu r = lhs;
    r /= x;
    return r;
}

inline JoulesCpu operator*(const JoulesCpu& lhs, double x){
    JoulesCpu r = lhs;
    r *= x;
    return r;
}

inline std::ostream& operator<<(std::ostream& os, const JoulesCpu& obj){
    os << obj.cpu << "\t";
    os << obj.cores << "\t";
    os << obj.graphic << "\t";
    os << obj.dram << "\t";
    return os;
}

}
}

#endif /* MAMMUT_ENERGY_HPP_ */