xaiefal
Loading...
Searching...
No Matches
xaiefal-trace.hpp
Go to the documentation of this file.
1// Copyright(C) 2020 - 2021 by Xilinx, Inc. All rights reserved.
2// SPDX-License-Identifier: MIT
3
4#include <cerrno>
5#include <fstream>
6#include <functional>
7#include <string.h>
8#include <vector>
9#include <xaiengine.h>
10#include <bitset>
11
12#include <xaiefal/rsc/xaiefal-bc.hpp>
13#include <xaiefal/rsc/xaiefal-rsc-base.hpp>
14
15#pragma once
16
17namespace xaiefal {
22 class XAieTraceCntr: public XAieSingleTileRsc {
23 public:
24 XAieTraceCntr() = delete;
25 XAieTraceCntr(std::shared_ptr<XAieDevHandle> DevHd,
26 XAie_LocType Loc, XAie_ModuleType Mod):
27 XAieSingleTileRsc(DevHd, Loc, Mod, XAIE_TRACECTRL), Pkt() {
28 XAie_EventPhysicalToLogicalConv(dev(), Loc, Mod, 0,
29 &StartEvent);
30 StopEvent = StartEvent;
31 Mode = XAIE_TRACE_EVENT_TIME;
32 for(uint32_t i = 0;
33 i < sizeof(Events)/sizeof(Events[0]);
34 i++) {
35 Events[i] = StartEvent;
36 }
37 StartMod = Mod;
38 StopMod = Mod;
39 State.Initialized = 1;
40 }
44 ~XAieTraceCntr() {
45 if (State.Reserved == 1) {
46 if (StartMod != Mod) {
47 delete StartBC;
48 }
49 if (StopMod != Mod) {
50 delete StopBC;
51 }
52 }
53 }
54
60 XAie_ModuleType getModule() {
61 return Mod;
62 }
63
72 AieRC reserveTraceSlot(uint8_t &Slot) {
73 AieRC RC = XAIE_ERR;
74
75 if (State.Running == 1) {
76 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
77 "failed, tracing already started." << std::endl;
78 } else {
79 for (uint32_t i = 0; i < TraceSlotBits.size(); i++) {
80 if (TraceSlotBits.test(i) == 0) {
81 TraceSlotBits.set(i);
82 Slot = i;
83 RC = XAIE_OK;
84 break;
85 }
86 }
87 }
88 return RC;
89 }
90
96 AieRC releaseTraceSlot(uint8_t Slot) {
97 AieRC RC = XAIE_ERR;
98
99 if (State.Running == 1) {
100 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
101 "failed, tracing already started." << std::endl;
102 } else if (Slot >= static_cast<uint32_t>(TraceSlotBits.size())) {
103 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
104 "failed, invalid slot id " << Slot << "." << std::endl;
105 RC = XAIE_INVALID_ARGS;
106 } else {
107 XAie_Events E;
108
109 TraceSlotBits.reset(Slot);
110 XAie_EventPhysicalToLogicalConv(dev(), Loc, Mod, 0, &E);
111 Events[Slot] = E;
112 RC = XAIE_OK;
113 }
114 return RC;
115 }
116
128 AieRC setTraceEvent(uint32_t Slot, XAie_Events Event) {
129 AieRC RC;
130
131 Logger::log(LogLevel::FAL_DEBUG) << __func__ << " " <<
132 "(" << static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) << ") Mod=" << Mod <<
133 " Slot=" << Slot << " E=" << Event << " (" <<
134 XAie_EventGetString(Event) << ")" << std::endl;
135 if (State.Running == 1) {
136 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
137 "failed, trace started." << std::endl;
138 RC = XAIE_ERR;
139 } else if (Slot >= static_cast<uint32_t>(TraceSlotBits.size())) {
140 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
141 "failed, invalid slot." << std::endl;
142 RC = XAIE_INVALID_ARGS;
143 } else if ((TraceSlotBits.test(Slot) == 0)) {
144 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
145 "failed, trace slot is not reserved." << std::endl;
146 RC = XAIE_INVALID_ARGS;
147 } else {
148 if (Event == XAIE_EVENT_NONE_CORE) {
149 XAie_EventPhysicalToLogicalConv(dev(), Loc, Mod, 0, &Event);
150 }
151 Events[Slot] = Event;
152 RC = XAIE_OK;
153 }
154 changeToConfigured();
155 return RC;
156 }
157
168 AieRC setCntrEvent(XAie_Events StartE, XAie_Events StopE) {
169 XAie_ModuleType StartM, StopM;
170 AieRC RC;
171
172 Logger::log(LogLevel::FAL_DEBUG) << __func__ << " " <<
173 "(" << static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) << ") Mod=" << Mod <<
174 " StartE=" << StartE << " (" << XAie_EventGetString(StartE) << ")" <<
175 " StopE=" << StopE << " (" << XAie_EventGetString(StopE) << ")" << std::endl;
176 if (State.Running == 1) {
177 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
178 "failed, trace started." << std::endl;
179 RC = XAIE_ERR;
180 } else {
181 uint16_t HwE;
182
183 StartM = XAieEstimateModFromEvent(StartE);
184 StopM = XAieEstimateModFromEvent(StopE);
185 RC = XAie_EventLogicalToPhysicalConv(dev(), Loc,
186 StartM, StartE, &HwE);
187 if (RC == XAIE_OK) {
188 RC = XAie_EventLogicalToPhysicalConv(dev(), Loc,
189 StopM, StopE, &HwE);
190 }
191 if ((StartM != Mod || StopM != Mod) &&
192 State.Reserved == 1) {
193 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
194 "failed, trace reserved," <<
195 "but start/stop event not of the same module of trace control. " <<
196 "Please set control event before reserve() if they are of different mod" <<
197 std::endl;
198 RC = XAIE_ERR;
199 }
200 }
201 if (RC == XAIE_OK) {
202 StartEvent = StartE;
203 StopEvent = StopE;
204 StartMod = StartM;
205 StopMod = StopM;
206 changeToConfigured();
207 }
208 return RC;
209 }
210
219 AieRC setMode(XAie_TraceMode TraceMode) {
220 AieRC RC;
221
222 if (State.Running == 1) {
223 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
224 "failed, trace started." << std::endl;
225 RC = XAIE_ERR;
226 } else {
227 Mode = TraceMode;
228 changeToConfigured();
229 RC = XAIE_OK;
230 }
231 return RC;
232 }
233
242 AieRC setPkt(const XAie_Packet &Packet) {
243 AieRC RC;
244
245 if (State.Running == 1) {
246 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
247 "failed, trace started." << std::endl;
248 RC = XAIE_ERR;
249 } else {
250 Pkt = Packet;
251 changeToConfigured();
252 RC = XAIE_OK;
253 }
254 return RC;
255 }
256
262 uint32_t getMaxTraceEvents() const {
263 return 8;
264 }
265
271 uint32_t getReservedTraceEvents() const {
272 return TraceSlotBits.count();
273 }
274
281 int getStartBc() {
282 int BcId;
283
284 if (State.Reserved == 1) {
285 if (StartMod != Mod) {
286 BcId = StartBC->getBc();
287 } else {
288 BcId = -EINVAL;
289 }
290 } else {
291 Logger::log(LogLevel::FAL_ERROR) << "trace control " << __func__ << " (" <<
292 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
293 ") trace control Mod=" << Mod <<
294 " not reserved" << Mod << std::endl;
295 BcId = -EPERM;
296 }
297
298 return BcId;
299 }
300
307 int getStopBc() {
308 int BcId;
309
310 if (State.Reserved == 1) {
311 if (StopMod != Mod) {
312 BcId = StopBC->getBc();
313 } else {
314 BcId = -EINVAL;
315 }
316 } else {
317 Logger::log(LogLevel::FAL_ERROR) << "trace control " << __func__ << " (" <<
318 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
319 ") trace control Mod=" << Mod <<
320 " not reserved" << Mod << std::endl;
321 BcId = -EPERM;
322 }
323
324 return BcId;
325 }
326
327 uint32_t getAvailManagedRscs() {
328 return TraceSlotBits.size() - TraceSlotBits.count();
329 }
333 protected:
334 AieRC _reserve() {
335 AieRC RC;
336 XAieUserRsc Rsc;
337
338 Rsc.Loc = Loc;
339 Rsc.Mod = Mod;
340 Rsc.RscType = Type;
341 Rsc.RscId = 0U;
342 vRscs.push_back(Rsc);
343
344 RC = AieHd->rscMgr()->request(*this);
345 if (RC != XAIE_OK) {
346 Logger::log(LogLevel::FAL_ERROR) << "trace control " << __func__ << " (" <<
347 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
348 ") Mod=" << Mod <<" failed to reserve." << std::endl;
349 }
350 if (RC == XAIE_OK && StartMod != Mod) {
351 std::vector<XAie_LocType> vL;
352
353 vL.push_back(Loc);
354 StartBC = new XAieBroadcast(AieHd, vL,
355 StartMod, Mod);
356 RC = StartBC->reserve();
357 if (RC != XAIE_OK) {
358 delete StartBC;
359 }
360 }
361 if (RC == XAIE_OK && StopMod != Mod) {
362 std::vector<XAie_LocType> vL;
363
364 vL.push_back(Loc);
365 StopBC = new XAieBroadcast(AieHd, vL,
366 StartMod, Mod);
367 RC = StopBC->reserve();
368 if (RC != XAIE_OK) {
369 delete StopBC;
370 if (StartMod != Mod) {
371 StartBC->release();
372 delete StartBC;
373 }
374 }
375 }
376 if (RC != XAIE_OK) {
377 vRscs.clear();
378 } else {
379 reservedId = vRscs[0].RscId;
380 }
381 return RC;
382 }
383
384 AieRC _release() {
385 AieRC RC;
386
387 if (StartMod != Mod) {
388 StartBC->release();
389 delete StartBC;
390 }
391 if (StopMod != Mod) {
392 StopBC->release();
393 delete StopBC;
394 }
395
396 RC = AieHd->rscMgr()->release(*this);
397 if(RC != XAIE_OK) {
398 Logger::log(LogLevel::FAL_ERROR) << "trace control " << __func__ << " (" <<
399 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
400 ") Mod=" << Mod <<" failed to release." << std::endl;
401 }
402 vRscs.clear();
403 return RC;
404 }
405
406 AieRC _start() {
407 AieRC RC;
408 std::vector<XAie_Events> vE;
409 std::vector<u8> vSlot;
410 XAie_Events lStartE = StartEvent;
411 XAie_Events lStopE = StopEvent;
412
413 Logger::log(LogLevel::FAL_DEBUG) << "trace control " << __func__ << " (" <<
414 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) << ") Mod=" << Mod << std::endl;
415 for (uint32_t i = 0; i < TraceSlotBits.size(); i++) {
416 if (TraceSlotBits.test(i) != 0) {
417 vE.push_back(Events[i]);
418 vSlot.push_back((uint8_t)i);
419 }
420 }
421 RC = XAIE_OK;
422 if (StartMod != Mod) {
423 StartBC->getEvent(Loc, Mod, lStartE);
424 RC = XAie_EventBroadcast(dev(), Loc, StartMod,
425 StartBC->getBc(), StartEvent);
426 if (RC == XAIE_OK) {
427 RC = StartBC->start();
428 }
429 }
430 if (RC == XAIE_OK && StopMod != Mod) {
431 StopBC->getEvent(Loc, Mod, lStopE);
432 RC = XAie_EventBroadcast(dev(), Loc, StopMod,
433 StopBC->getBc(), StopEvent);
434 if (RC == XAIE_OK) {
435 RC = StopBC->start();
436 }
437 }
438 if (RC == XAIE_OK) {
439 RC = XAie_TraceEventList(dev(), Loc, Mod,
440 vE.data(), vSlot.data(),
441 vE.size());
442 }
443 if (RC == XAIE_OK) {
444 RC = XAie_TracePktConfig(dev(), Loc, Mod, Pkt);
445 if (RC == XAIE_OK) {
446 RC = XAie_TraceControlConfig(dev(),
447 Loc, Mod, lStartE, lStopE,
448 Mode);
449 }
450 }
451 return RC;
452 }
453
454 AieRC _stop() {
455 AieRC RC;
456
457 Logger::log(LogLevel::FAL_DEBUG) << "trace control " << __func__ << " (" <<
458 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) << ") Mod=" << Mod << std::endl;
459 // Do not reset the packet setting as it can
460 // cause issues on outstanding contents in
461 // the trace buffer.
462 // Reset the start, stop, and the trace events only.
463 RC = XAie_TraceControlConfigReset(dev(), Loc, Mod);
464 if (RC == XAIE_OK) {
465 for (uint8_t s = 0;
466 s < (TraceSlotBits.size());
467 s++) {
468 if (TraceSlotBits.test(s) != 0) {
469 XAie_TraceEventReset(dev(), Loc,
470 Mod, s);
471 }
472 }
473 }
474 if (RC == XAIE_OK && StartMod != Mod) {
475 StartBC->getEvent(Loc, Mod, StartEvent);
476 RC = XAie_EventBroadcastReset(dev(), Loc,
477 StartMod, StartBC->getBc());
478 if (RC == XAIE_OK) {
479 RC = StartBC->stop();
480 }
481 }
482 if (StopMod != Mod) {
483 StopBC->getEvent(Loc, Mod, StopEvent);
484 RC = XAie_EventBroadcastReset(dev(), Loc,
485 StopMod, StopBC->getBc());
486 if (RC == XAIE_OK) {
487 RC = StopBC->stop();
488 }
489 }
490 return RC;
491 }
492
493 void _getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
494 vOutRscs.push_back(vRscs[0]);
495 if (StartMod != Mod) {
496 StartBC->getReservedRscs(vOutRscs);
497 }
498 if (StopMod != Mod) {
499 StopBC->getReservedRscs(vOutRscs);
500 }
501 }
502
503 std::bitset<8> TraceSlotBits;
504 XAie_Events Events[8];
505 XAie_Events StartEvent;
506 XAie_Events StopEvent;
507 XAie_ModuleType StartMod;
508 XAie_ModuleType StopMod;
509 XAieBroadcast *StartBC;
510 XAieBroadcast *StopBC;
511 XAie_Packet Pkt;
512 XAie_TraceMode Mode;
513 private:
514 void changeToConfigured() {
515 if (State.Configured == 0 &&
516 StartEvent != XAIE_EVENT_NONE_CORE &&
517 TraceSlotBits != 0) {
518 std::bitset<8> bits(TraceSlotBits);
519 for (uint32_t i = 0; i < TraceSlotBits.size(); i++) {
520 XAie_Events E;
521
522 if (bits.test(i) == 0) {
523 continue;
524 }
525 XAie_EventPhysicalToLogicalConv(dev(), Loc, Mod, 0, &E);
526 if (Events[i] != E) {
527 State.Configured = 1;
528 break;
529 }
530 }
531 }
532 }
533 };
534
540 class XAieTraceEvent: public XAieSingleTileRsc {
541 public:
542 XAieTraceEvent() = delete;
543 XAieTraceEvent(std::shared_ptr<XAieDevHandle> DevHd,
544 XAie_LocType Loc, XAie_ModuleType Mod,
545 std::shared_ptr<XAieTraceCntr> TCntr):
546 XAieSingleTileRsc(DevHd, Loc, Mod, XAIE_TRACEEVENT),
547 EventMod(Mod) {
548 if (!TCntr) {
549 throw std::invalid_argument("Trace event failed, empty trace control");
550 }
551 if (TCntr->dev() != DevHd->dev() ||
552 TCntr->getModule() != Mod) {
553 throw std::invalid_argument("Trace event failed,trace control aiedev or module mismatched");
554 }
555 TraceCntr = std::move(TCntr);
556 State.Initialized = 1;
557 vRscs.resize(1);
558 }
559 XAieTraceEvent(XAieDev &Dev,
560 XAie_LocType Loc, XAie_ModuleType Mod):
561 XAieSingleTileRsc(Dev, Loc, Mod, XAIE_TRACEEVENT),
562 EventMod(Mod) {
563 TraceCntr = Dev.tile(Loc).module(Mod).traceControl();
564 State.Initialized = 1;
565 }
566 ~XAieTraceEvent() {}
574 AieRC setEvent(XAie_ModuleType Module, XAie_Events TraceEvent) {
575 AieRC RC;
576 uint16_t HwEvent;
577
578 RC = XAie_EventLogicalToPhysicalConv(dev(), Loc,
579 Module, TraceEvent, &HwEvent);
580 if (RC != XAIE_OK) {
581 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
582 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
583 ") Event Mod=" << Module << " Event=" << TraceEvent <<
584 " (" << XAie_EventGetString(TraceEvent) << ")" <<
585 " invalid event" << std::endl;
586 RC = XAIE_INVALID_ARGS;
587 } else if (State.Running == 1) {
588 RC = XAIE_ERR;
589 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
590 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
591 ") Event Mod=" << Module << " Event=" << TraceEvent <<
592 " (" << XAie_EventGetString(TraceEvent) << ")" <<
593 " trace event already in used" << std::endl;
594 } else if (State.Reserved == 1 && Module != EventMod) {
595 RC = XAIE_INVALID_ARGS;
596 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
597 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
598 ") Event Mod=" << Module << " Event=" << TraceEvent <<
599 " (" << XAie_EventGetString(TraceEvent) << ")" <<
600 " trace event already reserved, input event module is different to the one already set" << std::endl;
601 } else {
602 Event = TraceEvent;
603 EventMod = Module;
604 State.Configured = 1;
605 }
606 return RC;
607 }
608
616 AieRC getEvent(XAie_ModuleType &Module, XAie_Events &TraceEvent) const {
617 AieRC RC;
618
619 if (State.Configured == 0) {
620 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
621 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
622 ") trace control Mod=" << TraceCntr->getModule() <<
623 " Event Mod=" << Mod << " no event specified" << std::endl;
624 RC = XAIE_ERR;
625 } else {
626 TraceEvent = Event;
627 Module = EventMod;
628 RC = XAIE_OK;
629 }
630 return RC;
631 }
632
639 int getBc() {
640 int BcId;
641
642 if (State.Reserved == 1) {
643 if (EventMod != TraceCntr->getModule()) {
644 BcId = BC->getBc();
645 } else {
646 BcId = -EINVAL;
647 }
648 } else {
649 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
650 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
651 ") trace control Mod=" << TraceCntr->getModule() <<
652 " Event Mod=" << EventMod <<
653 " resource not reserved." << std::endl;
654 BcId = -EPERM;
655 }
656
657 return BcId;
658 }
659 protected:
660 AieRC _reserve() {
661 AieRC RC;
662
663 Logger::log(LogLevel::FAL_DEBUG) << "trace event " << __func__ << " (" <<
664 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
665 ") trace control Mod=" << TraceCntr->getModule() <<
666 " Event Mod=" << Mod << std::endl;
667 RC = TraceCntr->reserveTraceSlot(Slot);
668 if (RC != XAIE_OK) {
669 Logger::log(LogLevel::FAL_WARN) << "trace event " << __func__ << " (" <<
670 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
671 ") trace control Mod=" << TraceCntr->getModule() <<
672 " Event Mod=" << Mod << " no trace slot" << std::endl;
673 } else if (EventMod != TraceCntr->getModule()) {
674 std::vector<XAie_LocType> vL;
675
676 vL.push_back(Loc);
677 BC = std::make_shared<XAieBroadcast>(AieHd, vL,
678 XAIE_CORE_MOD, XAIE_MEM_MOD);
679 RC = BC->reserve();
680 if (RC != XAIE_OK) {
681 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
682 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
683 ") trace control Mod=" << TraceCntr->getModule() <<
684 " Event Mod=" << Mod << " no broadcast event" << std::endl;
685 TraceCntr->releaseTraceSlot(Slot);
686 } else {
687 vRscs[0].Mod = Mod;
688 vRscs[0].RscId = Slot;
689 }
690 } else {
691 vRscs[0].Mod = Mod;
692 vRscs[0].RscId = Slot;
693 }
694
695 reservedId = vRscs[0].RscId;
696 return RC;
697 }
698 AieRC _release() {
699 Logger::log(LogLevel::FAL_DEBUG) << "trace event " << __func__ << " (" <<
700 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
701 ") trace control Mod=" << TraceCntr->getModule() <<
702 " Event Mod=" << Mod << "Event=" << Event <<
703 " (" << XAie_EventGetString(Event) << ")" << std::endl;
704 TraceCntr->releaseTraceSlot(Slot);
705 if (EventMod != TraceCntr->getModule()) {
706 BC->release();
707 }
708 return XAIE_OK;
709 }
710 AieRC _start() {
711 AieRC RC;
712
713 Logger::log(LogLevel::FAL_DEBUG) << "trace event " << __func__ << " (" <<
714 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
715 ") trace control Mod=" << TraceCntr->getModule() <<
716 " Event Mod=" << EventMod << "Event=" << Event <<
717 " (" << XAie_EventGetString(Event) << ")" << std::endl;
718 if (EventMod != TraceCntr->getModule()) {
719 RC = XAie_EventBroadcast(dev(), Loc, EventMod,
720 BC->getBc(), Event);
721 if (RC == XAIE_OK) {
722 XAie_Events BcE;
723
724 BC->getEvent(Loc,
725 TraceCntr->getModule(), BcE);
726 RC = BC->start();
727 if (RC == XAIE_OK) {
728 RC = TraceCntr->setTraceEvent(Slot, BcE);
729 } else {
730 Logger::log(LogLevel::FAL_ERROR) << "trace event " << __func__ << " (" <<
731 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
732 ") trace control Mod=" << TraceCntr->getModule() <<
733 " Event Mod=" << EventMod << "Event=" << Event <<
734 " (" << XAie_EventGetString(Event) << ")" <<
735 " failed." << std::endl;
736 }
737 }
738 } else {
739 RC = TraceCntr->setTraceEvent(Slot, Event);
740 }
741 return RC;
742 }
743 AieRC _stop() {
744 AieRC RC, lRC;
745 XAie_Events E;
746
747 Logger::log(LogLevel::FAL_DEBUG) << "trace event " << __func__ << " (" <<
748 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) <<
749 ") trace control Mod=" << TraceCntr->getModule() <<
750 " Event Mod=" << Mod << "Event=" << Event <<
751 " (" << XAie_EventGetString(Event) << ")" << std::endl;
752 RC = XAIE_OK;
753 XAie_EventPhysicalToLogicalConv(dev(), Loc,
754 TraceCntr->getModule(), 0, &E);
755 lRC = TraceCntr->setTraceEvent(Slot, E);
756 if (lRC != XAIE_OK) {
757 RC = lRC;
758 }
759 if (EventMod != TraceCntr->getModule()) {
760 lRC = BC->stop();
761 if (lRC != XAIE_OK) {
762 RC = lRC;
763 }
764 }
765 return RC;
766 }
767
768 void _getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
769 XAieUserRsc Rsc;
770
771 Rsc.Loc.Col = Loc.Col;
772 Rsc.Loc.Row = Loc.Row;
773 Rsc.Mod = TraceCntr->getModule();
774 Rsc.RscType = XAIE_TRACEEVENT;
775 Rsc.RscId = Slot;
776 vOutRscs.push_back(Rsc);
777
778 if (EventMod != TraceCntr->getModule()) {
779 BC->getReservedRscs(vOutRscs);
780 }
781 }
782 protected:
783 std::shared_ptr<XAieTraceCntr> TraceCntr;
784 XAie_Events Event;
785 XAie_ModuleType EventMod;
786 std::shared_ptr<XAieBroadcast> BC;
787 uint8_t Slot;
788 };
789
795 class XAieTracing: public XAieSingleTileRsc {
796 public:
797 XAieTracing() = delete;
798 XAieTracing(std::shared_ptr<XAieDevHandle> DevHd,
799 XAie_LocType Loc, XAie_ModuleType Mod, std::shared_ptr<XAieTraceCntr> TCntr):
800 XAieSingleTileRsc(DevHd, Loc, Mod) {
801 if (!TCntr) {
802 throw std::invalid_argument("Trace event failed, empty trace control");
803 }
804 if (TCntr->dev() != DevHd->dev() ||
805 TCntr->getModule() != Mod) {
806 throw std::invalid_argument("Trace event failed,trace control aiedev or module mismatched");
807 }
808 TraceCntr = std::move(TCntr);
809 State.Initialized = 1;
810 }
811 XAieTracing(XAieDev &Dev, XAie_LocType Loc,
812 XAie_ModuleType Mod):
813 XAieSingleTileRsc(Dev, Loc, Mod) {
814 TraceCntr = Dev.tile(Loc).module(Mod).traceControl();
815 State.Initialized = 1;
816 }
817 ~XAieTracing() {
818 Events.clear();
819 }
820
830 AieRC addEvent(XAie_ModuleType Module, XAie_Events TraceEvent) {
831 AieRC RC;
832
833 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
834 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
835 ") Mod=" << static_cast<uint32_t>(Module) << " E=" << TraceEvent << std::endl;
836 if (Events.size() == TraceCntr->getMaxTraceEvents()) {
837 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
838 "failed for tracing, exceeded max num of events." << std::endl;
839 RC = XAIE_ERR;
840 } else if (State.Running == 1) {
841 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
842 "failed for tracing, resource reserved." << std::endl;
843 RC = XAIE_ERR;
844 } else {
845 XAieTraceEvent TraceE(AieHd, Loc, Mod, TraceCntr);
846
847 RC = TraceE.setEvent(Module, TraceEvent);
848 if (RC != XAIE_OK) {
849 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
850 "failed for tracing, failed to initialize event." << std::endl;
851 } else if (State.Reserved == 1) {
852 RC = TraceE.reserve();
853 if (RC != XAIE_OK) {
854 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
855 "failed for tracing, reserved new event failed." << std::endl;
856 } else {
857 RC = TraceE.start();
858 if (RC != XAIE_OK) {
859 TraceE.release();
860 }
861 }
862 }
863 if (RC == XAIE_OK) {
864 Events.push_back(TraceE);
865 changeToConfigured();
866 }
867 }
868 return RC;
869 }
870
878 AieRC removeEvent(XAie_ModuleType Module, XAie_Events TraceEvent) {
879 AieRC RC;
880
881 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
882 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
883 ") Mod=" << static_cast<uint32_t>(Module) << " E=" << TraceEvent <<
884 " (" << XAie_EventGetString(TraceEvent) << ")" << std::endl;
885 if (State.Running == 1) {
886 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
887 "failed for tracing, resource reserved." << std::endl;
888 RC = XAIE_ERR;
889 } else {
890 RC = XAIE_INVALID_ARGS;
891 for (uint32_t i = 0; i < Events.size(); i++) {
892 XAie_Events lE;
893 XAie_ModuleType lM;
894
895 Events[i].getEvent(lM, lE);
896 if (lM == Module && TraceEvent == lE) {
897 Events.erase(Events.begin() + i);
898 RC = XAIE_OK;
899 break;
900 }
901 }
902 if (RC != XAIE_OK) {
903 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
904 "failed for tracing, event doesn't exist." << std::endl;
905 } else {
906 changeToConfigured();
907 }
908 }
909 return RC;
910 }
911
922 AieRC setCntrEvent(XAie_Events StartE, XAie_Events StopE) {
923 AieRC RC;
924
925 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
926 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
927 ") Mod=" << static_cast<uint32_t>(TraceCntr->getModule()) <<
928 " StartE=" << StartE << " (" << XAie_EventGetString(StartE) << ")" <<
929 " StopE=" << StopE << " (" << XAie_EventGetString(StopE) << ")" <<
930 std::endl;
931 RC = TraceCntr->setCntrEvent(StartE, StopE);
932 if (RC == XAIE_OK) {
933 changeToConfigured();
934 }
935 return RC;
936 }
937
946 AieRC setMode(XAie_TraceMode TraceMode) {
947 AieRC RC;
948
949 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
950 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
951 ") Mode=" << TraceMode << std::endl;
952 RC = TraceCntr->setMode(TraceMode);
953 if (RC == XAIE_OK) {
954 changeToConfigured();
955 }
956 return RC;
957 }
958
967 AieRC setPkt(const XAie_Packet &Packet) {
968 AieRC RC;
969
970 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
971 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
972 ") Mod=" << static_cast<uint32_t>(TraceCntr->getModule()) << std::endl;
973 RC = TraceCntr->setPkt(Packet);
974 if (RC == XAIE_OK) {
975 changeToConfigured();
976 }
977 return RC;
978 }
979
985 uint32_t getTraceControlAvailTraceSlots() const {
986 uint32_t MaxEvents, NumReserved;
987
988 MaxEvents = getMaxTraceEvents();
989 NumReserved = TraceCntr->getReservedTraceEvents();
990 return (MaxEvents - NumReserved);
991 }
992
998 uint32_t getMaxTraceEvents() const {
999 return TraceCntr->getMaxTraceEvents();
1000 }
1001 protected:
1002 AieRC _reserve() {
1003 AieRC RC = XAIE_OK;
1004
1005 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
1006 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
1007 ") Mod=" << static_cast<uint32_t>(TraceCntr->getModule()) << std::endl;
1008 if (RC == XAIE_OK && !(TraceCntr->isReserved())) {
1009 RC = TraceCntr->reserve();
1010 }
1011 for (uint32_t i = 0; i < Events.size(); i++) {
1012 RC = Events[i].reserve();
1013 if (RC != XAIE_OK) {
1014 break;
1015 }
1016 }
1017 if (RC != XAIE_OK) {
1018 for (uint32_t i = 0; i < Events.size(); i++) {
1019 Events[i].release();
1020 }
1021 } else {
1022 // After reserved tracing events, configure
1023 // them so that the trace control state can
1024 // change to configured.
1025 for (uint32_t i = 0; i < Events.size(); i++) {
1026 Events[i].start();
1027 }
1028 changeToConfigured();
1029 }
1030 return RC;
1031 }
1032 AieRC _release() {
1033 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " ("
1034 << static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) <<
1035 ") Mod=" << static_cast<uint32_t>(TraceCntr->getModule()) << std::endl;
1036 TraceCntr->release();
1037 for (uint32_t i = 0; i < Events.size(); i++) {
1038 Events[i].release();
1039 }
1040 return XAIE_OK;
1041 }
1042 AieRC _start() {
1043 AieRC RC = XAIE_OK;
1044
1045 Logger::log(LogLevel::FAL_DEBUG) << "tracing " << __func__ << " (" <<
1046 static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) << ")" <<
1047 " Mod=" << TraceCntr->getModule() << ", " << Events.size() << " events to trace." << std::endl;
1048 for (uint32_t i = 0; i < Events.size(); i++) {
1049 RC = Events[i].start();
1050 if (RC != XAIE_OK) {
1051 break;
1052 }
1053 }
1054 if (RC == XAIE_OK) {
1055 RC = TraceCntr->start();
1056 }
1057 if (RC != XAIE_OK) {
1058 for (uint32_t i = 0; i < Events.size(); i++) {
1059 Events[i].stop();
1060 }
1061 }
1062 return RC;
1063 }
1064 AieRC _stop() {
1065 Logger::log(LogLevel::FAL_DEBUG) << "tracing "<< __func__ << " (" <<
1066 static_cast<uint32_t>(TraceCntr->loc().Col) << "," << static_cast<uint32_t>(TraceCntr->loc().Row) << ")" <<
1067 " Mod=" << TraceCntr->getModule() << ", " << Events.size() << " events to trace." << std::endl;
1068 TraceCntr->stop();
1069 for (uint32_t i = 0; i < Events.size(); i++) {
1070 Events[i].stop();
1071 }
1072 return XAIE_OK;
1073 }
1074 std::shared_ptr<XAieTraceCntr> TraceCntr;
1075 std::vector<XAieTraceEvent> Events;
1076 private:
1077 void changeToConfigured() {
1078 if (State.Configured == 0) {
1079 if (TraceCntr->isConfigured()) {
1080 if (Events.size() > 0) {
1081 State.Configured = 1;
1082 }
1083 }
1084 }
1085 }
1086 };
1087}
xaiefal::Logger::log
static std::ostream & log(LogLevel Lvl=LogLevel::FAL_MAX)
Definition xaiefal-log.hpp:50
xaiefal::XAieBroadcast
class for broadcast channel resource. A broadcast channel resource represents a broadcast channel bet...
Definition xaiefal-bc.hpp:29
xaiefal::XAieDev
AI engine device class. It defines AI engine device operations.
Definition xaiefal-base.hpp:259
xaiefal::XAieDev::tile
XAieTile & tile(XAie_LocType Loc)
Definition xaiefal-base.hpp:272
xaiefal::XAieRsc::Type
XAieRscType Type
Definition xaiefal-rsc-base.hpp:399
xaiefal::XAieRsc::vRscs
std::vector< XAieUserRsc > vRscs
Definition xaiefal-rsc-base.hpp:403
xaiefal::XAieRsc::State
XAieRscState State
Definition xaiefal-rsc-base.hpp:398
xaiefal::XAieRsc::dev
XAie_DevInst * dev()
Definition xaiefal-rsc-base.hpp:373
xaiefal::XAieRsc::release
AieRC release()
Definition xaiefal-rsc-base.hpp:188
xaiefal::XAieRsc::reserve
AieRC reserve()
Definition xaiefal-rsc-base.hpp:161
xaiefal::XAieRsc::start
AieRC start()
Definition xaiefal-rsc-base.hpp:239
xaiefal::XAieRsc::reservedId
uint32_t reservedId
Definition xaiefal-rsc-base.hpp:402
xaiefal::XAieRsc::AieHd
std::shared_ptr< XAieDevHandle > AieHd
Definition xaiefal-rsc-base.hpp:400
xaiefal::XAieSingleTileRsc::Loc
XAie_LocType Loc
Definition xaiefal-rsc-base.hpp:594
xaiefal::XAieSingleTileRsc::Mod
XAie_ModuleType Mod
Definition xaiefal-rsc-base.hpp:595
xaiefal::XAieTraceCntr::setCntrEvent
AieRC setCntrEvent(XAie_Events StartE, XAie_Events StopE)
Definition xaiefal-trace.hpp:168
xaiefal::XAieTraceCntr::setMode
AieRC setMode(XAie_TraceMode TraceMode)
Definition xaiefal-trace.hpp:219
xaiefal::XAieTraceCntr::_getReservedRscs
void _getReservedRscs(std::vector< XAieUserRsc > &vOutRscs) const
Definition xaiefal-trace.hpp:493
xaiefal::XAieTraceCntr::_stop
AieRC _stop()
Definition xaiefal-trace.hpp:454
xaiefal::XAieTraceCntr::Mode
XAie_TraceMode Mode
Definition xaiefal-trace.hpp:512
xaiefal::XAieTraceCntr::getMaxTraceEvents
uint32_t getMaxTraceEvents() const
Definition xaiefal-trace.hpp:262
xaiefal::XAieTraceCntr::StartBC
XAieBroadcast * StartBC
Definition xaiefal-trace.hpp:509
xaiefal::XAieTraceCntr::Events
XAie_Events Events[8]
Definition xaiefal-trace.hpp:504
xaiefal::XAieTraceCntr::TraceSlotBits
std::bitset< 8 > TraceSlotBits
Definition xaiefal-trace.hpp:503
xaiefal::XAieTraceCntr::~XAieTraceCntr
~XAieTraceCntr()
Definition xaiefal-trace.hpp:44
xaiefal::XAieTraceCntr::_start
AieRC _start()
Definition xaiefal-trace.hpp:406
xaiefal::XAieTraceCntr::getReservedTraceEvents
uint32_t getReservedTraceEvents() const
Definition xaiefal-trace.hpp:271
xaiefal::XAieTraceCntr::XAieTraceCntr
XAieTraceCntr(XAieDev &Dev, XAie_LocType Loc, XAie_ModuleType Mod)
Definition xaiefal-trace.hpp:41
xaiefal::XAieTraceCntr::reserveTraceSlot
AieRC reserveTraceSlot(uint8_t &Slot)
Definition xaiefal-trace.hpp:72
xaiefal::XAieTraceCntr::getStartBc
int getStartBc()
Definition xaiefal-trace.hpp:281
xaiefal::XAieTraceCntr::StopBC
XAieBroadcast * StopBC
Definition xaiefal-trace.hpp:510
xaiefal::XAieTraceCntr::getStopBc
int getStopBc()
Definition xaiefal-trace.hpp:307
xaiefal::XAieTraceCntr::getManagedRscsType
XAieRscType getManagedRscsType()
Definition xaiefal-trace.hpp:330
xaiefal::XAieTraceCntr::StartEvent
XAie_Events StartEvent
Definition xaiefal-trace.hpp:505
xaiefal::XAieTraceCntr::setTraceEvent
AieRC setTraceEvent(uint32_t Slot, XAie_Events Event)
Definition xaiefal-trace.hpp:128
xaiefal::XAieTraceCntr::getModule
XAie_ModuleType getModule()
Definition xaiefal-trace.hpp:60
xaiefal::XAieTraceCntr::_reserve
AieRC _reserve()
Definition xaiefal-trace.hpp:334
xaiefal::XAieTraceCntr::_release
AieRC _release()
Definition xaiefal-trace.hpp:384
xaiefal::XAieTraceCntr::releaseTraceSlot
AieRC releaseTraceSlot(uint8_t Slot)
Definition xaiefal-trace.hpp:96
xaiefal::XAieTraceCntr::Pkt
XAie_Packet Pkt
Definition xaiefal-trace.hpp:511
xaiefal::XAieTraceCntr::setPkt
AieRC setPkt(const XAie_Packet &Packet)
Definition xaiefal-trace.hpp:242
xaiefal::XAieTraceCntr::StopMod
XAie_ModuleType StopMod
Definition xaiefal-trace.hpp:508
xaiefal::XAieTraceCntr::XAieTraceCntr
XAieTraceCntr(std::shared_ptr< XAieDevHandle > DevHd, XAie_LocType Loc, XAie_ModuleType Mod)
Definition xaiefal-trace.hpp:25
xaiefal::XAieTraceCntr::StopEvent
XAie_Events StopEvent
Definition xaiefal-trace.hpp:506
xaiefal::XAieTraceCntr::getAvailManagedRscs
uint32_t getAvailManagedRscs()
Definition xaiefal-trace.hpp:327
xaiefal::XAieTraceCntr::StartMod
XAie_ModuleType StartMod
Definition xaiefal-trace.hpp:507
xaiefal::XAieTraceEvent
Trace event resource class. Each event to trace is presented as a trace event resource class.
Definition xaiefal-trace.hpp:540
xaiefal::XAieTraceEvent::_start
AieRC _start()
Definition xaiefal-trace.hpp:710
xaiefal::XAieTraceEvent::~XAieTraceEvent
~XAieTraceEvent()
Definition xaiefal-trace.hpp:566
xaiefal::XAieTraceEvent::getBc
int getBc()
Definition xaiefal-trace.hpp:639
xaiefal::XAieTraceEvent::_getReservedRscs
void _getReservedRscs(std::vector< XAieUserRsc > &vOutRscs) const
Definition xaiefal-trace.hpp:768
xaiefal::XAieTraceEvent::Slot
uint8_t Slot
Definition xaiefal-trace.hpp:787
xaiefal::XAieTraceEvent::EventMod
XAie_ModuleType EventMod
Definition xaiefal-trace.hpp:785
xaiefal::XAieTraceEvent::BC
std::shared_ptr< XAieBroadcast > BC
Definition xaiefal-trace.hpp:786
xaiefal::XAieTraceEvent::getEvent
AieRC getEvent(XAie_ModuleType &Module, XAie_Events &TraceEvent) const
Definition xaiefal-trace.hpp:616
xaiefal::XAieTraceEvent::_release
AieRC _release()
Definition xaiefal-trace.hpp:698
xaiefal::XAieTraceEvent::XAieTraceEvent
XAieTraceEvent(std::shared_ptr< XAieDevHandle > DevHd, XAie_LocType Loc, XAie_ModuleType Mod, std::shared_ptr< XAieTraceCntr > TCntr)
Definition xaiefal-trace.hpp:543
xaiefal::XAieTraceEvent::XAieTraceEvent
XAieTraceEvent(XAieDev &Dev, XAie_LocType Loc, XAie_ModuleType Mod)
Definition xaiefal-trace.hpp:559
xaiefal::XAieTraceEvent::TraceCntr
std::shared_ptr< XAieTraceCntr > TraceCntr
Definition xaiefal-trace.hpp:783
xaiefal::XAieTraceEvent::Event
XAie_Events Event
Definition xaiefal-trace.hpp:784
xaiefal::XAieTraceEvent::_reserve
AieRC _reserve()
Definition xaiefal-trace.hpp:660
xaiefal::XAieTraceEvent::_stop
AieRC _stop()
Definition xaiefal-trace.hpp:743
xaiefal::XAieTraceEvent::setEvent
AieRC setEvent(XAie_ModuleType Module, XAie_Events TraceEvent)
Definition xaiefal-trace.hpp:574
xaiefal::XAieTracing::TraceCntr
std::shared_ptr< XAieTraceCntr > TraceCntr
Definition xaiefal-trace.hpp:1074
xaiefal::XAieTracing::Events
std::vector< XAieTraceEvent > Events
Definition xaiefal-trace.hpp:1075
xaiefal::XAieTracing::_start
AieRC _start()
Definition xaiefal-trace.hpp:1042
xaiefal::XAieTracing::~XAieTracing
~XAieTracing()
Definition xaiefal-trace.hpp:817
xaiefal::XAieTracing::setMode
AieRC setMode(XAie_TraceMode TraceMode)
Definition xaiefal-trace.hpp:946
xaiefal::XAieTracing::XAieTracing
XAieTracing(std::shared_ptr< XAieDevHandle > DevHd, XAie_LocType Loc, XAie_ModuleType Mod, std::shared_ptr< XAieTraceCntr > TCntr)
Definition xaiefal-trace.hpp:798
xaiefal::XAieTracing::getMaxTraceEvents
uint32_t getMaxTraceEvents() const
Definition xaiefal-trace.hpp:998
xaiefal::XAieTracing::setPkt
AieRC setPkt(const XAie_Packet &Packet)
Definition xaiefal-trace.hpp:967
xaiefal::XAieTracing::_reserve
AieRC _reserve()
Definition xaiefal-trace.hpp:1002
xaiefal::XAieTracing::XAieTracing
XAieTracing(XAieDev &Dev, XAie_LocType Loc, XAie_ModuleType Mod)
Definition xaiefal-trace.hpp:811
xaiefal::XAieTracing::removeEvent
AieRC removeEvent(XAie_ModuleType Module, XAie_Events TraceEvent)
Definition xaiefal-trace.hpp:878
xaiefal::XAieTracing::_release
AieRC _release()
Definition xaiefal-trace.hpp:1032
xaiefal::XAieTracing::getTraceControlAvailTraceSlots
uint32_t getTraceControlAvailTraceSlots() const
Definition xaiefal-trace.hpp:985
xaiefal::XAieTracing::setCntrEvent
AieRC setCntrEvent(XAie_Events StartE, XAie_Events StopE)
Definition xaiefal-trace.hpp:922
xaiefal::XAieTracing::addEvent
AieRC addEvent(XAie_ModuleType Module, XAie_Events TraceEvent)
Definition xaiefal-trace.hpp:830
xaiefal::XAieTracing::_stop
AieRC _stop()
Definition xaiefal-trace.hpp:1064
XAie_ModuleType
xaiefal
Definition xaiefal-base.hpp:23
xaiefal::XAieRscType
XAieRscType
Enums representing all requestable resources.
Definition xaiefal-rsc-group.hpp:27
xaiefal::XAIE_TRACEEVENT
@ XAIE_TRACEEVENT
Definition xaiefal-rsc-group.hpp:38
xaiefal::XAIE_TRACECTRL
@ XAIE_TRACECTRL
Definition xaiefal-rsc-group.hpp:30
xaiefal::XAieEstimateModFromEvent
static XAie_ModuleType XAieEstimateModFromEvent(XAie_Events Event)
Definition xaiefal-base.hpp:1098
xaiefal::LogLevel::FAL_DEBUG
@ FAL_DEBUG
Definition xaiefal-log.hpp:11
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
Generated on for xaiefal by doxygen 1.15.0