xaiefal
Loading...
Searching...
No Matches
xaiefal-bc.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 <fstream>
5#include <functional>
6#include <string.h>
7#include <vector>
8#include <xaiengine.h>
9
10#include <xaiefal/rsc/xaiefal-rsc-base.hpp>
11
12#pragma once
13
14namespace xaiefal {
29 class XAieBroadcast: public XAieRsc {
30 public:
31 XAieBroadcast() = delete;
32 XAieBroadcast(std::shared_ptr<XAieDevHandle> DevHd,
33 const std::vector<XAie_LocType> &vInLocs,
34 XAie_ModuleType StartM, XAie_ModuleType EndM):
35 XAieRsc(DevHd, XAIE_BROADCAST) {
36 StartMod = StartM;
37 EndMod = EndM;
38 vLocs = vInLocs;
39
40 State.Initialized = 1;
41 State.Configured = 1;
42 }
43 XAieBroadcast(XAieDev &Dev,
44 const std::vector<XAie_LocType> &vInLocs,
45 XAie_ModuleType StartM, XAie_ModuleType EndM):
46 XAieBroadcast(Dev.getDevHandle(), vInLocs, StartM, EndM) {}
47 ~XAieBroadcast() {}
53 int getBc() {
54 int BC = XAIE_RSC_ID_ANY;
55
56 if (State.Reserved == 1) {
57 BC = vRscs[0].RscId;
58 }
59 return BC;
60 }
61
70 AieRC getEvent(XAie_LocType Loc, XAie_ModuleType Mod,
71 XAie_Events &Event) {
72 AieRC RC = XAIE_INVALID_ARGS;
73
74 if (State.Reserved == 0) {
75 Logger::log(LogLevel::FAL_ERROR) << "broadcast object " << __func__ << " (" <<
76 static_cast<uint32_t>(Loc.Col) << "," << static_cast<uint32_t>(Loc.Row) << ")" <<
77 " Mod= " << Mod <<
78 " resource not reserved." << std::endl;
79 RC = XAIE_ERR;
80 } else {
81 uint8_t TileType = XAie_GetTileTypefromLoc(AieHd->dev(), Loc);
82 for (int i = 0; i < (int)vLocs.size(); i++) {
83 if (Loc.Col == vLocs[i].Col && Loc.Row == vLocs[i].Row) {
84 RC = XAIE_OK;
85 if (TileType == XAIEGBL_TILE_TYPE_AIETILE) {
86 if (Mod == XAIE_MEM_MOD) {
87 Event = XAIE_EVENT_BROADCAST_0_MEM;
88 } else {
89 Event = XAIE_EVENT_BROADCAST_0_CORE;
90 }
91 } else if (TileType == XAIEGBL_TILE_TYPE_MEMTILE) {
92 Event = XAIE_EVENT_BROADCAST_0_MEM_TILE;
93 } else {
94 Event = XAIE_EVENT_BROADCAST_A_0_PL;
95 }
96 Event = static_cast<XAie_Events>(static_cast<uint32_t>(Event) +
97 vRscs[0].RscId);
98 break;
99 }
100 }
101 }
102 return RC;
103 }
104
112 AieRC getChannel(std::vector<XAie_LocType> &vL,
113 XAie_ModuleType &StartM,
114 XAie_ModuleType &EndM) {
115 vL = vLocs;
116 StartM = StartMod;
117 EndM = EndMod;
118
119 return XAIE_OK;
120 }
121 XAieRscStat getRscStat(const std::string &GName) const {
122 XAieRscStat RscStat(GName);
123 (void) GName;
124
125 if (preferredId == XAIE_RSC_ID_ANY) {
126 return AieHd->getRscGroup(GName).getRscStat(vLocs,
127 getRscType());
128 } else {
129 return AieHd->getRscGroup(GName).getRscStat(vLocs,
130 getRscType(), preferredId);
131 }
132 }
133 private:
134 AieRC _reserve() {
135 AieRC RC = XAIE_OK;
136
137 if (vLocs.size() != 0) {
138 RC = setRscs(AieHd, vLocs, StartMod, EndMod, vRscs);
139 }
140
141 if (RC == XAIE_OK) {
142 RC = AieHd->rscMgr()->request(*this);
143 }
144
145 if (RC != XAIE_OK) {
146 Logger::log(LogLevel::FAL_WARN) << "broadcast " <<
147 __func__ << " resource not available.\n";
148 vRscs.clear();
149 } else {
150 reservedId = vRscs[0].RscId;
151 }
152 return RC;
153
154 }
155 AieRC _release() {
156 AieRC RC;
157
158 RC = AieHd->rscMgr()->release(*this);
159 vRscs.clear();
160 return RC;
161 }
162 AieRC _start() {
163 AieRC RC = XAIE_OK;
164 int i = 0;
165 uint32_t TType;
166
167 for(auto r = vRscs.begin(); r != vRscs.end();) {
168 uint8_t un_block = 0;
169 uint8_t un_block_n = 0;
170
171 TType = XAie_GetTileTypefromLoc(dev(), (*r).Loc);
172 if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
173 if (r != vRscs.begin()) {
174 if ((*(r - 1)).Loc.Col < ((*r).Loc.Col )) {
175 un_block |= XAIE_EVENT_BROADCAST_WEST;
176 } else if ((*(r - 1)).Loc.Col > ((*r).Loc.Col)) {
177 un_block |= XAIE_EVENT_BROADCAST_EAST;
178 } else if ((*(r - 1)).Loc.Row > ((*r).Loc.Row)) {
179 un_block |= XAIE_EVENT_BROADCAST_NORTH;
180 } else {
181 un_block |= XAIE_EVENT_BROADCAST_SOUTH;
182 }
183 }
184
185 if ((r + 2) != vRscs.end()) {
186 if ((*(r + 2)).Loc.Col < ((*r).Loc.Col )) {
187 un_block |= XAIE_EVENT_BROADCAST_WEST;
188 } else if ((*(r + 2)).Loc.Col > ((*r).Loc.Col)) {
189 un_block |= XAIE_EVENT_BROADCAST_EAST;
190 } else if ((*(r + 2)).Loc.Row > ((*r).Loc.Row)) {
191 un_block |= XAIE_EVENT_BROADCAST_NORTH;
192 } else {
193 un_block |= XAIE_EVENT_BROADCAST_SOUTH;
194 }
195 }
196 un_block_n = un_block;
197 u8 IsCheckerBoard;
198 XAie_IsDeviceCheckerboard(dev(), &IsCheckerBoard);
199 if (IsCheckerBoard) {
200 /* All broadcast core tiles begin with reserving core module first */
201 if ((*r).Loc.Row % 2) {
202 un_block |= XAIE_EVENT_BROADCAST_EAST;
203 un_block_n |= XAIE_EVENT_BROADCAST_WEST;
204 } else {
205 un_block |= XAIE_EVENT_BROADCAST_WEST;
206 un_block_n |= XAIE_EVENT_BROADCAST_EAST;
207 }
208
209 } else {
210 un_block |= XAIE_EVENT_BROADCAST_EAST;
211 un_block_n |= XAIE_EVENT_BROADCAST_WEST;
212 }
213
214 RC = XAie_EventBroadcastUnblockDir(dev(),
215 (*r).Loc, (*r).Mod,
216 XAIE_EVENT_SWITCH_A,
217 (*r).RscId,
218 XAIE_EVENT_BROADCAST_ALL);
219 RC = XAie_EventBroadcastUnblockDir(dev(),
220 (*(r+1)).Loc, (*(r + 1)).Mod,
221 XAIE_EVENT_SWITCH_A,
222 (*(r + 1)).RscId,
223 XAIE_EVENT_BROADCAST_ALL);
224 RC = XAie_EventBroadcastBlockDir(dev(),
225 (*r).Loc, (*r).Mod,
226 XAIE_EVENT_SWITCH_A,
227 (*r).RscId,
228 XAIE_EVENT_BROADCAST_ALL & (~un_block));
229 RC = XAie_EventBroadcastBlockDir(dev(),
230 (*(r + 1)).Loc, (*(r+1)).Mod,
231 XAIE_EVENT_SWITCH_A,
232 (*(r + 1)).RscId,
233 XAIE_EVENT_BROADCAST_ALL & (~un_block_n));
234
235 r += 2;
236 } else {
237 if (r != vRscs.begin()) {
238 if ((*(r - 1)).Loc.Col < ((*r).Loc.Col )) {
239 un_block = XAIE_EVENT_BROADCAST_WEST;
240 } else if ((*(r - 1)).Loc.Col > ((*r).Loc.Col)) {
241 un_block = XAIE_EVENT_BROADCAST_EAST;
242 } else {
243 un_block = XAIE_EVENT_BROADCAST_NORTH;
244 }
245 }
246 if ((r + 1) != vRscs.end()) {
247 if ((*(r + 1)).Loc.Col < ((*r).Loc.Col )) {
248 un_block |= XAIE_EVENT_BROADCAST_WEST;
249 } else if ((*(r + 1)).Loc.Col > ((*r).Loc.Col)) {
250 un_block |= XAIE_EVENT_BROADCAST_EAST;
251 } else {
252 un_block |= XAIE_EVENT_BROADCAST_NORTH;
253 }
254 }
255 RC = XAie_EventBroadcastUnblockDir(dev(),
256 (*r).Loc, (*r).Mod,
257 XAIE_EVENT_SWITCH_A,
258 (*r).RscId,
259 XAIE_EVENT_BROADCAST_ALL);
260 RC = XAie_EventBroadcastUnblockDir(dev(),
261 (*r).Loc, (*r).Mod,
262 XAIE_EVENT_SWITCH_B,
263 (*r).RscId,
264 XAIE_EVENT_BROADCAST_ALL);
265 RC = XAie_EventBroadcastBlockDir(dev(),
266 (*r).Loc, (*r).Mod,
267 XAIE_EVENT_SWITCH_A,
268 (*r).RscId,
269 XAIE_EVENT_BROADCAST_ALL & (~(un_block | XAIE_EVENT_BROADCAST_EAST)));
270
271 RC = XAie_EventBroadcastBlockDir(dev(),
272 (*r).Loc, (*r).Mod,
273 XAIE_EVENT_SWITCH_B,
274 (*r).RscId,
275 XAIE_EVENT_BROADCAST_ALL & (~(un_block | XAIE_EVENT_BROADCAST_WEST)));
276
277 r++;
278 }
279 if (RC != XAIE_OK) {
280 break;
281 }
282 i++;
283 }
284 if (RC != XAIE_OK) {
285 Logger::log(LogLevel::FAL_ERROR) << "BC: " <<
286 " failed to stop." << std::endl;
287 }
288 return RC;
289 }
290
291 AieRC _stop() {
292 AieRC RC;
293 int iRC = XAIE_OK;
294
295 if(vLocs.size() == 0) {
296 return XAIE_OK;
297 }
298
299 for (auto r: vRscs) {
300 if (r.Loc.Row == 0) {
301 // Unblock SHIM tile switch A and B
302 iRC |= XAie_EventBroadcastUnblockDir(dev(),
303 r.Loc, r.Mod,
304 XAIE_EVENT_SWITCH_A, r.RscId,
305 XAIE_EVENT_BROADCAST_ALL);
306 iRC |= XAie_EventBroadcastUnblockDir(dev(),
307 r.Loc, r.Mod,
308 XAIE_EVENT_SWITCH_B, r.RscId,
309 XAIE_EVENT_BROADCAST_ALL);
310 } else {
311 iRC |= XAie_EventBroadcastUnblockDir(dev(),
312 r.Loc, r.Mod,
313 XAIE_EVENT_SWITCH_A, r.RscId,
314 XAIE_EVENT_BROADCAST_ALL);
315 }
316 }
317 if (iRC != (int)XAIE_OK) {
318 Logger::log(LogLevel::FAL_ERROR) << "BC: " <<
319 " failed to stop." << std::endl;
320 RC = XAIE_ERR;
321 } else {
322 RC = XAIE_OK;
323 }
324 return RC;
325 }
326
327 void _getReservedRscs(std::vector<XAieUserRsc> &vOutRscs) const {
328 vOutRscs.insert(vOutRscs.end(), vRscs.begin(), vRscs.end());
329 }
330 private:
331 XAie_ModuleType StartMod;
332 XAie_ModuleType EndMod;
333 std::vector<XAie_LocType> vLocs;
334 private:
335 static AieRC setRscs(std::shared_ptr<XAieDevHandle> Dev,
336 const std::vector<XAie_LocType> &vL,
337 XAie_ModuleType startM, XAie_ModuleType endM,
338 std::vector<XAieUserRsc> &vR) {
339
340 if ((vL[0].Row == 0 && startM != XAIE_PL_MOD) ||
341 (vL.back().Row == 0 && endM != XAIE_PL_MOD) ||
342 (vL[0].Row != 0 && startM == XAIE_PL_MOD) ||
343 (vL.back().Row != 0 && endM == XAIE_PL_MOD)) {
344 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
345 "BC: invalid tiles and modules combination." << std::endl;
346 return XAIE_INVALID_ARGS;
347 }
348
349 for (size_t i = 0; i < vL.size(); i++) {
350 XAieUserRsc R;
351 uint32_t TType;
352
353 R.RscType = XAIE_BROADCAST;
354
355 TType = XAie_GetTileTypefromLoc(Dev->dev(),
356 vL[i]);
357 if (TType == XAIEGBL_TILE_TYPE_MAX) {
358 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
359 "BC: invalid tile (" << vL[i].Col <<
360 "," << vL[i].Row <<")" <<
361 std::endl;
362 return XAIE_INVALID_ARGS;
363 }
364
365 R.Loc.Col = vL[i].Col;
366 R.Loc.Row = vL[i].Row;
367
368 if (TType == XAIEGBL_TILE_TYPE_AIETILE) {
369 R.Mod = XAIE_CORE_MOD;
370 vR.push_back(R);
371 R.Mod = XAIE_MEM_MOD;
372 vR.push_back(R);
373 } else if (TType == XAIEGBL_TILE_TYPE_MEMTILE) {
374 R.Mod = XAIE_MEM_MOD;
375 vR.push_back(R);
376 } else {
377 R.Mod = XAIE_PL_MOD;
378 vR.push_back(R);
379 }
380
381 if (i != vL.size() - 1) {
382 if (vL[i+1].Row == vL[i].Row &&
383 vL[i+1].Col == vL[i].Col) {
384 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
385 "BC: duplicated tiles in the vector." <<
386 std::endl;
387 return XAIE_INVALID_ARGS;
388 }
389 if (vL[i+1].Row != vL[i].Row) {
390 if ((vL[i+1].Col != vL[i].Col) ||
391 (vL[i+1].Row > vL[i].Row &&
392 (vL[i+1].Row - vL[i].Row) > 1) ||
393 (vL[i+1].Row < vL[i].Row &&
394 (vL[i].Row - vL[i+1].Row) > 1)) {
395 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
396 "BC: discontinuous input tiles." <<
397 std::endl;
398 return XAIE_INVALID_ARGS;
399 }
400 } else {
401 if ((vL[i+1].Col > vL[i].Col &&
402 (vL[i+1].Col - vL[i].Col) > 1) ||
403 (vL[i+1].Col < vL[i].Col &&
404 (vL[i].Col - vL[i+1].Col) > 1)) {
405 Logger::log(LogLevel::FAL_ERROR) << __func__ <<
406 "BC: discontinuous input tiles." <<
407 std::endl;
408 return XAIE_INVALID_ARGS;
409 }
410 }
411 }
412 }
413 return XAIE_OK;
414 }
415 };
416}
xaiefal::Logger::log
static std::ostream & log(LogLevel Lvl=LogLevel::FAL_MAX)
Definition xaiefal-log.hpp:50
xaiefal::XAieBroadcast::~XAieBroadcast
~XAieBroadcast()
Definition xaiefal-bc.hpp:47
xaiefal::XAieBroadcast::getChannel
AieRC getChannel(std::vector< XAie_LocType > &vL, XAie_ModuleType &StartM, XAie_ModuleType &EndM)
Definition xaiefal-bc.hpp:112
xaiefal::XAieBroadcast::XAieBroadcast
XAieBroadcast(XAieDev &Dev, const std::vector< XAie_LocType > &vInLocs, XAie_ModuleType StartM, XAie_ModuleType EndM)
Definition xaiefal-bc.hpp:43
xaiefal::XAieBroadcast::getRscStat
XAieRscStat getRscStat(const std::string &GName) const
Definition xaiefal-bc.hpp:121
xaiefal::XAieBroadcast::XAieBroadcast
XAieBroadcast(std::shared_ptr< XAieDevHandle > DevHd, const std::vector< XAie_LocType > &vInLocs, XAie_ModuleType StartM, XAie_ModuleType EndM)
Definition xaiefal-bc.hpp:32
xaiefal::XAieBroadcast::getBc
int getBc()
Definition xaiefal-bc.hpp:53
xaiefal::XAieBroadcast::getEvent
AieRC getEvent(XAie_LocType Loc, XAie_ModuleType Mod, XAie_Events &Event)
Definition xaiefal-bc.hpp:70
xaiefal::XAieDev
AI engine device class. It defines AI engine device operations.
Definition xaiefal-base.hpp:259
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::getRscType
virtual XAieRscType getRscType() const
Definition xaiefal-rsc-base.hpp:351
xaiefal::XAieRsc::dev
XAie_DevInst * dev()
Definition xaiefal-rsc-base.hpp:373
xaiefal::XAieRsc::preferredId
uint32_t preferredId
Definition xaiefal-rsc-base.hpp:401
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
void
c Accompany it with the information you received as to the offer to distribute corresponding source complete source code means all the source code for all modules it plus any associated interface definition plus the scripts used to control compilation and installation of the executable as a special the source code distributed need not include anything that is normally and so on of the operating system on which the executable unless that component itself accompanies the executable If distribution of executable or object code is made by offering access to copy from a designated then offering equivalent access to copy the source code from the same place counts as distribution of the source even though third parties are not compelled to copy the source along with the object code You may not or distribute the Program except as expressly provided under this License Any attempt otherwise to sublicense or distribute the Program is void
Definition license.txt:197
XAie_ModuleType
xaiefal
Definition xaiefal-base.hpp:23
xaiefal::XAIE_BROADCAST
@ XAIE_BROADCAST
Definition xaiefal-rsc-group.hpp:33
xaiefal::LogLevel::FAL_ERROR
@ FAL_ERROR
Definition xaiefal-log.hpp:14
xaiefal::LogLevel::FAL_WARN
@ FAL_WARN
Definition xaiefal-log.hpp:13
xaiefal::XAieRscStat
struct of resource usage statistics
Definition xaiefal-rsc-group.hpp:66
XAIE_RSC_ID_ANY
#define XAIE_RSC_ID_ANY
Definition xaiefal-common.hpp:7
Generated on for xaiefal by doxygen 1.15.0