topology.hpp

#ifndef MAMMUT_TOPOLOGY_HPP_
#define MAMMUT_TOPOLOGY_HPP_

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

#include "stdint.h"
#include "vector"

namespace mammut{
namespace topology{

class VirtualCore;
class PhysicalCore;
class Cpu;

typedef uint32_t CpuId;
typedef uint32_t PhysicalCoreId;
typedef uint32_t VirtualCoreId;

// @cond HIDDEN_SYMBOLS
typedef struct{
    CpuId cpuId;
    PhysicalCoreId physicalCoreId;
    VirtualCoreId virtualCoreId;
}VirtualCoreCoordinates;
// @endcond

class Unit{
public:
    inline virtual ~Unit(){;}

    virtual void maximizeUtilization() const = 0;

    virtual void resetUtilization() const = 0;
};

class Topology: public Module, public Unit{
    MAMMUT_MODULE_DECL(Topology)
protected:
    std::vector<Cpu*> _cpus;
    std::vector<PhysicalCore*> _physicalCores;
    std::vector<VirtualCore*> _virtualCores;
    Communicator* const _communicator;

    Topology();
    Topology(Communicator* const communicator);
    virtual ~Topology();
private:
    void buildCpuVector(std::vector<VirtualCoreCoordinates> coord);
    std::vector<PhysicalCore*> buildPhysicalCoresVector(std::vector<VirtualCoreCoordinates> coord, CpuId cpuId);
    std::vector<VirtualCore*> buildVirtualCoresVector(std::vector<VirtualCoreCoordinates> coord, CpuId cpuId, PhysicalCoreId physicalCoreId);
    bool processMessage(const std::string& messageIdIn, const std::string& messageIn,
                                    std::string& messageIdOut, std::string& messageOut);
public:
    std::vector<Cpu*> getCpus() const;

    std::vector<PhysicalCore*> getPhysicalCores() const;

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

    std::vector<PhysicalCore*> virtualToPhysical(const std::vector<VirtualCore*>& virtualCores) const;

    Cpu* getCpu(CpuId cpuId) const;

    PhysicalCore* getPhysicalCore(PhysicalCoreId physicalCoreId) const;

    VirtualCore* getVirtualCore(VirtualCoreId virtualCoreId) const;

    VirtualCore* getVirtualCore() const;
};

class Cpu: public Unit{
private:
    std::vector<VirtualCore*> virtualCoresFromPhysicalCores();
protected:
    Cpu(CpuId cpuId, std::vector<PhysicalCore*> physicalCores);
    const CpuId _cpuId;
    const std::vector<PhysicalCore*> _physicalCores;
    const std::vector<VirtualCore*> _virtualCores;
public:
    CpuId getCpuId() const;

    std::vector<PhysicalCore*> getPhysicalCores() const;

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

    PhysicalCore* getPhysicalCore(PhysicalCoreId physicalCoreId) const;

    VirtualCore* getVirtualCore(VirtualCoreId virtualCoreId) const;

    VirtualCore* getVirtualCore() const;

    virtual std::string getVendorId() const = 0;

    virtual std::string getFamily() const = 0;

    virtual std::string getModel() const = 0;

    virtual void maximizeUtilization() const = 0;

    virtual void resetUtilization() const = 0;

    /*****************************************************/
    /*                   HotPlug Support                 */
    /*****************************************************/

    bool isHotPluggable() const;

    bool isHotPlugged() const;

    void hotPlug() const;

    void hotUnplug() const;

    virtual inline ~Cpu(){;}
};

class PhysicalCore: public Unit{
protected:
    PhysicalCore(CpuId cpuId, PhysicalCoreId physicalCoreId, std::vector<VirtualCore*> virtualCores);
    const CpuId _cpuId;
    const PhysicalCoreId _physicalCoreId;
    const std::vector<VirtualCore*> _virtualCores;
public:
    PhysicalCoreId getPhysicalCoreId() const;

    CpuId getCpuId() const;

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

    VirtualCore* getVirtualCore(VirtualCoreId virtualCoreId) const;

    VirtualCore* getVirtualCore() const;

    virtual void maximizeUtilization() const = 0;

    virtual void resetUtilization() const = 0;

    /*****************************************************/
    /*                   HotPlug Support                 */
    /*****************************************************/

    bool isHotPluggable() const;

    bool isHotPlugged() const;

    void hotPlug() const;

    void hotUnplug() const;

    virtual inline ~PhysicalCore(){;}
};

class VirtualCoreIdleLevel{
protected:
    const VirtualCoreId _virtualCoreId;
    const uint _levelId;

    VirtualCoreIdleLevel(VirtualCoreId virtualCoreId, uint levelId);
public:
    VirtualCoreId getVirtualCoreId() const;

    uint getLevelId() const;

    virtual std::string getName() const = 0;

    virtual std::string getDesc() const = 0;

    virtual bool isEnableable() const = 0;

    virtual bool isEnabled() const = 0;

    virtual void enable() const = 0;

    virtual void disable() const = 0;

    virtual uint getExitLatency() const = 0;

    virtual uint getConsumedPower() const = 0;

    virtual uint getAbsoluteTime() const = 0;

    virtual uint getTime() const = 0;

    virtual void resetTime() = 0;

    virtual uint getAbsoluteCount() const = 0;

    virtual uint getCount() const = 0;

    virtual void resetCount() = 0;


    virtual inline ~VirtualCoreIdleLevel(){;}
};

class VirtualCore: public Unit{
protected:
    VirtualCore(CpuId cpuId, PhysicalCoreId physicalCoreId, VirtualCoreId virtualCoreId);
    const CpuId _cpuId;
    const PhysicalCoreId _physicalCoreId;
    const VirtualCoreId _virtualCoreId;
public:

    VirtualCoreId getVirtualCoreId() const;

    PhysicalCoreId getPhysicalCoreId() const;

    CpuId getCpuId() const;

    /*****************************************************/
    /*                 Various utilities                 */
    /*****************************************************/

    virtual bool hasFlag(const std::string& flagName) const = 0;

    virtual uint64_t getAbsoluteTicks() const = 0;

    virtual bool areTicksConstant() const;

    virtual void maximizeUtilization() const = 0;

    virtual void resetUtilization() const = 0;

    virtual double getIdleTime() const = 0;

    virtual void resetIdleTime() = 0;

    /*****************************************************/
    /*                   HotPlug Support                 */
    /*****************************************************/

    virtual bool isHotPluggable() const = 0;

    virtual bool isHotPlugged() const = 0;

    virtual void hotPlug() const = 0;

    virtual void hotUnplug() const = 0;

    /*****************************************************/
    /*                   CpuIdle Support                 */
    /*****************************************************/

    virtual std::vector<VirtualCoreIdleLevel*> getIdleLevels() const = 0;

    virtual inline ~VirtualCore(){;}
};

size_t getNumPhysicalCores(const std::vector<VirtualCore*>& virtualCores);

std::vector<VirtualCore*> getOneVirtualPerPhysical(const std::vector<VirtualCore*>& virtualCores);

inline bool operator==(const Cpu& lhs, const Cpu& rhs){return lhs.getCpuId() == rhs.getCpuId();}

inline bool operator!=(const Cpu& lhs, const Cpu& rhs){return !operator==(lhs,rhs);}

inline bool operator==(const PhysicalCore& lhs, const PhysicalCore& rhs){return lhs.getPhysicalCoreId() == rhs.getPhysicalCoreId();}

inline bool operator!=(const PhysicalCore& lhs, const PhysicalCore& rhs){return !operator==(lhs,rhs);}

inline bool operator==(const VirtualCore& lhs, const VirtualCore& rhs){return lhs.getVirtualCoreId() == rhs.getVirtualCoreId();}

inline bool operator!=(const VirtualCore& lhs, const VirtualCore& rhs){return !operator==(lhs,rhs);}

}
}

#endif /* MAMMUT_TOPOLOGY_HPP_ */