xaiefal
Loading...
Searching...
No Matches
xaiefal-rscmgr-generic.hpp
Go to the documentation of this file.
1#pragma once
2
3#include <bitset>
4#include <memory>
5#include <vector>
6#include <xaiengine.h>
7#include <xaiefal/common/xaiefal-common.hpp>
8#include <xaiefal/common/xaiefal-log.hpp>
9#include <xaiefal/rsc/xaiefal-rscmgr-backend-base.hpp>
10
11#define XAIE_TRACE_PER_MOD 1U
12#define XAIE_COMBO_PER_MOD 4U
13#define XAIE_MDMPERF_PER_MOD 1U
14
15#define XAIE_RSC_HEADER_TTYPE_SHIFT 0U
16#define XAIE_RSC_HEADER_TTYPE_MASK 0xF
17#define XAIE_RSC_HEADER_MOD_SHIFT 4U
18#define XAIE_RSC_HEADER_MOD_MASK 0xF
19#define XAIE_RSC_HEADER_RTYPE_SHIFT 8U
20#define XAIE_RSC_HEADER_RTYPE_MASK 0xFF
21#define XAIE_RSC_HEADER_SIZE_SHIFT 16U
22#define XAIE_RSC_HEADER_SIZE_MASK 0xFFFFFFFF
23
24namespace xaiefal {
30 typedef std::vector<std::bitset<32>> XAieRscBitmap;
35 typedef std::vector<std::pair<XAie_ModuleType, uint32_t>> XAieRscMaxRsc;
45
49 class XAieRscMgrGeneric : public XAieRscMgrBackend {
50 public:
51 XAieRscMgrGeneric() = delete;
52 XAieRscMgrGeneric(XAieDevHandle *DevHd):
53 XAieRscMgrBackend(DevHd) {
54 std::string errStr = "Could not create resource manager";
55 if (rscBitmapsInit() != XAIE_OK) {
56 throw std::runtime_error(errStr);
57 }
58 }
59 ~XAieRscMgrGeneric() {
60 for(uint8_t TType = 0U; TType < (uint8_t)XAIEGBL_TILE_TYPE_MAX; TType++) {
61 if (TType == XAIEGBL_TILE_TYPE_SHIMNOC)
62 continue;
63
64 for (uint8_t RType = 0U; RType < (uint8_t)XAIE_MAXRSC; RType++) {
65 auto MaxRsc = RscMaps[TType].MaxRscs[RType];
66 uint32_t NumRscs = 0;
67
68 for (auto x: MaxRsc)
69 NumRscs += x.second;
70
71 if (NumRscs == 0U)
72 continue;
73
74 delete RscMaps[TType].Bitmaps[RType];
75 }
76 }
77 }
78
87 AieRC request(XAieUserRsc& RscReq) {
88 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), RscReq.Loc);
89 uint32_t StartBit, StaticOffset, MaxRscId;
90
91 if ((XAie_CheckModule(dev(), RscReq.Loc, RscReq.Mod) != XAIE_OK) ||
92 TileType >= XAIEGBL_TILE_TYPE_MAX) {
93 Logger::log(LogLevel::FAL_WARN) << __func__ <<
94 " Invalid Location/Module for request" << std::endl;
95 return XAIE_INVALID_ARGS;
96 }
97
98 StaticOffset = getStaticOff(RscReq.Loc, RscReq.Mod, RscReq.RscType);
99 StartBit = getStartBit(RscReq.Loc, RscReq.Mod, RscReq.RscType);
100 MaxRscId = getMaxRsc(RscReq.Loc, RscReq.Mod, RscReq.RscType);
101 auto Bitmap = RscMaps[TileType].Bitmaps[RscReq.RscType];
102
103 for (uint32_t i = 0; i < MaxRscId; i++) {
104 uint32_t sIndex, rIndex, rBit, sBit;
105
106 sIndex = (StartBit + StaticOffset) / 32U;
107 sBit = (StartBit + StaticOffset) % 32U;
108 rIndex = StartBit / 32U;
109 rBit = StartBit % 32U;
114 if (!(Bitmap->at(sIndex).test(sBit) |
115 Bitmap->at(rIndex).test(rBit))) {
116 Bitmap->at(rIndex).set(rBit);
117 RscReq.RscId = i;
118 return XAIE_OK;
119 }
120 StartBit++;
121 }
122 return XAIE_ERR;
123 }
124
133 AieRC requestAllocated(XAieUserRsc& RscReq) {
134 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), RscReq.Loc);
135 uint32_t StaticOff, rBit, sBit, rIndex, sIndex;
136
137 if ((XAie_CheckModule(dev(), RscReq.Loc, RscReq.Mod) != XAIE_OK) ||
138 TileType >= XAIEGBL_TILE_TYPE_MAX) {
139 Logger::log(LogLevel::FAL_WARN) << __func__ <<
140 " Invalid Location/Module for request" << std::endl;
141 return XAIE_INVALID_ARGS;
142 }
143
144 if (RscReq.RscId > getMaxRsc(RscReq.Loc, RscReq.Mod, RscReq.RscType)) {
145 Logger::log(LogLevel::FAL_WARN) << __func__ <<
146 " Invalid resource id for request" << std::endl;
147 return XAIE_INVALID_ARGS;
148 }
149
150 rBit = RscReq.RscId + getStartBit(RscReq.Loc, RscReq.Mod, RscReq.RscType);
151 StaticOff = getStaticOff(RscReq.Loc, RscReq.Mod, RscReq.RscType);
152 auto Bitmap = RscMaps[TileType].Bitmaps[RscReq.RscType];
153
154 sIndex = (rBit + StaticOff) / 32U;
155 sBit = (rBit + StaticOff) % 32U;
156 rIndex = rBit / 32U;
157 rBit %= 32U;
158
159 if (!(Bitmap->at(sIndex).test(sBit) |
160 Bitmap->at(rIndex).test(rBit))) {
161 Bitmap->at(rIndex).set(rBit);
162 return XAIE_OK;
163 }
164 return XAIE_ERR;
165 }
166
175 AieRC requestContiguous(std::vector<XAieUserRsc>& RscReq) {
176 uint32_t StaticOff, StartBit, MaxRscId, NumContigRscs;
177 uint8_t TileType;
178
179 if (RscReq.size() <= 0) {
180 return XAIE_ERR;
181 }
182
183 TileType = XAie_GetTileTypefromLoc(dev(), RscReq[0].Loc);
184 if ((XAie_CheckModule(dev(), RscReq[0].Loc, RscReq[0].Mod) != XAIE_OK) ||
185 TileType >= XAIEGBL_TILE_TYPE_MAX) {
186 Logger::log(LogLevel::FAL_WARN) << __func__ <<
187 " Invalid Location/Module for request" << std::endl;
188 return XAIE_INVALID_ARGS;
189 }
190
191 StaticOff = getStaticOff(RscReq[0].Loc, RscReq[0].Mod, RscReq[0].RscType);
192 StartBit = getStartBit(RscReq[0].Loc, RscReq[0].Mod, RscReq[0].RscType);
193 MaxRscId = getMaxRsc(RscReq[0].Loc, RscReq[0].Mod, RscReq[0].RscType);
194 NumContigRscs = RscReq.size();
195 auto Bitmap = RscMaps[TileType].Bitmaps[RscReq[0].RscType];
196
197 for (uint32_t i = 0; i < MaxRscId; i++) {
198 uint32_t sIndex, rIndex, sBit, rBit;
199 uint8_t j, k;
200
201 sIndex = (StartBit + StaticOff) / 32U;
202 sBit = (StartBit + StaticOff) % 32U;
203 rIndex = StartBit / 32U;
204 rBit = StartBit % 32U;
205
206 if (!(Bitmap->at(sIndex).test(sBit) |
207 Bitmap->at(rIndex).test(rBit))) {
208 for (j = 1; j < NumContigRscs; j++) {
209 if ((sBit + j) >= 32U)
210 sIndex++;
211 if ((rBit + j) >= 32U)
212 rIndex++;
213
214 if (Bitmap->at(sIndex).test((sBit + j) % 32U) |
215 Bitmap->at(rIndex).test((rBit + j) % 32U)) {
216 break;
217 }
218 }
219 if (j == NumContigRscs) {
220 for (k = 0; k < j; k++) {
221 rIndex = (StartBit + k) / 32U;
222 rBit = (StartBit + k) % 32U;
223 Bitmap->at(rIndex).set(rBit);
224 RscReq[k].RscId = i + k;
225 }
226 return XAIE_OK;
227 }
228 }
229 StartBit++;
230 }
231 return XAIE_ERR;
232 }
233
243 AieRC requestBc(std::vector<XAieUserRsc>& RscReq, bool isBcAll) {
244 uint32_t preferredId, MaxRscId, CommonId;
245
246 preferredId = RscReq[0].RscId;
247 if (isBcAll) {
248 if (setBcAllRscs(RscReq, preferredId) != XAIE_OK)
249 return XAIE_ERR;
250 }
251
252 MaxRscId = getMaxRsc(RscReq[0].Loc, RscReq[0].Mod, RscReq[0].RscType);
253 if ((preferredId != XAIE_RSC_ID_ANY) &&
254 (preferredId >= MaxRscId)) {
255 Logger::log(LogLevel::FAL_WARN) << __func__ <<
256 " Invalid resource id for request" << std::endl;
257 return XAIE_INVALID_ARGS;
258 }
259
260 CommonId = getCommonRscId(RscReq);
261 if (CommonId == XAIE_RSC_ID_ANY) {
262 Logger::log(LogLevel::FAL_WARN) << __func__ <<
263 " Unable to find common broadcast channel"
264 << std::endl;
265 return XAIE_ERR;
266 }
267
268 for (uint32_t i = 0; i < RscReq.size(); i++) {
269 uint8_t TType = XAie_GetTileTypefromLoc(dev(), RscReq[i].Loc);
270 auto Bitmap = RscMaps[TType].Bitmaps[RscReq[i].RscType];
271 uint32_t StartBit, rBit, rIndex;
272
273 if (TType == XAIEGBL_TILE_TYPE_MAX) {
274 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
275 " Invalid Tile Type" << std::endl;
276 return XAIE_INVALID_TILE;
277 }
278
279 RscReq[i].RscId = CommonId;
280 StartBit = CommonId + getStartBit(RscReq[i].Loc, RscReq[i].Mod,
281 RscReq[i].RscType);
282 rIndex = StartBit / 32U;
283 rBit = StartBit % 32U;
284
285 Bitmap->at(rIndex).set(rBit);
286 }
287 return XAIE_OK;
288 }
289
298 AieRC release(XAieUserRsc& RscRel) {
299 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), RscRel.Loc);
300 uint32_t sBit, rBit, sIndex, rIndex, StaticOff;
301
302 if ((XAie_CheckModule(dev(), RscRel.Loc, RscRel.Mod) != XAIE_OK) ||
303 TileType >= XAIEGBL_TILE_TYPE_MAX) {
304 Logger::log(LogLevel::FAL_WARN) << __func__ <<
305 " Invalid Location/Module for release" << std::endl;
306 return XAIE_INVALID_ARGS;
307 }
308
309 if (RscRel.RscId >= getMaxRsc(RscRel.Loc, RscRel.Mod, RscRel.RscType)) {
310 Logger::log(LogLevel::FAL_WARN) << __func__ <<
311 " Invalid resource id for release" << std::endl;
312 return XAIE_INVALID_ARGS;
313 }
314
315 rBit = RscRel.RscId + getStartBit(RscRel.Loc, RscRel.Mod, RscRel.RscType);
316 StaticOff = getStaticOff(RscRel.Loc, RscRel.Mod, RscRel.RscType);
317 auto Bitmap = RscMaps[TileType].Bitmaps[RscRel.RscType];
318
319 sIndex = (rBit + StaticOff) / 32U;
320 sBit = (rBit + StaticOff) % 32U;
321 rIndex = rBit / 32U;
322 rBit %= 32U;
323
324 Bitmap->at(rIndex).reset(rBit);
325 Bitmap->at(sIndex).reset(sBit);
326 return XAIE_OK;
327 }
328
337 AieRC free(XAieUserRsc& RscFree) {
338 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), RscFree.Loc);
339 uint32_t rBit, rIndex;
340
341 if ((XAie_CheckModule(dev(), RscFree.Loc, RscFree.Mod) != XAIE_OK) ||
342 TileType >= XAIEGBL_TILE_TYPE_MAX) {
343 Logger::log(LogLevel::FAL_WARN) << __func__ <<
344 " Invalid Location/Module for free" << std::endl;
345 return XAIE_INVALID_ARGS;
346 }
347
348 if (RscFree.RscId >= getMaxRsc(RscFree.Loc, RscFree.Mod, RscFree.RscType)) {
349 Logger::log(LogLevel::FAL_WARN) << __func__ <<
350 " Invalid resource id for free" << std::endl;
351 return XAIE_INVALID_ARGS;
352 }
353
354 rBit = RscFree.RscId + getStartBit(RscFree.Loc, RscFree.Mod, RscFree.RscType);
355 auto Bitmap = RscMaps[TileType].Bitmaps[RscFree.RscType];
356
357 rIndex = rBit / 32U;
358 rBit %= 32U;
359
360 Bitmap->at(rIndex).reset(rBit);
361 return XAIE_OK;
362 }
363
370 AieRC getRscStats(std::vector<XAieUserRscStat> &vStats,
371 XAieRscBitmapType BType) {
372 for (uint32_t i = 0; i < vStats.size(); i++) {
373 uint32_t StartBit, StaticOff, MaxRscId, NumRscs = 0;
374 uint32_t sBit, sIndex, rBit, rIndex;
375 XAie_ModuleType Mod = vStats[i].Mod;
376 XAieRscType Type = vStats[i].RscType;
377 XAie_LocType Loc = vStats[i].Loc;
378 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), Loc);
379
380 if ((XAie_CheckModule(dev(), Loc, Mod) != XAIE_OK) ||
381 TileType >= XAIEGBL_TILE_TYPE_MAX) {
382 Logger::log(LogLevel::FAL_WARN) << __func__ <<
383 " Invalid Location/Module for stat request"
384 << std::endl;
385 return XAIE_INVALID_ARGS;
386 }
387 if (Type >= XAIE_MAXRSC) {
388 Logger::log(LogLevel::FAL_WARN) << __func__ <<
389 " Invalid resource type for stat request"
390 << std::endl;
391 return XAIE_INVALID_ARGS;
392 }
393
394 MaxRscId = getMaxRsc(Loc, Mod, Type);
395 StartBit = getStartBit(Loc, Mod, Type);
396 StaticOff = getStaticOff(Loc, Mod, Type);
397 auto Bitmap = RscMaps[TileType].Bitmaps[Type];
398
399 sIndex = (StartBit + StaticOff) / 32U;
400 sBit = (StartBit + StaticOff) % 32U;
401 rIndex = StartBit / 32U;
402 rBit = StartBit % 32U;
403
404 for (uint8_t j = 0; j < MaxRscId; j++) {
405 if (sBit >= 32U) {
406 sIndex++;
407 sBit %= 32U;
408 }
409 if (rBit >= 32U) {
410 rIndex++;
411 rBit %= 32U;
412 }
413 if (BType == XAIE_STATIC_RSC) {
414 if (Bitmap->at(sIndex).test(sBit))
415 NumRscs++;
416 } else if (BType == XAIE_AVAIL_RSC) {
417 if (!(Bitmap->at(sIndex).test(sBit) |
418 Bitmap->at(rIndex).test(rBit)))
419 NumRscs++;
420 }
421
422 sBit++;
423 rBit++;
424 }
425 vStats[i].NumRscs = NumRscs;
426 }
427 return XAIE_OK;
428 }
429
440 AieRC writeRscBitmaps(std::ofstream &Fs, uint64_t &NumRscs) {
441 uint8_t TType, RType;
442 NumRscs = 0U;
443
444 for (TType = 0; TType < XAIEGBL_TILE_TYPE_MAX; TType++) {
445 uint32_t NumRows, NumMods;
446
447 if (TType == XAIEGBL_TILE_TYPE_SHIMNOC)
448 continue;
449
450 NumMods = dev()->DevProp.DevMod[TType].NumModules;
451 NumRows = XAie_GetNumRows(dev(), TType);
452
453 for (RType = 0; RType < XAIE_MAXRSC; RType++) {
454 auto MaxRsc = &RscMaps[TType].MaxRscs[RType];
455 auto Bitmap = RscMaps[TType].Bitmaps[RType];
456
457 /*
458 * TODO: add support for MDM perfcount
459 * rsc in Linux driver. Once added we
460 * remove the below statement
461 */
462 if (RType == XAIE_MDMPERFCNT)
463 continue;
464
465 for (uint8_t i = 0; i < NumMods; i++) {
466 uint32_t Size, ModOff = 0U;
467 uint64_t RscHeader;
468 XAie_ModuleType Mod;
469
470 if (MaxRsc->at(i).second == 0U)
471 continue;
472
473 Mod = estimateModfromIndex(TType, i);
474 Size = roundUp(NumRows * dev()->NumCols *
475 MaxRsc->at(i).second, 32U);
476 Size /= 32U;
477
478 RscHeader = createRscHeader(TType,
479 static_cast<XAieRscType>(RType),
480 Mod, Size);
481 Fs.write(reinterpret_cast<char *>(&RscHeader),
482 sizeof(RscHeader));
483 if (Fs.fail())
484 return XAIE_ERR;
485
486 if (Mod == XAIE_CORE_MOD) {
487 ModOff = (MaxRsc->at(XAIE_MEM_MOD).second *
488 dev()->NumCols * NumRows * 2U) / 32U;
489 }
490
491 for (uint32_t Word = 0U; Word < Size; Word += 2U) {
492 uint32_t Index = Word + ModOff;
493 uint64_t Payload = 0U;
494
495 /*
496 * If bitmap size is odd number of 32 bit
497 * bitmaps, pad with extra zeros to create
498 * 64 bit payloads
499 */
500 if (Word != Size - 1U) {
501 Payload |= (uint64_t)Bitmap->at(Index +
502 1).to_ulong() << 32U;
503 Payload |= Bitmap->at(Index).to_ulong();
504 } else {
505 Payload = Bitmap->at(Index).to_ulong();
506 }
507 Fs.write(reinterpret_cast<char *>(&Payload),
508 sizeof(Payload));
509 if (Fs.fail())
510 return XAIE_ERR;
511 }
512 NumRscs++;
513 }
514 }
515 }
516 return XAIE_OK;
517 }
518
528 AieRC loadRscBitmaps(const char *MetaData, uint64_t NumBitmaps) {
529 uint64_t *Data = (uint64_t *)MetaData;
530
531 for (uint32_t i = 0; i < NumBitmaps; i++) {
532 uint32_t BitmapSize, Bitmap64Size, BitmapOffset = 0U;
533 uint32_t RscSize, NumRows, NumRscs;
534 const uint64_t *Bits64;
535 XAie_ModuleType Mod;
536 XAieRscType RscType;
537 uint64_t RscHeader;
538 uint8_t TileType;
539
540 RscHeader = Data[0U];
541 TileType = (RscHeader >> XAIE_RSC_HEADER_TTYPE_SHIFT)
542 & XAIE_RSC_HEADER_TTYPE_MASK;
543 Mod = static_cast<XAie_ModuleType>(
544 (RscHeader >> XAIE_RSC_HEADER_MOD_SHIFT)
545 & XAIE_RSC_HEADER_MOD_MASK);
546 RscType = static_cast<XAieRscType>(
547 (RscHeader >> XAIE_RSC_HEADER_RTYPE_SHIFT)
548 & XAIE_RSC_HEADER_RTYPE_MASK);
549 RscSize = (RscHeader >> XAIE_RSC_HEADER_SIZE_SHIFT)
550 & XAIE_RSC_HEADER_SIZE_MASK;
551
552 if (RscSize == 0U) {
553 Logger::log(LogLevel::FAL_ERROR) <<
554 "Invalid resource length in bitmap"
555 << std::endl;
556 return XAIE_INVALID_ARGS;
557 }
558
559 if (TileType == XAIEGBL_TILE_TYPE_SHIMNOC ||
560 TileType >= XAIEGBL_TILE_TYPE_MAX) {
561 Logger::log(LogLevel::FAL_ERROR) <<
562 "Invalid tile type in bitmap"
563 << std::endl;
564 return XAIE_INVALID_ARGS;
565 }
566
567 NumRows = XAie_GetNumRows(dev(), TileType);
568 NumRscs = getTotalRscs(TileType, Mod, RscType);
569 BitmapSize = NumRows * dev()->NumCols * NumRscs;
570 Bitmap64Size = roundUp(BitmapSize, 64U) / 64U;
571
572 if (RscSize != Bitmap64Size) {
573 Logger::log(LogLevel::FAL_ERROR) <<
574 "Invalid resource length in bitmap"
575 << std::endl;
576 return XAIE_INVALID_ARGS;
577 }
578
579 if (Mod == XAIE_CORE_MOD) {
580 uint32_t MemModRscs;
581
582 MemModRscs = getTotalRscs(TileType, XAIE_MEM_MOD,
583 RscType);
584 BitmapOffset = MemModRscs * dev()->NumCols *
585 NumRows * 2U;
586 }
587 /* Get static bitmap offset */
588 BitmapOffset += BitmapSize;
589 BitmapOffset /= 32U;
590 Bits64 = &Data[1U];
591
592 auto StaticBitmap = RscMaps[TileType].Bitmaps[RscType];
593 for (uint32_t j = 0; j < RscSize; j++) {
594 uint64_t Val64 = Bits64[j];
595
596 for (uint8_t k = 0; k < 64U; k++) {
597 uint32_t Pos;
598
599 Pos = k + (j * 64U);
600 if (Pos > BitmapSize)
601 break;
602
603 if (Val64 & 1LU) {
604 uint32_t Index;
605
606 Index = BitmapOffset + (Pos / 32U);
607 StaticBitmap->at(Index).set(Pos % 32U);
608 }
609 Val64 >>= 1U;
610 }
611 }
612
613 Data = (uint64_t *)((const char *)Data + sizeof(RscHeader)
614 + (RscSize * sizeof(uint64_t)));
615 }
616 return XAIE_OK;
617 }
618
619 private:
620 AieRscMap RscMaps[XAIEGBL_TILE_TYPE_MAX];
621
628 AieRC rscBitmapsInit() {
629 uint8_t TType, RType;
630
631 for (TType = 0; TType < XAIEGBL_TILE_TYPE_MAX; TType++) {
632 uint32_t NumRows;
633
634 if (TType == XAIEGBL_TILE_TYPE_SHIMNOC)
635 continue;
636
637 NumRows = XAie_GetNumRows(dev(), TType);
638 for (RType = 0; RType < (uint8_t)XAIE_MAXRSC; RType++) {
639 auto MaxRsc = &RscMaps[TType].MaxRscs[RType];
640 uint32_t BitmapSize, TotalRscs = 0;
641
642 if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
643 uint32_t numRscs = 0;
644
645 /* Mem Module */
646 numRscs = getTotalRscs(TType, XAIE_MEM_MOD,
647 static_cast<XAieRscType>(RType));
648 MaxRsc->push_back(std::make_pair(XAIE_MEM_MOD, numRscs));
649 TotalRscs += numRscs;
650 /* Core Module */
651 numRscs = getTotalRscs(TType, XAIE_CORE_MOD,
652 static_cast<XAieRscType>(RType));
653 MaxRsc->push_back(std::make_pair(XAIE_CORE_MOD, numRscs));
654 TotalRscs += numRscs;
655 } else if (TType == XAIEGBL_TILE_TYPE_MEMTILE) {
656 uint32_t numRscs = 0;
657
658 numRscs = getTotalRscs(TType, XAIE_MEM_MOD,
659 static_cast<XAieRscType>(RType));
660 MaxRsc->push_back(std::make_pair(XAIE_MEM_MOD, numRscs));
661 TotalRscs += numRscs;
662 } else {
663 uint32_t numRscs = 0;
664
665 numRscs = getTotalRscs(TType, XAIE_PL_MOD,
666 static_cast<XAieRscType>(RType));
667 MaxRsc->push_back(std::make_pair(XAIE_PL_MOD, numRscs));
668 TotalRscs += numRscs;
669 }
670
676 BitmapSize = roundUp(NumRows * dev()->NumCols * TotalRscs * 2U, 32U);
677 if (BitmapSize == 0U)
678 continue;
679
680 BitmapSize /= 32U;
681 RscMaps[TType].Bitmaps[RType] = new XAieRscBitmap(BitmapSize + 1);
682 }
683 }
684 RscMaps[XAIEGBL_TILE_TYPE_SHIMNOC] = RscMaps[XAIEGBL_TILE_TYPE_SHIMPL];
685 return XAIE_OK;
686 }
687
698 uint32_t getStaticOff(XAie_LocType Loc, XAie_ModuleType Mod, XAieRscType Type) {
699 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), Loc);
700 uint32_t NumCols, NumRows, MaxRscId;
701
702 NumRows = XAie_GetNumRows(dev(), TileType);
703 MaxRscId = getMaxRsc(Loc, Mod, Type);
704 NumCols = dev()->NumCols;
705
706 return NumRows * NumCols * MaxRscId;
707 }
708
720 uint32_t getStartBit(XAie_LocType Loc, XAie_ModuleType Mod, XAieRscType Type) {
721 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), Loc);
722 uint32_t NumCols, NumRows, StartRow;
723 uint32_t StartBit, ModOffset = 0U;
724
725 StartRow = XAie_GetStartRow(dev(), TileType);
726 NumRows = XAie_GetNumRows(dev(), TileType);
727 NumCols = dev()->NumCols;
728
729 if (Mod == XAIE_CORE_MOD)
730 ModOffset = getMaxRsc(Loc, XAIE_MEM_MOD, Type) *
731 NumCols * NumRows * 2U;
732
733 StartBit = ModOffset + (getMaxRsc(Loc, Mod, Type) *
734 (Loc.Col * NumRows + (Loc.Row - StartRow)));
735
736 return StartBit;
737 }
738
750 uint32_t getMaxRsc(XAie_LocType Loc, XAie_ModuleType Mod, XAieRscType Type) {
751 uint8_t TileType = XAie_GetTileTypefromLoc(dev(), Loc);
752
753 auto vMaxRscs = RscMaps[TileType].MaxRscs[Type];
754 for (auto x : vMaxRscs)
755 if (x.first == Mod)
756 return x.second;
757 return 0;
758 }
759
770 uint32_t getCommonRscId(std::vector<XAieUserRsc> vRscs) {
771 std::bitset<32> RscStatus;
772 uint32_t MaxRscId;
773
774 for (auto rsc : vRscs) {
775 uint8_t TType = XAie_GetTileTypefromLoc(dev(), rsc.Loc);
776 uint32_t sIndex, rIndex, sBit, rBit;
777 uint32_t StartBit, StaticOff, Mask;
778
779 if ((XAie_CheckModule(dev(), rsc.Loc, rsc.Mod) != XAIE_OK) ||
780 TType >= XAIEGBL_TILE_TYPE_MAX) {
781 Logger::log(LogLevel::FAL_WARN) << __func__ <<
782 " Invalid Location/Module for request" << std::endl;
783 return XAIE_RSC_ID_ANY;
784 }
785
786 MaxRscId = getMaxRsc(rsc.Loc, rsc.Mod, rsc.RscType);
787 if (MaxRscId > 32U) {
788 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
789 " Max resource ID larger than bitmap size"
790 << std::endl;
791 return XAIE_RSC_ID_ANY;
792 }
793
794 StaticOff = getStaticOff(rsc.Loc, rsc.Mod, rsc.RscType);
795 StartBit = getStartBit(rsc.Loc, rsc.Mod, rsc.RscType);
796 auto Bitmap = RscMaps[TType].Bitmaps[rsc.RscType];
797 Mask = (1 << MaxRscId) - 1;
798
799 sIndex = (StartBit + StaticOff) / 32U;
800 sBit = (StartBit + StaticOff) % 32U;
801 rIndex = StartBit / 32U;
802 rBit = StartBit % 32U;
803
804 /* Check static and runtime bitmaps */
805 RscStatus |= (Bitmap->at(sIndex) >> sBit) |
806 (Bitmap->at(rIndex) >> rBit);
807 RscStatus &= Mask;
808
809 if ((sBit + MaxRscId) > 32U) {
810 uint32_t remBits = (sBit + MaxRscId) % 32U;
811 std::bitset<32> Temp;
812
813 Mask = (1 << remBits) - 1 ;
814 Temp |= Bitmap->at(sIndex + 1);
815 Temp &= Mask;
816 Temp << (MaxRscId - remBits);
817 RscStatus |= Temp;
818 }
819 if ((rBit + MaxRscId) > 32U) {
820 uint32_t remBits = (rBit + MaxRscId) % 32U;
821 std::bitset<32> Temp;
822
823 Mask = (1 << remBits) - 1 ;
824 Temp |= Bitmap->at(rIndex + 1);
825 Temp &= Mask;
826 Temp << (MaxRscId - remBits);
827 RscStatus |= Temp;
828 }
829 }
830
831 if (vRscs[0].RscId == XAIE_RSC_ID_ANY) {
832 for (uint8_t i = 0; i < MaxRscId; i++)
833 if (!RscStatus.test(i))
834 return i;
835 } else {
836 if (RscStatus.test(vRscs[0].RscId))
837 return XAIE_RSC_ID_ANY;
838 else
839 return vRscs[0].RscId;
840 }
841 return XAIE_RSC_ID_ANY;
842 }
843
853 AieRC setBcAllRscs(std::vector<XAieUserRsc> &vRscs, uint32_t preferredId) {
854 std::vector<XAie_LocType> Locs;
855 uint32_t NumTiles;
856 XAieUserRsc Rsc;
857 AieRC RC;
858
859 vRscs.clear();
860 NumTiles = dev()->NumCols * dev()->NumRows;
861 Locs.resize(NumTiles);
862 RC = XAie_GetUngatedLocsInPartition(dev(),
863 &NumTiles, Locs.data());
864 if (RC != XAIE_OK) {
865 Logger::log(LogLevel::FAL_WARN) <<
866 "Unable to get ungated locs" <<
867 std::endl;
868 return RC;
869 }
870 Locs.resize(NumTiles);
871
872 Rsc.RscType = XAIE_BROADCAST;
873 Rsc.RscId = preferredId;
874 for (auto loc : Locs) {
875 uint8_t TType;
876
877 TType = XAie_GetTileTypefromLoc(dev(), loc);
878 Rsc.Loc = loc;
879 if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
880 Rsc.Mod = XAIE_MEM_MOD;
881 vRscs.push_back(Rsc);
882 Rsc.Mod = XAIE_CORE_MOD;
883 vRscs.push_back(Rsc);
884 } else if (TType == XAIEGBL_TILE_TYPE_MEMTILE) {
885 Rsc.Mod = XAIE_MEM_MOD;
886 vRscs.push_back(Rsc);
887 } else {
888 Rsc.Mod = XAIE_PL_MOD;
889 vRscs.push_back(Rsc);
890 }
891 }
892 return XAIE_OK;
893 }
894
905 uint32_t getTotalRscs(uint8_t TileType, XAie_ModuleType Mod, XAieRscType RscType) {
906 switch(RscType) {
907 case XAIE_PERFCOUNT:
908 {
909 const XAie_PerfMod *PerfMod;
910
911 if (Mod == XAIE_PL_MOD)
912 PerfMod = &dev()->DevProp.DevMod[TileType].PerfMod[0U];
913 else
914 PerfMod = &dev()->DevProp.DevMod[TileType].PerfMod[Mod];
915
916 if(!PerfMod)
917 return 0U;
918
919 return PerfMod->MaxCounterVal;
920 }
921 case XAIE_USEREVENT:
922 {
923 const XAie_EvntMod *EventMod;
924
925 if (Mod == XAIE_PL_MOD)
926 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[0U];
927 else
928 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[Mod];
929
930 if(!EventMod)
931 return 0U;
932
933 return EventMod->NumUserEvents;
934 }
935 case XAIE_TRACECTRL:
936 {
937 if (XAie_GetNumRows(dev(), TileType) > 0U)
938 return XAIE_TRACE_PER_MOD;
939 else
940 return 0U;
941 }
942 case XAIE_PCEVENT:
943 {
944 const XAie_EvntMod *EventMod;
945
946 if (Mod == XAIE_PL_MOD)
947 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[0U];
948 else
949 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[Mod];
950
951 if(!EventMod)
952 return 0U;
953
954 return EventMod->NumPCEvents;
955 }
956 case XAIE_SSEVENT:
957 {
958 const XAie_EvntMod *EventMod;
959
960 if (Mod == XAIE_PL_MOD)
961 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[0U];
962 else
963 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[Mod];
964
965 if(!EventMod)
966 return 0U;
967
968 return EventMod->NumStrmPortSelectIds;
969
970 }
971 case XAIE_BROADCAST:
972 {
973 const XAie_EvntMod *EventMod;
974
975 if (Mod == XAIE_PL_MOD)
976 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[0U];
977 else
978 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[Mod];
979
980 if(!EventMod)
981 return 0U;
982
983 return EventMod->NumBroadcastIds;
984
985 }
986 case XAIE_COMBOEVENT:
987 {
988 if (XAie_GetNumRows(dev(), TileType) > 0U)
989 return XAIE_COMBO_PER_MOD;
990 else
991 return 0U;
992 }
993 case XAIE_GROUPEVENT:
994 {
995 const XAie_EvntMod *EventMod;
996
997 if (Mod == XAIE_PL_MOD)
998 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[0U];
999 else
1000 EventMod = &dev()->DevProp.DevMod[TileType].EvntMod[Mod];
1001
1002 if(!EventMod)
1003 return 0U;
1004
1005 return EventMod->NumGroupEvents;
1006
1007 }
1008 case XAIE_MDMPERFCNT:
1009 {
1010 if ((XAie_GetNumRows(dev(), TileType) > 0U) &&
1011 (Mod == XAIE_PL_MOD))
1012 return XAIE_MDMPERF_PER_MOD;
1013 else
1014 return 0U;
1015 }
1016 default:
1017 return 0U;
1018 }
1019 }
1020
1032 uint64_t createRscHeader(uint8_t TType, XAieRscType RType,
1033 XAie_ModuleType Mod, uint32_t Size) {
1034 uint64_t Ret = 0;
1035
1036 Size = (Size % 2U) ? (Size + 1U) : Size;
1037 Size /= 2U;
1038
1039 Ret |= (static_cast<uint64_t>(TType) &
1040 XAIE_RSC_HEADER_TTYPE_MASK) <<
1041 XAIE_RSC_HEADER_TTYPE_SHIFT;
1042 Ret |= (static_cast<uint64_t>(RType) &
1043 XAIE_RSC_HEADER_RTYPE_MASK) <<
1044 XAIE_RSC_HEADER_RTYPE_SHIFT;
1045 Ret |= (static_cast<uint64_t>(Mod) &
1046 XAIE_RSC_HEADER_MOD_MASK) <<
1047 XAIE_RSC_HEADER_MOD_SHIFT;
1048 Ret |= (static_cast<uint64_t>(Size) &
1049 XAIE_RSC_HEADER_SIZE_MASK) <<
1050 XAIE_RSC_HEADER_SIZE_SHIFT;
1051 return Ret;
1052 }
1059 XAie_ModuleType estimateModfromIndex(uint8_t TileType, uint32_t Index) {
1060 XAie_ModuleType Mod = static_cast<XAie_ModuleType>(XAIE_MOD_ANY);
1061
1062 switch(TileType) {
1063 case XAIEGBL_TILE_TYPE_AIETILE:
1064 {
1065 if (Index == 0U) {
1066 Mod = XAIE_MEM_MOD;
1067 } else {
1068 Mod = XAIE_CORE_MOD;
1069 }
1070 break;
1071 }
1072 case XAIEGBL_TILE_TYPE_MEMTILE:
1073 {
1074 if (Index == 0U) {
1075 Mod = XAIE_MEM_MOD;
1076 }
1077 break;
1078 }
1079 case XAIEGBL_TILE_TYPE_SHIMNOC:
1080 case XAIEGBL_TILE_TYPE_SHIMPL:
1081 {
1082 if (Index == 0U) {
1083 Mod = XAIE_PL_MOD;
1084 }
1085 break;
1086 }
1087 default:
1088 Mod = static_cast<XAie_ModuleType>(XAIE_MOD_ANY);
1089 }
1090 return Mod;
1091 }
1101 uint32_t roundUp(uint32_t Val, uint32_t Aligned) {
1102 return (Aligned * ((Val + (Aligned - 1U)) / Aligned));
1103 }
1104 }; /* class XAieRscMgrGeneric */
1105} /* 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::XAieRscMgrBackend::dev
XAie_DevInst * dev()
Definition xaiefal-rscmgr-backend-base.hpp:244
xaiefal::XAieRscMgrGeneric::writeRscBitmaps
AieRC writeRscBitmaps(std::ofstream &Fs, uint64_t &NumRscs)
Definition xaiefal-rscmgr-generic.hpp:440
xaiefal::XAieRscMgrGeneric::request
AieRC request(XAieUserRsc &RscReq)
Definition xaiefal-rscmgr-generic.hpp:87
xaiefal::XAieRscMgrGeneric::free
AieRC free(XAieUserRsc &RscFree)
Definition xaiefal-rscmgr-generic.hpp:337
xaiefal::XAieRscMgrGeneric::~XAieRscMgrGeneric
~XAieRscMgrGeneric()
Definition xaiefal-rscmgr-generic.hpp:59
xaiefal::XAieRscMgrGeneric::requestContiguous
AieRC requestContiguous(std::vector< XAieUserRsc > &RscReq)
Definition xaiefal-rscmgr-generic.hpp:175
xaiefal::XAieRscMgrGeneric::release
AieRC release(XAieUserRsc &RscRel)
Definition xaiefal-rscmgr-generic.hpp:298
xaiefal::XAieRscMgrGeneric::loadRscBitmaps
AieRC loadRscBitmaps(const char *MetaData, uint64_t NumBitmaps)
Definition xaiefal-rscmgr-generic.hpp:528
xaiefal::XAieRscMgrGeneric::getRscStats
AieRC getRscStats(std::vector< XAieUserRscStat > &vStats, XAieRscBitmapType BType)
Definition xaiefal-rscmgr-generic.hpp:370
xaiefal::XAieRscMgrGeneric::requestAllocated
AieRC requestAllocated(XAieUserRsc &RscReq)
Definition xaiefal-rscmgr-generic.hpp:133
xaiefal::XAieRscMgrGeneric::XAieRscMgrGeneric
XAieRscMgrGeneric(XAieDevHandle *DevHd)
Definition xaiefal-rscmgr-generic.hpp:52
xaiefal::XAieRscMgrGeneric::requestBc
AieRC requestBc(std::vector< XAieUserRsc > &RscReq, bool isBcAll)
Definition xaiefal-rscmgr-generic.hpp:243
XAie_ModuleType
xaiefal
Definition xaiefal-base.hpp:23
xaiefal::XAieRscBitmap
std::vector< std::bitset< 32 > > XAieRscBitmap
Vector of 32 bit bitsets used to represent resource bitmaps.
Definition xaiefal-rscmgr-generic.hpp:30
xaiefal::XAieRscMaxRsc
std::vector< std::pair< XAie_ModuleType, uint32_t > > XAieRscMaxRsc
Type to hold max resources per module given tile type.
Definition xaiefal-rscmgr-generic.hpp:35
xaiefal::XAieRscType
XAieRscType
Enums representing all requestable resources.
Definition xaiefal-rsc-group.hpp:27
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::XAieRscBitmapType
XAieRscBitmapType
Definition xaiefal-rscmgr-backend-base.hpp:14
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::AieRscMap
Structure containing resource bitmaps and relevant information.
Definition xaiefal-rscmgr-generic.hpp:41
xaiefal::AieRscMap::Bitmaps
XAieRscBitmap * Bitmaps[XAIE_MAXRSC]
Definition xaiefal-rscmgr-generic.hpp:42
xaiefal::AieRscMap::MaxRscs
XAieRscMaxRsc MaxRscs[XAIE_MAXRSC]
Definition xaiefal-rscmgr-generic.hpp:43
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_MOD_ANY
#define XAIE_MOD_ANY
Definition xaiefal-common.hpp:9
XAIE_RSC_ID_ANY
#define XAIE_RSC_ID_ANY
Definition xaiefal-common.hpp:7
XAIE_RSC_HEADER_TTYPE_SHIFT
#define XAIE_RSC_HEADER_TTYPE_SHIFT
Definition xaiefal-rscmgr-generic.hpp:15
XAIE_RSC_HEADER_MOD_SHIFT
#define XAIE_RSC_HEADER_MOD_SHIFT
Definition xaiefal-rscmgr-generic.hpp:17
XAIE_RSC_HEADER_RTYPE_MASK
#define XAIE_RSC_HEADER_RTYPE_MASK
Definition xaiefal-rscmgr-generic.hpp:20
XAIE_RSC_HEADER_RTYPE_SHIFT
#define XAIE_RSC_HEADER_RTYPE_SHIFT
Definition xaiefal-rscmgr-generic.hpp:19
XAIE_MDMPERF_PER_MOD
#define XAIE_MDMPERF_PER_MOD
Definition xaiefal-rscmgr-generic.hpp:13
XAIE_RSC_HEADER_TTYPE_MASK
#define XAIE_RSC_HEADER_TTYPE_MASK
Definition xaiefal-rscmgr-generic.hpp:16
XAIE_RSC_HEADER_MOD_MASK
#define XAIE_RSC_HEADER_MOD_MASK
Definition xaiefal-rscmgr-generic.hpp:18
XAIE_COMBO_PER_MOD
#define XAIE_COMBO_PER_MOD
Definition xaiefal-rscmgr-generic.hpp:12
XAIE_RSC_HEADER_SIZE_MASK
#define XAIE_RSC_HEADER_SIZE_MASK
Definition xaiefal-rscmgr-generic.hpp:22
XAIE_TRACE_PER_MOD
#define XAIE_TRACE_PER_MOD
Definition xaiefal-rscmgr-generic.hpp:11
XAIE_RSC_HEADER_SIZE_SHIFT
#define XAIE_RSC_HEADER_SIZE_SHIFT
Definition xaiefal-rscmgr-generic.hpp:21
Generated on for xaiefal by doxygen 1.15.0