xaiefal
Loading...
Searching...
No Matches
xaiefal-rscmgr.hpp
Go to the documentation of this file.
1#pragma once
2
3#include <fstream>
4#include <memory>
5#include <vector>
6#include <xaiengine.h>
7
8#ifdef FAL_LINUX
9#define BACKEND XAieRscMgrLinux
10#include <xaiefal/rsc/xaiefal-rscmgr-linux.hpp>
11#else
12#define BACKEND XAieRscMgrGeneric
13#include <xaiefal/rsc/xaiefal-rscmgr-generic.hpp>
14#endif /* FAL_LINUX */
15
16#define XAIE_ERROR_BCAST_ID 0U
17#define XAIE_ECC_BCAST_ID 6U
18#define XAIE_ECC_PERFCNT_ID 0U
19
20namespace xaiefal {
25 class XAieRscMgr {
26 public:
27 XAieRscMgr() = delete;
28 XAieRscMgr(XAieDevHandle *DevHd):
29 AieHd(DevHd) {
30 if (!DevHd)
31 throw std::invalid_argument("rscmgr: empty device handle");
32 Backend = std::make_shared<BACKEND>(DevHd);
33 }
34 ~XAieRscMgr() {}
35
45 AieRC request(XAieRsc& Rsc) {
46 AieRC RC = XAIE_OK;
47 std::vector<XAieUserRsc> vRequests;
48
49 switch(Rsc.getRscType()) {
50 case XAIE_PERFCOUNT:
51 case XAIE_USEREVENT:
52 case XAIE_TRACECTRL:
53 case XAIE_PCEVENT:
54 case XAIE_SSEVENT:
55 case XAIE_MDMPERFCNT:
56 {
57 RC = Rsc.getRscs(vRequests);
58 if (RC != XAIE_OK) {
59 return RC;
60 }
61
62 if (Rsc.getPreferredId() != XAIE_RSC_ID_ANY) {
63 RC = Backend->requestAllocated(vRequests);
64 } else if ((Rsc.getRscType() == XAIE_PCEVENT) &&
65 (vRequests.size() > 1)) {
66 /* PCRange */
67 RC = Backend->requestContiguous(vRequests);
68 } else {
69 RC = Backend->request(vRequests);
70 }
71
72 if (RC == XAIE_OK) {
73 RC = Rsc.setRscs(vRequests);
74 }
75 break;
76 }
77 case XAIE_BROADCAST:
78 {
79 bool BcastAll;
80
81 RC = Rsc.getRscs(vRequests);
82 if (RC != XAIE_OK) {
83 return RC;
84 }
85
86 BcastAll = false;
87 if (vRequests.size() == 0) {
88 uint8_t NumAieRows;
89 uint32_t NumRscs;
90
91 /*
92 * AIE tiles have to sets of bcast channels
93 * for memory and core module
94 */
95 NumAieRows = dev()->NumRows - dev()->AieTileRowStart;
96 NumRscs = (dev()->NumCols * dev()->NumRows) +
97 (dev()->NumCols * NumAieRows);
98
99 vRequests.resize(NumRscs);
100 BcastAll = true;
101 }
102
103 vRequests[0].RscId = Rsc.getPreferredId();
104 RC = Backend->requestBc(vRequests, BcastAll);
105 if (RC == XAIE_OK) {
106 RC = Rsc.setRscs(vRequests);
107 }
108 break;
109 }
110 case XAIE_COMBOEVENT:
111 {
112 RC = Rsc.getRscs(vRequests);
113 if (RC != XAIE_OK) {
114 return RC;
115 }
116
117 RC = Backend->requestContiguous(vRequests);
118
119 if (RC == XAIE_OK) {
120 RC = Rsc.setRscs(vRequests);
121 }
122 break;
123 }
124 case XAIE_GROUPEVENT:
125 {
126 RC = Rsc.getRscs(vRequests);
127 if (RC != XAIE_OK) {
128 return RC;
129 }
130
131 RC = Backend->requestAllocated(vRequests);
132 if (RC == XAIE_OK) {
133 RC = Rsc.setRscs(vRequests);
134 }
135 break;
136 }
137 default:
138 return XAIE_ERR;
139 }
140 return RC;
141 }
142
154 AieRC release(XAieRsc& Rsc) {
155 AieRC RC = XAIE_OK;
156 std::vector<XAieUserRsc> vReleases;
157
158 if (Rsc.getRscType() >= XAIE_MAXRSC) {
159 return XAIE_ERR;
160 }
161
162 RC = Rsc.getRscs(vReleases);
163 if (RC != XAIE_OK) {
164 return RC;
165 }
166
167 return Backend->release(vReleases);
168 }
169
182 AieRC free(XAieRsc& Rsc) {
183 AieRC RC = XAIE_OK;
184 std::vector<XAieUserRsc> vReleases;
185
186 if (Rsc.getRscType() >= XAIE_MAXRSC) {
187 return XAIE_ERR;
188 }
189
190 RC = Rsc.getRscs(vReleases);
191 if (RC != XAIE_OK) {
192 return RC;
193 }
194
195 return Backend->free(vReleases);
196 }
197
204 AieRC getStaticRscs(std::vector<XAieUserRscStat> &vStats) {
205 return Backend->getRscStats(vStats, XAIE_STATIC_RSC);
206 }
207
215 AieRC getAvailRscs(std::vector<XAieUserRscStat> &vStats) {
216 return Backend->getRscStats(vStats, XAIE_AVAIL_RSC);
217 }
218
225 AieRC saveAllocatedRscs(const std::string &File) {
226 uint64_t FirstBitmapOffset = 0x10;
227 uint64_t NumRscsInFile = 0;
228 std::ofstream Fs;
229 AieRC RC;
230
231 Fs.open(File);
232 if (!Fs.is_open()){
233 Logger::log(LogLevel::FAL_ERROR) <<
234 "Could not open file " << File
235 << std::endl;
236 return XAIE_ERR;
237 }
238
239 Fs.write(reinterpret_cast<char *>(&NumRscsInFile),
240 sizeof(NumRscsInFile));
241 Fs.write(reinterpret_cast<char *>(&FirstBitmapOffset),
242 sizeof(FirstBitmapOffset));
243 if (Fs.fail()) {
244 Logger::log(LogLevel::FAL_ERROR) <<
245 "Failed to write rscs to file " << File
246 << std::endl;
247 Fs.close();
248 return XAIE_ERR;
249 }
250
251 RC = Backend->writeRscBitmaps(Fs, NumRscsInFile);
252 if (RC != XAIE_OK) {
253 Logger::log(LogLevel::FAL_ERROR) <<
254 "Failed to write rscs to file " << File
255 << std::endl;
256 Fs.close();
257 return RC;
258 }
259
260 Fs.seekp(std::ios_base::beg);
261 Fs.write(reinterpret_cast<char *>(&NumRscsInFile),
262 sizeof(NumRscsInFile));
263 if (Fs.fail()) {
264 Logger::log(LogLevel::FAL_ERROR) <<
265 "Failed to write rscs to file " << File
266 << std::endl;
267 Fs.close();
268 return XAIE_ERR;
269 }
270
271 Fs.close();
272 return XAIE_OK;
273 }
274
275 AieRC loadStaticRscs(const char *MetaData) {
276 uint64_t *MetaHeader = (uint64_t *)MetaData;
277 uint64_t NumBitmaps, FirstBitmapOffset;
278
279 if (MetaHeader == NULL) {
280 Logger::log(LogLevel::FAL_ERROR) <<
281 "Invalid resource metadata" << std::endl;
282 return XAIE_INVALID_ARGS;
283 }
284
285 NumBitmaps = MetaHeader[0U];
286 FirstBitmapOffset = MetaHeader[1U];
287
288 if (FirstBitmapOffset < (sizeof(uint64_t) * 2U) ||
289 NumBitmaps == 0U) {
290 Logger::log(LogLevel::FAL_ERROR) <<
291 "Invalid metadata header"
292 << std::endl;
293 return XAIE_INVALID_ARGS;
294 }
295 return Backend->loadRscBitmaps(MetaData + FirstBitmapOffset,
296 NumBitmaps);
297 }
298
305 AieRC reserveEcc() {
306 std::vector<XAieUserRsc> vBcastRscs, vPerfRscs;
307 std::vector<XAie_LocType> vLocs;
308 uint32_t NumRscs, NumTiles;
309 AieRC RC = XAIE_OK;
310
311 NumRscs = dev()->AieTileNumRows * dev()->NumCols * 2
312 + (dev()->NumRows - dev()->AieTileNumRows)
313 * dev()->NumCols;
314 vBcastRscs.resize(NumRscs);
315
316 vBcastRscs[0].RscId = XAIE_ECC_BCAST_ID;
317 RC = Backend->requestBc(vBcastRscs, true);
318 if (RC != XAIE_OK) {
319 Logger::log(LogLevel::FAL_WARN) << "Unable to reserve " <<
320 "broadcast resources for ECC" << std::endl;
321 return RC;
322 }
323
324 NumTiles = dev()->NumCols * dev()->NumRows;
325 vLocs.resize(NumTiles);
326 RC = XAie_GetUngatedLocsInPartition(dev(), &NumTiles, vLocs.data());
327 if (RC != XAIE_OK) {
328 Logger::log(LogLevel::FAL_WARN) << "Unable to reserve " <<
329 "resources for ECC, get ungated tiles failed"
330 << std::endl;
331 return RC;
332 }
333 vLocs.resize(NumTiles);
334
335 for (auto loc : vLocs) {
336 uint8_t TileType;
337 XAieUserRsc Rsc;
338
339 TileType = XAie_GetTileTypefromLoc(dev(), loc);
340 if (TileType == XAIEGBL_TILE_TYPE_AIETILE) {
341 Rsc.Loc = loc;
342 Rsc.Mod = XAIE_CORE_MOD;
343 Rsc.RscType = XAIE_PERFCOUNT;
344 Rsc.RscId = XAIE_ECC_PERFCNT_ID;
345
346 RC = Backend->requestAllocated(Rsc);
347 if (RC != XAIE_OK) {
348 Logger::log(LogLevel::FAL_WARN) <<
349 "Unable to reserve " <<
350 "perfcounter resources for ECC"
351 << std::endl;
352 Backend->release(vBcastRscs);
353 Backend->release(vPerfRscs);
354 return RC;
355 }
356 vPerfRscs.push_back(Rsc);
357 }
358 }
359 return RC;
360 }
361
368 AieRC reserveErrorHandling() {
369 std::vector<XAieUserRsc> vRscs, vShimRscs;
370 const XAie_L1IntrMod *L1IntrMod;
371 uint32_t NumRscs;
372 AieRC RC = XAIE_OK;
373
374 NumRscs = dev()->AieTileNumRows * dev()->NumCols * 2
375 + (dev()->NumRows - dev()->AieTileNumRows)
376 * dev()->NumCols;
377 vRscs.resize(NumRscs);
378
379 vRscs[0].RscId = XAIE_ERROR_BCAST_ID;
380 RC = Backend->requestBc(vRscs, true);
381 if (RC != XAIE_OK) {
382 Logger::log(LogLevel::FAL_WARN) << "Unable to reserve " <<
383 "broadcast resources for Error Handling"
384 << std::endl;
385 return RC;
386 }
387
388 L1IntrMod = dev()->DevProp.DevMod[XAIEGBL_TILE_TYPE_SHIMPL].L1IntrMod;
389 for (uint32_t i = 1; i < L1IntrMod->MaxErrorBcIdsRvd; i++) {
390 for (uint8_t j = 0; j < dev()->NumCols; j++) {
391 XAieUserRsc rsc;
392 rsc.Loc = XAie_TileLoc(j, dev()->ShimRow);
393 rsc.Mod = XAIE_PL_MOD;
394 rsc.RscType = XAIE_BROADCAST;
395 rsc.RscId = i;
396 vShimRscs.push_back(rsc);
397 }
398 }
399 RC = Backend->requestAllocated(vShimRscs);
400 if (RC != XAIE_OK) {
401 Logger::log(LogLevel::FAL_WARN) << "Unable to reserve " <<
402 "shim broadcast resources for Error Handling"
403 << std::endl;
404 return RC;
405 }
406 return XAIE_OK;
407 }
408
409 XAie_DevInst *dev() {
410 return AieHd->dev();
411 }
412
413 protected:
414 XAieDevHandle *AieHd;
415 std::shared_ptr<XAieRscMgrBackend> Backend;
416 }; /* class XAieRscMgr */
417
425 inline AieRC XAieDev::saveAllocatedRscsToFile(const std::string &File) {
426 return AieHandle->rscMgr()->saveAllocatedRscs(File);
427 }
428
436 inline AieRC XAieDev::loadStaticRscsFromMem(const char *MetaData) {
437 return AieHandle->rscMgr()->loadStaticRscs(MetaData);
438 }
439
446 inline AieRC XAieDev::reserveEcc() {
447 return AieHandle->rscMgr()->reserveEcc();
448 }
449
456 inline AieRC XAieDev::reserveErrorHandling() {
457 return AieHandle->rscMgr()->reserveErrorHandling();
458 }
459} /* namespace xaiefal */
xaiefal::Logger::log
static std::ostream & log(LogLevel Lvl=LogLevel::FAL_MAX)
Definition xaiefal-log.hpp:50
xaiefal::XAieDevHandle
AI engine low level device pointer handle.
Definition xaiefal-base.hpp:104
xaiefal::XAieDev::reserveErrorHandling
AieRC reserveErrorHandling()
Definition xaiefal-rscmgr.hpp:456
xaiefal::XAieDev::saveAllocatedRscsToFile
AieRC saveAllocatedRscsToFile(const std::string &File)
Definition xaiefal-rscmgr.hpp:425
xaiefal::XAieDev::reserveEcc
AieRC reserveEcc()
Definition xaiefal-rscmgr.hpp:446
xaiefal::XAieDev::loadStaticRscsFromMem
AieRC loadStaticRscsFromMem(const char *MetaData)
Definition xaiefal-rscmgr.hpp:436
xaiefal::XAieRsc
Base AI engine resource class. It defines resource operations and maintains resource state machine.
Definition xaiefal-rsc-base.hpp:69
xaiefal::XAieRsc::getPreferredId
uint32_t getPreferredId()
Definition xaiefal-rsc-base.hpp:141
xaiefal::XAieRsc::getRscType
virtual XAieRscType getRscType() const
Definition xaiefal-rsc-base.hpp:351
xaiefal::XAieRsc::getRscs
AieRC getRscs(std::vector< XAieUserRsc > &vOutRscs)
Definition xaiefal-rsc-base.hpp:332
xaiefal::XAieRsc::setRscs
AieRC setRscs(std::vector< XAieUserRsc > &vInRscs)
Definition xaiefal-rsc-base.hpp:342
xaiefal::XAieRscMgr::request
AieRC request(XAieRsc &Rsc)
Definition xaiefal-rscmgr.hpp:45
xaiefal::XAieRscMgr::XAieRscMgr
XAieRscMgr(XAieDevHandle *DevHd)
Definition xaiefal-rscmgr.hpp:28
xaiefal::XAieRscMgr::release
AieRC release(XAieRsc &Rsc)
Definition xaiefal-rscmgr.hpp:154
xaiefal::XAieRscMgr::getAvailRscs
AieRC getAvailRscs(std::vector< XAieUserRscStat > &vStats)
Definition xaiefal-rscmgr.hpp:215
xaiefal::XAieRscMgr::saveAllocatedRscs
AieRC saveAllocatedRscs(const std::string &File)
Definition xaiefal-rscmgr.hpp:225
xaiefal::XAieRscMgr::loadStaticRscs
AieRC loadStaticRscs(const char *MetaData)
Definition xaiefal-rscmgr.hpp:275
xaiefal::XAieRscMgr::getStaticRscs
AieRC getStaticRscs(std::vector< XAieUserRscStat > &vStats)
Definition xaiefal-rscmgr.hpp:204
xaiefal::XAieRscMgr::~XAieRscMgr
~XAieRscMgr()
Definition xaiefal-rscmgr.hpp:34
xaiefal::XAieRscMgr::Backend
std::shared_ptr< XAieRscMgrBackend > Backend
Definition xaiefal-rscmgr.hpp:415
xaiefal::XAieRscMgr::reserveEcc
AieRC reserveEcc()
Definition xaiefal-rscmgr.hpp:305
xaiefal::XAieRscMgr::AieHd
XAieDevHandle * AieHd
Definition xaiefal-rscmgr.hpp:414
xaiefal::XAieRscMgr::reserveErrorHandling
AieRC reserveErrorHandling()
Definition xaiefal-rscmgr.hpp:368
xaiefal::XAieRscMgr::dev
XAie_DevInst * dev()
Definition xaiefal-rscmgr.hpp:409
xaiefal::XAieRscMgr::free
AieRC free(XAieRsc &Rsc)
Definition xaiefal-rscmgr.hpp:182
xaiefal
Definition xaiefal-base.hpp:23
xaiefal::XAIE_COMBOEVENT
@ XAIE_COMBOEVENT
Definition xaiefal-rsc-group.hpp:34
xaiefal::XAIE_MDMPERFCNT
@ XAIE_MDMPERFCNT
Definition xaiefal-rsc-group.hpp:36
xaiefal::XAIE_GROUPEVENT
@ XAIE_GROUPEVENT
Definition xaiefal-rsc-group.hpp:35
xaiefal::XAIE_SSEVENT
@ XAIE_SSEVENT
Definition xaiefal-rsc-group.hpp:32
xaiefal::XAIE_PERFCOUNT
@ XAIE_PERFCOUNT
Definition xaiefal-rsc-group.hpp:28
xaiefal::XAIE_PCEVENT
@ XAIE_PCEVENT
Definition xaiefal-rsc-group.hpp:31
xaiefal::XAIE_MAXRSC
@ XAIE_MAXRSC
Definition xaiefal-rsc-group.hpp:37
xaiefal::XAIE_TRACECTRL
@ XAIE_TRACECTRL
Definition xaiefal-rsc-group.hpp:30
xaiefal::XAIE_BROADCAST
@ XAIE_BROADCAST
Definition xaiefal-rsc-group.hpp:33
xaiefal::XAIE_USEREVENT
@ XAIE_USEREVENT
Definition xaiefal-rsc-group.hpp:29
xaiefal::XAIE_STATIC_RSC
@ XAIE_STATIC_RSC
Definition xaiefal-rscmgr-backend-base.hpp:15
xaiefal::XAIE_AVAIL_RSC
@ XAIE_AVAIL_RSC
Definition xaiefal-rscmgr-backend-base.hpp:16
xaiefal::LogLevel::FAL_ERROR
@ FAL_ERROR
Definition xaiefal-log.hpp:14
xaiefal::LogLevel::FAL_WARN
@ FAL_WARN
Definition xaiefal-log.hpp:13
xaiefal::XAieUserRsc
Data needed to make a resource request.
Definition xaiefal-rsc-base.hpp:27
xaiefal::XAieUserRsc::RscId
uint32_t RscId
Definition xaiefal-rsc-base.hpp:41
xaiefal::XAieUserRsc::RscType
XAieRscType RscType
Definition xaiefal-rsc-base.hpp:37
xaiefal::XAieUserRsc::Loc
XAie_LocType Loc
Definition xaiefal-rsc-base.hpp:29
xaiefal::XAieUserRsc::Mod
XAie_ModuleType Mod
Definition xaiefal-rsc-base.hpp:33
XAIE_RSC_ID_ANY
#define XAIE_RSC_ID_ANY
Definition xaiefal-common.hpp:7
XAIE_ERROR_BCAST_ID
#define XAIE_ERROR_BCAST_ID
Definition xaiefal-rscmgr.hpp:16
XAIE_ECC_PERFCNT_ID
#define XAIE_ECC_PERFCNT_ID
Definition xaiefal-rscmgr.hpp:18
XAIE_ECC_BCAST_ID
#define XAIE_ECC_BCAST_ID
Definition xaiefal-rscmgr.hpp:17
Generated on for xaiefal by doxygen 1.15.0