xaiefal-rscmgr-backend-base.hpp

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <memory>
#include <vector>
#include <xaiengine.h>
#include <xaiefal/common/xaiefal-common.hpp>
#include <xaiefal/common/xaiefal-log.hpp>
#include <xaiefal/rsc/xaiefal-rsc-base.hpp>
 
namespace xaiefal {
        class XAieDevHandle;
 
        enum XAieRscBitmapType {
                XAIE_STATIC_RSC,
                XAIE_AVAIL_RSC,
        };

        class XAieRscMgrBackend {
        public:
                XAieRscMgrBackend() = delete;
                XAieRscMgrBackend(XAieDevHandle *DevHd):
                        AieHd(DevHd) {}

                virtual AieRC request(XAieUserRsc& RscReq) {
                        (void)RscReq;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                AieRC request(std::vector<XAieUserRsc>& RscReq) {
                        AieRC RC;
                        for (uint32_t i = 0; i < RscReq.size(); i++) {
                                RC = request(RscReq[i]);
                                if (RC != XAIE_OK) {
                                        RscReq.resize(i);
                                        free(RscReq);
                                        return RC;
                                }
                        }
                        return XAIE_OK;
                }

                virtual AieRC requestAllocated(XAieUserRsc& RscReq) {
                        (void)RscReq;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                AieRC requestAllocated(std::vector<XAieUserRsc>& RscReq) {
                        AieRC RC;
                        for (uint32_t i = 0; i < RscReq.size(); i++) {
                                RC = requestAllocated(RscReq[i]);
                                if (RC != XAIE_OK) {
                                        RscReq.resize(i);
                                        free(RscReq);
                                        return RC;
                                }
                        }
                        return XAIE_OK;
                }

                virtual AieRC requestContiguous(std::vector<XAieUserRsc>& RscReq) {
                        (void)RscReq;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                virtual AieRC requestBc(std::vector<XAieUserRsc>& RscReq, bool isBcAll) {
                        (void)RscReq;
                        (void)isBcAll;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                virtual AieRC release(XAieUserRsc& RscRel) {
                        (void)RscRel;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                AieRC release(std::vector<XAieUserRsc>& RscRel) {
                        for (uint32_t i = 0; i < RscRel.size(); i++)
                                release(RscRel[i]);
                        return XAIE_OK;
                }

                virtual AieRC free(XAieUserRsc& RscFree) {
                        (void)RscFree;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                AieRC free(std::vector<XAieUserRsc>& RscFree) {
                        for (uint32_t i = 0; i < RscFree.size(); i++)
                                free(RscFree[i]);
                        return XAIE_OK;
                }

                virtual AieRC getRscStats(std::vector<XAieUserRscStat> &vStats,
                                XAieRscBitmapType BType) {
                        (void)vStats;
                        (void)BType;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for base backend " << std::endl;
                        return XAIE_ERR;
                }

                virtual AieRC writeRscBitmaps(std::ofstream &Fs, uint64_t &NumRscs) {
                        (void)Fs;
                        (void)NumRscs;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for selected backend " << std::endl;
                        return XAIE_ERR;
                }

                virtual AieRC loadRscBitmaps(const char *MetaData, uint64_t NumBitmaps) {
                        (void)MetaData;
                        (void)NumBitmaps;
                        Logger::log(LogLevel::FAL_ERROR) << __func__ <<
                                " Not supported for selected backend " << std::endl;
                        return XAIE_ERR;
                }
 
                XAie_DevInst *dev() {
                        return AieHd->dev();
                }
        protected:
                XAieDevHandle *AieHd;
        }; /* class XAieRscMgrBackend */
} /* namespace xaiefal */