xaiefal-rsc-base.hpp

Go to the documentation of this file.

// Copyright(C) 2020 - 2021 by Xilinx, Inc. All rights reserved.
// SPDX-License-Identifier: MIT
 
#include <fstream>
#include <functional>
#include <map>
#include <memory>
#include <unordered_map>
#include <vector>
#include <xaiengine.h>
#include <xaiefal/common/xaiefal-base.hpp>
#include <xaiefal/common/xaiefal-log.hpp>
 
#pragma once
 
namespace xaiefal {
        class XAieRsc;

        struct XAieUserRsc {
                XAie_LocType Loc {
                        XAie_TileLoc(XAIE_LOC_ANY, XAIE_LOC_ANY)
                };

                XAie_ModuleType Mod {
                        static_cast<XAie_ModuleType>(XAIE_MOD_ANY)
                };

                XAieRscType RscType {
                        static_cast<XAieRscType>(XAIE_RSC_TYPE_ANY)
                };

                uint32_t RscId {
                        static_cast<uint32_t>(XAIE_RSC_ID_ANY)
                };
        };

        struct XAieRscState {
                uint8_t Initialized: 1; 
                uint8_t Configured: 1; 
                uint8_t Reserved: 1; 
                uint8_t Prereserved: 1; 
                uint8_t Running: 1; 
        };

        class XAieRsc {
        public:
                XAieRsc() = delete;
                XAieRsc(std::shared_ptr<XAieDevHandle> DevHd):
                        State(), AieHd(DevHd) {
                        if (!DevHd) {
                                throw std::invalid_argument("aie rsc: empty device handle");
                        }
                        preferredId = XAIE_RSC_ID_ANY;
                        Type = static_cast<XAieRscType>(XAIE_RSC_TYPE_ANY);
                }
                XAieRsc(std::shared_ptr<XAieDevHandle> DevHd, XAieRscType Type):
                        State(), Type(Type), AieHd(DevHd) {
                        if (!DevHd) {
                                throw std::invalid_argument("aie rsc: empty device handle");
                        }
                        preferredId = XAIE_RSC_ID_ANY;
                }
                XAieRsc(XAieDev &Dev):
                        State(), AieHd(Dev.getDevHandle()) {
                                preferredId = XAIE_RSC_ID_ANY;
                                Type = static_cast<XAieRscType>(XAIE_RSC_TYPE_ANY);
                        }
                virtual ~XAieRsc() {
                        if (State.Running == 1) {
                                stop();
                        } else if (State.Reserved == 1) {
                                if (State.Prereserved == 1) {
                                        free();
                                } else {
                                        release();
                                }
                        }
                }

 
                AieRC setPreferredId(uint32_t id, bool isStaticAllocated = false) {
                        AieRC RC;
 
                        if (State.Reserved == 1) {
                                RC = XAIE_INVALID_ARGS;
                        } else {
                                preferredId = id;
                                RC = XAIE_OK;
                                if (isStaticAllocated) {
                                        if (id == XAIE_RSC_ID_ANY) {
                                                RC = XAIE_INVALID_ARGS;
                                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                                        typeid(*this).name() <<
                                                        " If Rsc ID is any, cannot be statically allocated" << std::endl;
                                        } else {
                                                State.Prereserved = 1;
                                        }
                                }
                        }
 
                        return RC;
                }

                uint32_t getPreferredId() {
                        return preferredId;
                }

                AieRC reserve() {
                        AieRC RC;
 
                        if (State.Reserved == 1) {
                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                        typeid(*this).name() << " resource has been allocated." << std::endl;
                                RC = XAIE_ERR;
                        } else if (State.Initialized == 0) {
                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                        typeid(*this).name() << " resource not configured." << std::endl;
                                RC = XAIE_ERR;
                        } else {
                                RC = _reserve();
                                if (RC == XAIE_OK) {
                                        State.Reserved = 1;
                                }
                        }
                        return RC;
                }

                AieRC release() {
                        AieRC RC = XAIE_OK;
 
                        if (State.Running == 1) {
                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                        typeid(*this).name() << "resource is running." << std::endl;
                                RC = XAIE_ERR;
                        } else if (State.Reserved == 1) {
                                RC = _release();
                                State.Reserved = 0;
                                State.Prereserved = 0;
                        }
                        return RC;
                }

                AieRC free() {
                        AieRC RC = XAIE_OK;
 
                        if (State.Prereserved == 0) {
                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                        typeid(*this).name() << " resource is not preserved." << std::endl;
                                RC = XAIE_INVALID_ARGS;
                        } else {
                                if (State.Running == 1) {
                                        Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                                typeid(*this).name() << " resource is running." << std::endl;
                                        RC = XAIE_INVALID_ARGS;
                                } else if (State.Reserved == 1) {
                                        RC = _free();
                                        State.Reserved = 0;
                                }
                        }
                        return RC;
                }

                AieRC start() {
                        AieRC RC = XAIE_OK;
 
                        if (State.Running == 1) {
                                RC = XAIE_OK;
                        } else if (State.Reserved == 1) {
                                if (State.Configured == 1) {
                                        RC = _start();
                                        if (RC == XAIE_OK) {
                                                State.Running = 1;
                                        }
                                } else {
                                        Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                                typeid(*this).name() << " resource is not configured." << std::endl;
                                        RC = XAIE_ERR;
                                }
                        } else {
                                Logger::log(LogLevel::FAL_ERROR) << __func__ << " " <<
                                        typeid(*this).name() << " resource is not allocated." << std::endl;
                                RC = XAIE_ERR;
                        }
                        return RC;
                }

                AieRC stop() {
                        AieRC RC = XAIE_OK;
 
                        if (State.Running == 0) {
                                RC = XAIE_OK;
                        } else {
                                RC = _stop();
                                if (RC == XAIE_OK) {
                                        State.Running = 0;
                                }
                        }
                        return RC;
                }

                bool isInitialized() const {
                        return State.Initialized;
                }

                bool isReserved() const {
                        return State.Reserved;
                }

                bool isConfigured() const {
                        return State.Configured;
                }

                bool isRunning() const {
                        return State.Running;
                }

                void getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
                        if (State.Reserved != 0) {
                                _getReservedRscs(vOutRscs);
                        }
                }

                AieRC getRscs(std::vector<XAieUserRsc> &vOutRscs) {
                        _getRscs(vOutRscs);
                        return XAIE_OK;
                }

                AieRC setRscs(std::vector<XAieUserRsc> &vInRscs) {
                        _setRscs(vInRscs);
                        return XAIE_OK;
                }

                virtual XAieRscType getRscType() const {
                        return Type;
                }

                virtual XAieRscStat getRscStat(const std::string &GName) const {
                        XAieRscStat RscStat(GName);
                        std::string rName(typeid(*this).name());
                        (void) GName;
 
                        throw std::invalid_argument("get rsc stat not supported of rsc" +
                                        rName);
                }

                XAie_DevInst *dev() {
                        return AieHd->dev();
                }

                virtual uint32_t getAvailManagedRscs() {
                        std::string rName(typeid(*this).name());
                        throw std::invalid_argument("get max rsc num not supported of rsc " +
                                        rName);
                }

                virtual XAieRscType getManagedRscsType() {
                        std::string rName(typeid(*this).name());
                        throw std::invalid_argument("get managed rsc type not supported of rsc " +
                                        rName);
                }
 
        protected:
                XAieRscState State; 
                XAieRscType Type; 
                std::shared_ptr<XAieDevHandle> AieHd; 
                uint32_t preferredId; 
                uint32_t reservedId; 
                std::vector<XAieUserRsc> vRscs; 
        private:
                virtual AieRC _reserve() {return XAIE_OK;}
                virtual AieRC _release() {return XAIE_OK;}
                virtual AieRC _free() {return XAIE_OK;}
                virtual AieRC _start() {return XAIE_OK;}
                virtual AieRC _stop() {return XAIE_OK;}

                virtual void _getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
                        std::string rName(typeid(*this).name());
 
                        (void)vOutRscs;
                        throw std::invalid_argument("get resource not supported of rsc" +
                                        rName);
                }
                virtual void _getRscs(std::vector<XAieUserRsc> &vOutRscs) {
                        vOutRscs.insert(vOutRscs.end(), vRscs.begin(), vRscs.end());
                }
                virtual void _setRscs(std::vector<XAieUserRsc> &vInRscs) {
                        vRscs = vInRscs;
                }
        };

        class XAieSingleTileRsc: public XAieRsc {
        public:
                XAieSingleTileRsc() = delete;
                XAieSingleTileRsc(std::shared_ptr<XAieDevHandle> DevHd,
                        XAie_LocType Loc, XAie_ModuleType Mod):
                        XAieRsc(DevHd), Loc(Loc), Mod(Mod) {
                        if (XAie_CheckModule(AieHd->dev(), Loc, Mod) !=
                                XAIE_OK) {
                                throw std::invalid_argument("invalid module tile");
                        }
                }
                XAieSingleTileRsc(std::shared_ptr<XAieDevHandle> DevHd,
                        XAie_LocType Loc, XAie_ModuleType Mod, XAieRscType Type):
                        XAieRsc(DevHd, Type), Loc(Loc), Mod(Mod) {
                        if (XAie_CheckModule(AieHd->dev(), Loc, Mod) !=
                                XAIE_OK) {
                                throw std::invalid_argument("invalid module tile");
                        }
                }
                XAieSingleTileRsc(XAieDev &Dev,
                        XAie_LocType Loc, XAie_ModuleType Mod):
                        XAieSingleTileRsc(Dev.getDevHandle(), Loc, Mod) {}
                XAieSingleTileRsc(XAieDev &Dev,
                        XAie_LocType Loc, XAie_ModuleType Mod, XAieRscType Type):
                        XAieSingleTileRsc(Dev.getDevHandle(), Loc, Mod, Type) {}
                XAieSingleTileRsc(std::shared_ptr<XAieDevHandle> DevHd,
                        XAie_LocType Loc):
                        XAieRsc(DevHd), Loc(Loc) {
                        uint8_t TType = XAie_GetTileTypefromLoc(
                                        AieHd->dev(), Loc);
                        if (TType == XAIEGBL_TILE_TYPE_MAX) {
                                throw std::invalid_argument("Invalid tile");
                        }
                        if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
                                Mod = XAIE_CORE_MOD;
                        } else if (TType == XAIEGBL_TILE_TYPE_SHIMPL ||
                                        TType == XAIEGBL_TILE_TYPE_SHIMNOC) {
                                Mod = XAIE_PL_MOD;
                        } else {
                                Mod = XAIE_MEM_MOD;
                        }
                }
                XAieSingleTileRsc(std::shared_ptr<XAieDevHandle> DevHd,
                        XAie_LocType Loc, XAieRscType Type):
                        XAieRsc(DevHd, Type), Loc(Loc){
                        uint8_t TType = XAie_GetTileTypefromLoc(
                                        AieHd->dev(), Loc);
                        if (TType == XAIEGBL_TILE_TYPE_MAX) {
                                throw std::invalid_argument("Invalid tile");
                        }
                        if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
                                Mod = XAIE_CORE_MOD;
                        } else if (TType == XAIEGBL_TILE_TYPE_SHIMPL ||
                                        TType == XAIEGBL_TILE_TYPE_SHIMNOC) {
                                Mod = XAIE_PL_MOD;
                        } else {
                                Mod = XAIE_MEM_MOD;
                        }
                }
                XAieSingleTileRsc(XAieDev &Dev, XAie_LocType Loc, XAieRscType Type):
                        XAieSingleTileRsc(Dev.getDevHandle(), Loc, Type) {}
                virtual ~XAieSingleTileRsc() {}
                XAie_LocType loc() const {
                        return Loc;
                }

                XAie_ModuleType mod() const {
                        return Mod;
                }

                AieRC getRscId(XAie_LocType &OutLoc, XAie_ModuleType &OutMod,
                                uint32_t &OutRscId) {
                        AieRC RC = XAIE_ERR;
 
                        if (State.Reserved == 0) {
                                Logger::log(LogLevel::FAL_ERROR) << typeid(*this).name() << " " <<
                                        __func__ << "(" <<
                                        (uint32_t)Loc.Col << "," << (uint32_t)Loc.Row << ")" <<
                                        " Expect Mod= " << Mod <<
                                        " resource not reserved." << std::endl;
                        } else {
                                if (vRscs.size() > 0) {
                                        OutMod = vRscs[0].Mod;
                                        OutRscId = reservedId;
                                }
                                OutLoc = Loc;
                                RC = XAIE_OK;
                        }
                        return RC;
                }
                virtual XAieRscStat getRscStat(const std::string &GName) const {
                        XAieRscStat RscStat(GName);
                        (void) GName;
 
                        if (preferredId == XAIE_RSC_ID_ANY) {
                                return AieHd->getRscGroup(GName).getRscStat(Loc,
                                                Mod, getRscType());
                        } else {
                                return AieHd->getRscGroup(GName).getRscStat(Loc,
                                                Mod, getRscType(), preferredId);
                        }
                }
        protected:
                XAie_LocType Loc; 
                XAie_ModuleType Mod; 
        private:
                virtual void _getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
                        if (vRscs.size() > 0) {
                                vOutRscs.push_back(vRscs[0]);
                        }
                }
        };
 
        struct XAieRscGetRscsWrapper {
                XAieRscGetRscsWrapper() = delete;
                XAieRscGetRscsWrapper(std::shared_ptr<XAieRsc> &Rsc,
                                std::vector<XAieUserRsc> &Rscs) {
                        Rsc->getReservedRscs(Rscs);
                }
                ~XAieRscGetRscsWrapper() {};
        };
}