Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 : #include "queue_process_host.h"
11 : #include "log_inner.h"
12 : #include "runtime/mem.h"
13 : #include "runtime/rt_mem_queue.h"
14 : #include "runtime/dev.h"
15 : #include "queue_schedule/qs_client.h"
16 : #include "utils/math_utils.h"
17 :
18 : namespace acl {
19 3 : aclError QueueProcessorHost::acltdtCreateQueue(const acltdtQueueAttr *const attr, uint32_t *const qid)
20 : {
21 3 : ACL_LOG_INFO("Start to acltdtCreateQueue");
22 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(qid);
23 2 : int32_t deviceId = 0;
24 2 : ACL_REQUIRES_RTS_OK(rtGetDevice(&deviceId));
25 2 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
26 2 : const rtError_t ret = rtMemQueueInit(deviceId);
27 2 : if ((ret != ACL_RT_SUCCESS) && (ret != ACL_ERROR_RT_REPEATED_INIT)) {
28 0 : return ret;
29 : }
30 2 : ACL_REQUIRES_OK(acltdtCreateQueueWithAttr(deviceId, attr, qid));
31 2 : ACL_LOG_INFO("Successfully to execute acltdtCreateQueue, qid is %u", *qid);
32 2 : return ACL_SUCCESS;
33 2 : }
34 :
35 1 : aclError QueueProcessorHost::acltdtDestroyQueue(const uint32_t qid)
36 : {
37 1 : int32_t deviceId = 0;
38 1 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtGetDevice(&deviceId), rtGetDevice);
39 : // get qs id
40 1 : int32_t qsPid = 0;
41 1 : size_t routeNum = 0UL;
42 1 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
43 1 : if (GetDstInfo(deviceId, QS_PID, qsPid) == RT_ERROR_NONE) {
44 1 : rtEschedEventSummary_t eventSum = {0, 0U, 0, 0U, 0U, nullptr, 0U, 0};
45 1 : rtEschedEventReply_t ack = {nullptr, 0U, 0U};
46 1 : bqs::QsProcMsgRsp qsRsp = {0UL, 0, 0U, 0U, 0U, {0}};
47 1 : int32_t cpPid = 0;
48 1 : ACL_REQUIRES_OK(GetDstInfo(deviceId, CP_PID, cpPid));
49 1 : eventSum.pid = cpPid;
50 1 : eventSum.grpId = 0U;
51 1 : eventSum.eventId = RT_MQ_SCHED_EVENT_QS_MSG;
52 1 : eventSum.dstEngine = static_cast<uint32_t>(RT_MQ_DST_ENGINE_ACPU_DEVICE);
53 1 : ack.buf = reinterpret_cast<char_t *>(&qsRsp);
54 1 : ack.bufLen = sizeof(qsRsp);
55 1 : acltdtQueueRouteQueryInfo queryInfo = {bqs::BQS_QUERY_TYPE_SRC_OR_DST, qid, qid, true, true, true};
56 1 : ACL_REQUIRES_OK(GetQueueRouteNum(&queryInfo, deviceId, eventSum, ack, routeNum));
57 : }
58 1 : if (routeNum > 0UL) {
59 0 : ACL_LOG_ERROR("qid [%u] can not be destroyed, it needs to be unbound first.", qid);
60 0 : return ACL_ERROR_FAILURE;
61 : }
62 1 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtMemQueueDestroy(deviceId, qid), rtMemQueueDestroy);
63 1 : DeleteMutexForData(qid);
64 1 : return ACL_SUCCESS;
65 1 : }
66 :
67 2 : aclError QueueProcessorHost::acltdtBindQueueRoutes(acltdtQueueRouteList *const qRouteList)
68 : {
69 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(qRouteList);
70 2 : ACL_LOG_INFO("Start to acltdtBindQueueRoutes, queue route is %zu", qRouteList->routeList.size());
71 2 : int32_t deviceId = 0;
72 2 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtGetDevice(&deviceId), rtGetDevice);
73 2 : ACL_REQUIRES_OK(InitQueueSchedule(deviceId));
74 : // get dst pid
75 2 : int32_t dstPid = 0;
76 2 : ACL_REQUIRES_OK(GetDstInfo(deviceId, CP_PID, dstPid));
77 2 : rtEschedEventSummary_t eventSum = {0, 0U, 0, 0U, 0U, nullptr, 0U, 0};
78 2 : rtEschedEventReply_t ack = {nullptr, 0U, 0U};
79 2 : bqs::QsProcMsgRsp qsRsp = {0UL, 0, 0U, 0U, 0U, {0}};
80 2 : eventSum.pid = dstPid;
81 2 : eventSum.grpId = 0U;
82 2 : eventSum.eventId = RT_MQ_SCHED_EVENT_QS_MSG;
83 2 : eventSum.dstEngine = static_cast<uint32_t>(RT_MQ_DST_ENGINE_ACPU_DEVICE);
84 2 : ack.buf = reinterpret_cast<char_t *>(&qsRsp);
85 2 : ack.bufLen = sizeof(qsRsp);
86 2 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
87 2 : if (!isQsInit_) {
88 1 : ACL_REQUIRES_OK(SendConnectQsMsg(deviceId, eventSum, ack));
89 1 : isQsInit_ = true;
90 : }
91 2 : ACL_REQUIRES_OK(SendBindUnbindMsg(deviceId, qRouteList, true, eventSum, ack));
92 1 : ACL_LOG_INFO("Successfully to execute acltdtBindQueueRoutes, queue route is %zu", qRouteList->routeList.size());
93 1 : return ACL_SUCCESS;
94 2 : }
95 :
96 4 : aclError QueueProcessorHost::acltdtUnbindQueueRoutes(acltdtQueueRouteList *const qRouteList)
97 : {
98 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(qRouteList);
99 4 : ACL_LOG_INFO("Start to acltdtUnBindQueueRoutes, queue route is %zu", qRouteList->routeList.size());
100 4 : int32_t deviceId = 0;
101 4 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtGetDevice(&deviceId), rtGetDevice);
102 : // get dst pid
103 4 : int32_t dstPid = 0;
104 4 : ACL_REQUIRES_OK(GetDstInfo(deviceId, CP_PID, dstPid));
105 4 : rtEschedEventSummary_t eventSum = {0, 0U, 0, 0U, 0U, nullptr, 0U, 0};
106 4 : rtEschedEventReply_t ack = {nullptr, 0U, 0U};
107 4 : bqs::QsProcMsgRsp qsRsp = {0UL, 0, 0U, 0U, 0U, {0}};
108 4 : eventSum.pid = dstPid;
109 4 : eventSum.grpId = 0U;
110 4 : eventSum.eventId = RT_MQ_SCHED_EVENT_QS_MSG;
111 4 : eventSum.dstEngine = static_cast<uint32_t>(RT_MQ_DST_ENGINE_ACPU_DEVICE);
112 4 : ack.buf = reinterpret_cast<char_t *>(&qsRsp);
113 4 : ack.bufLen = sizeof(qsRsp);
114 4 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
115 4 : ACL_REQUIRES_OK(SendBindUnbindMsg(deviceId, qRouteList, false, eventSum, ack));
116 4 : ACL_LOG_INFO("Successfully to execute acltdtUnBindQueueRoutes, queue route is %zu",
117 : qRouteList->routeList.size());
118 4 : return ACL_SUCCESS;
119 4 : }
120 :
121 1 : aclError QueueProcessorHost::acltdtQueryQueueRoutes(const acltdtQueueRouteQueryInfo *const queryInfo,
122 : acltdtQueueRouteList *const qRouteList)
123 : {
124 1 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(queryInfo);
125 1 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(qRouteList);
126 1 : ACL_LOG_INFO("Start to acltdtQueryQueueRoutes");
127 1 : int32_t deviceId = 0;
128 1 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtGetDevice(&deviceId), rtGetDevice);
129 : // get dst id
130 1 : int32_t dstPid = 0;
131 1 : ACL_REQUIRES_OK(GetDstInfo(deviceId, CP_PID, dstPid));
132 1 : rtEschedEventSummary_t eventSum = {0, 0U, 0, 0U, 0U, nullptr, 0U, 0};
133 1 : rtEschedEventReply_t ack = {nullptr, 0U, 0U};
134 1 : bqs::QsProcMsgRsp qsRsp = {0UL, 0, 0U, 0U, 0U, {0}};
135 1 : eventSum.pid = dstPid;
136 1 : eventSum.grpId = 0U;
137 1 : eventSum.eventId = RT_MQ_SCHED_EVENT_QS_MSG;
138 1 : eventSum.dstEngine = static_cast<uint32_t>(RT_MQ_DST_ENGINE_ACPU_DEVICE);
139 1 : ack.buf = reinterpret_cast<char_t *>(&qsRsp);
140 1 : ack.bufLen = sizeof(qsRsp);
141 1 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
142 1 : size_t routeNum = 0UL;
143 1 : ACL_REQUIRES_OK(GetQueueRouteNum(queryInfo, deviceId, eventSum, ack, routeNum));
144 1 : ACL_REQUIRES_OK(QueryQueueRoutes(deviceId, queryInfo, routeNum, eventSum, ack, qRouteList));
145 1 : return ACL_SUCCESS;
146 1 : }
147 :
148 8 : aclError QueueProcessorHost::SendBindUnbindMsg(const int32_t deviceId, acltdtQueueRouteList *const qRouteList,
149 : const bool isBind, rtEschedEventSummary_t &eventSum, rtEschedEventReply_t &ack) const
150 : {
151 8 : ACL_LOG_INFO("start to send bind or unbind msg");
152 : // send bind or unbind msg
153 8 : size_t routeListBody = 0U;
154 8 : ACL_CHECK_ASSIGN_SIZET_MULTI(qRouteList->routeList.size(), sizeof(bqs::QueueRoute), routeListBody);
155 8 : size_t routeSize = 0U;
156 8 : ACL_CHECK_ASSIGN_SIZET_ADD(sizeof(bqs::QsRouteHead), routeListBody, routeSize);
157 8 : ACL_LOG_INFO("route size is %zu, queue route num is %zu", routeSize, qRouteList->routeList.size());
158 8 : void *devPtr = nullptr;
159 8 : constexpr uint32_t flags = RT_MEMORY_DEFAULT | RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY;
160 8 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtMalloc(&devPtr, routeSize, flags, acl::ACL_MODE_ID_U16), rtMalloc);
161 8 : ACL_CHECK_MALLOC_RESULT(devPtr);
162 8 : (void)rtMemset(devPtr, routeSize, 0U, routeSize);
163 8 : bqs::QsRouteHead head = {0U, 0U, 0U, 0UL};
164 8 : head.length = routeSize;
165 8 : head.routeNum = qRouteList->routeList.size();
166 8 : head.subEventId =
167 8 : isBind ? static_cast<uint32_t>(bqs::ACL_BIND_QUEUE) : static_cast<uint32_t>(bqs::ACL_UNBIND_QUEUE);
168 8 : auto ret = rtMemcpy(devPtr, routeSize, &head, sizeof(head), RT_MEMCPY_HOST_TO_DEVICE);
169 8 : if (ret != ACL_RT_SUCCESS) {
170 0 : (void)rtFree(devPtr);
171 0 : devPtr = nullptr;
172 0 : return ret;
173 : }
174 8 : size_t offset = sizeof(bqs::QsRouteHead);
175 16 : for (size_t i = 0UL; i < qRouteList->routeList.size(); ++i) {
176 8 : bqs::QueueRoute tmpRoute = {0U, 0U, 0, 0, 0, 0UL, 0UL, {0}};
177 8 : tmpRoute.srcId = qRouteList->routeList[i].srcId;
178 8 : tmpRoute.dstId = qRouteList->routeList[i].dstId;
179 8 : ret = rtMemcpy((static_cast<uint8_t *>(devPtr) + offset), (routeSize - offset), &tmpRoute,
180 : sizeof(tmpRoute), RT_MEMCPY_HOST_TO_DEVICE);
181 8 : if (ret != ACL_RT_SUCCESS) {
182 0 : (void)rtFree(devPtr);
183 0 : devPtr = nullptr;
184 0 : return ret;
185 : }
186 8 : offset += sizeof(bqs::QueueRoute);
187 : }
188 :
189 8 : bqs::QueueRouteList bqsBindUnbindMsg = {0U, 0U, {0}};
190 8 : bqsBindUnbindMsg.routeListMsgAddr = reinterpret_cast<uintptr_t>(devPtr);
191 8 : eventSum.subeventId =
192 8 : isBind ? static_cast<uint32_t>(bqs::ACL_BIND_QUEUE) : static_cast<uint32_t>(bqs::ACL_UNBIND_QUEUE);
193 8 : eventSum.msgLen = sizeof(bqsBindUnbindMsg);
194 8 : eventSum.msg = reinterpret_cast<char_t *>(&bqsBindUnbindMsg);
195 8 : ret = rtEschedSubmitEventSync(deviceId, &eventSum, &ack);
196 8 : eventSum.msgLen = 0U;
197 8 : eventSum.msg = nullptr;
198 8 : if (ret != RT_ERROR_NONE) {
199 1 : (void)rtFree(devPtr);
200 1 : devPtr = nullptr;
201 1 : return ret;
202 : }
203 7 : bqs::QsProcMsgRsp *const rsp = reinterpret_cast<bqs::QsProcMsgRsp *>(ack.buf);
204 7 : if (rsp->retCode != 0) {
205 1 : ACL_LOG_INNER_ERROR("send connect qs failed, ret code is %d", rsp->retCode);
206 1 : (void)rtFree(devPtr);
207 1 : devPtr = nullptr;
208 1 : return ACL_ERROR_FAILURE;
209 : }
210 6 : offset = sizeof(bqs::QsRouteHead);
211 11 : for (size_t i = 0UL; i < qRouteList->routeList.size(); ++i) {
212 6 : bqs::QueueRoute retRoute = {0U, 0U, 0, 0, 0, 0UL, 0UL, {0}};
213 6 : ret = rtMemcpy(&retRoute, sizeof(retRoute), (static_cast<uint8_t *>(devPtr) + offset),
214 : sizeof(retRoute), RT_MEMCPY_DEVICE_TO_HOST);
215 6 : if (ret != ACL_RT_SUCCESS) {
216 1 : (void)rtFree(devPtr);
217 1 : devPtr = nullptr;
218 1 : return ret;
219 : }
220 5 : qRouteList->routeList[i].status = retRoute.status;
221 5 : ACL_LOG_INFO("route %zu, srcqid is %u, dst pid is %u, status is %d", i, qRouteList->routeList[i].srcId,
222 : qRouteList->routeList[i].dstId, qRouteList->routeList[i].status);
223 5 : offset += sizeof(bqs::QueueRoute);
224 : }
225 5 : (void)rtFree(devPtr);
226 5 : devPtr = nullptr;
227 5 : return ret;
228 : }
229 :
230 7 : aclError QueueProcessorHost::QueryQueueRoutes(const int32_t deviceId,
231 : const acltdtQueueRouteQueryInfo *const queryInfo,
232 : const size_t routeNum, rtEschedEventSummary_t &eventSum,
233 : rtEschedEventReply_t &ack, acltdtQueueRouteList *const qRouteList) const
234 : {
235 7 : ACL_LOG_INFO("start to query queue route %zu", routeNum);
236 7 : if (routeNum == 0U) {
237 1 : return ACL_SUCCESS;
238 : }
239 6 : size_t routeListBody = 0U;
240 6 : ACL_CHECK_ASSIGN_SIZET_MULTI(routeNum, sizeof(bqs::QueueRoute), routeListBody);
241 6 : size_t routeSize = 0U;
242 6 : ACL_CHECK_ASSIGN_SIZET_ADD((sizeof(bqs::QsRouteHead) + sizeof(bqs::QueueRouteQuery)), routeListBody, routeSize);
243 6 : ACL_LOG_INFO("route size is %zu, queue route num is %zu", routeSize, qRouteList->routeList.size());
244 6 : void *devPtr = nullptr;
245 6 : constexpr uint32_t flags = RT_MEMORY_DEFAULT | RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY;
246 6 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtMalloc(&devPtr, routeSize, flags, acl::ACL_MODE_ID_U16), rtMalloc);
247 6 : ACL_CHECK_MALLOC_RESULT(devPtr);
248 6 : (void)rtMemset(devPtr, routeSize, 0U, routeSize);
249 6 : bqs::QsRouteHead head = {0U, 0U, 0U, 0UL};
250 6 : head.length = routeSize;
251 6 : head.routeNum = routeNum;
252 6 : head.subEventId = bqs::ACL_QUERY_QUEUE;
253 6 : auto ret = rtMemcpy(devPtr, routeSize, &head, sizeof(head), RT_MEMCPY_HOST_TO_DEVICE);
254 6 : if (ret != ACL_RT_SUCCESS) {
255 1 : (void)rtFree(devPtr);
256 1 : devPtr = nullptr;
257 1 : return ret;
258 : }
259 5 : size_t offset = sizeof(bqs::QsRouteHead);
260 5 : bqs::QueueRouteQuery routeQuery = {0UL, 0U, 0U, 0U, 0, 0, 0UL, {0}};
261 5 : routeQuery.queryType = static_cast<uint32_t>(queryInfo->mode);
262 5 : routeQuery.srcId = queryInfo->srcId;
263 5 : routeQuery.dstId = queryInfo->dstId;
264 5 : ret = rtMemcpy((static_cast<uint8_t *>(devPtr) + offset), (routeSize - offset), &routeQuery,
265 : sizeof(routeQuery), RT_MEMCPY_HOST_TO_DEVICE);
266 5 : if (ret != ACL_RT_SUCCESS) {
267 1 : (void)rtFree(devPtr);
268 1 : devPtr = nullptr;
269 1 : return ret;
270 : }
271 :
272 4 : bqs::QueueRouteList qsCommonMsg = {0U, 0U, {0}};
273 4 : qsCommonMsg.routeListMsgAddr = reinterpret_cast<uintptr_t>(devPtr);
274 4 : eventSum.subeventId = bqs::ACL_QUERY_QUEUE;
275 4 : eventSum.msgLen = sizeof(qsCommonMsg);
276 4 : eventSum.msg = reinterpret_cast<char_t *>(&qsCommonMsg);
277 :
278 4 : ret = rtEschedSubmitEventSync(deviceId, &eventSum, &ack);
279 4 : eventSum.msgLen = 0U;
280 4 : eventSum.msg = nullptr;
281 4 : if (ret != RT_ERROR_NONE) {
282 1 : (void)rtFree(devPtr);
283 1 : devPtr = nullptr;
284 1 : return ret;
285 : }
286 3 : bqs::QsProcMsgRsp *const rsp = reinterpret_cast<bqs::QsProcMsgRsp *>(ack.buf);
287 3 : if (rsp->retCode != 0) {
288 1 : ACL_LOG_INNER_ERROR("query queue route failed, ret code is %d", rsp->retCode);
289 1 : (void)rtFree(devPtr);
290 1 : devPtr = nullptr;
291 1 : return ACL_ERROR_FAILURE;
292 : }
293 2 : offset = sizeof(bqs::QsRouteHead) + sizeof(bqs::QueueRouteQuery);
294 3 : for (size_t i = 0UL; i < routeNum; ++i) {
295 2 : bqs::QueueRoute retRoute = {0U, 0U, 0, 0, 0, 0UL, 0UL, {0}};
296 2 : ret = rtMemcpy(&retRoute, sizeof(retRoute), (static_cast<uint8_t *>(devPtr) + offset),
297 : sizeof(retRoute), RT_MEMCPY_DEVICE_TO_HOST);
298 2 : if (ret != ACL_RT_SUCCESS) {
299 1 : (void)rtFree(devPtr);
300 1 : devPtr = nullptr;
301 1 : return ret;
302 : }
303 1 : const acltdtQueueRoute tmpQueueRoute = {retRoute.srcId, retRoute.dstId, retRoute.status};
304 1 : qRouteList->routeList.push_back(tmpQueueRoute);
305 1 : ACL_LOG_INFO("route %zu, srcqid is %u, dst pid is %u, status is %d", i, qRouteList->routeList[i].srcId,
306 : qRouteList->routeList[i].dstId, qRouteList->routeList[i].status);
307 1 : offset += sizeof(bqs::QueueRoute);
308 : }
309 1 : (void)rtFree(devPtr);
310 1 : devPtr = nullptr;
311 1 : ACL_LOG_INFO("Successfully to execute acltdtQueryQueueRoutes, queue route is %zu",
312 : qRouteList->routeList.size());
313 1 : return ACL_SUCCESS;
314 : }
315 :
316 1 : aclError QueueProcessorHost::acltdtEnqueue(const uint32_t qid, const acltdtBuf buf, const int32_t timeout)
317 : {
318 : (void)(qid);
319 : (void)(buf);
320 : (void)(timeout);
321 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtEnqueue is not supported in this version. Please check.");
322 1 : const char_t *argList[] = {"func"};
323 1 : const char_t *argVal[] = {__func__};
324 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
325 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
326 : }
327 :
328 1 : aclError QueueProcessorHost::acltdtDequeue(const uint32_t qid, acltdtBuf *const buf, const int32_t timeout)
329 : {
330 : (void)(qid);
331 : (void)(buf);
332 : (void)(timeout);
333 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtDequeue is not supported in this version. Please check.");
334 1 : const char_t *argList[] = {"func"};
335 1 : const char_t *argVal[] = {__func__};
336 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
337 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
338 : }
339 :
340 3 : aclError QueueProcessorHost::acltdtAllocBuf(const size_t size, const uint32_t type, acltdtBuf *const buf)
341 : {
342 : (void)(size);
343 : (void)(type);
344 : (void)(buf);
345 3 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtAllocBuf is not supported in this version. Please check.");
346 3 : const char_t *argList[] = {"func"};
347 3 : const char_t *argVal[] = {__func__};
348 3 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
349 3 : return ACL_ERROR_FEATURE_UNSUPPORTED;
350 : }
351 :
352 3 : aclError QueueProcessorHost::acltdtFreeBuf(acltdtBuf buf)
353 : {
354 : (void)(buf);
355 3 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtFreeBuf is not supported in this version. Please check.");
356 3 : const char_t *argList[] = {"func"};
357 3 : const char_t *argVal[] = {__func__};
358 3 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
359 3 : return ACL_ERROR_FEATURE_UNSUPPORTED;
360 : }
361 :
362 1 : aclError QueueProcessorHost::acltdtGetBufData(const acltdtBuf buf, void **const dataPtr, size_t *const size)
363 : {
364 : (void)(buf);
365 : (void)(dataPtr);
366 : (void)(size);
367 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufData is not supported in this version. Please check.");
368 1 : const char_t *argList[] = {"func"};
369 1 : const char_t *argVal[] = {__func__};
370 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
371 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
372 : }
373 :
374 1 : aclError QueueProcessorHost::acltdtGetBufUserData(const acltdtBuf buf, void *dataPtr,
375 : const size_t size, const size_t offset)
376 : {
377 : (void)(buf);
378 : (void)(dataPtr);
379 : (void)(size);
380 : (void)(offset);
381 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufUserData is not supported in this version. Please check.");
382 1 : const char_t *argList[] = {"func"};
383 1 : const char_t *argVal[] = {__func__};
384 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
385 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
386 : }
387 :
388 1 : aclError QueueProcessorHost::acltdtSetBufUserData(acltdtBuf buf, const void *dataPtr,
389 : const size_t size, const size_t offset)
390 : {
391 : (void)(buf);
392 : (void)(dataPtr);
393 : (void)(size);
394 : (void)(offset);
395 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtSetBufUserData is not supported in this version. Please check.");
396 1 : const char_t *argList[] = {"func"};
397 1 : const char_t *argVal[] = {__func__};
398 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
399 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
400 : }
401 :
402 1 : aclError QueueProcessorHost::acltdtCopyBufRef(const acltdtBuf buf, acltdtBuf *const newBuf)
403 : {
404 : (void)(buf);
405 : (void)(newBuf);
406 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtCopyBufRef is not supported in this version. Please check.");
407 1 : const char_t *argList[] = {"func"};
408 1 : const char_t *argVal[] = {__func__};
409 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
410 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
411 : }
412 :
413 1 : aclError QueueProcessorHost::acltdtSetBufDataLen(const acltdtBuf buf, const size_t len)
414 : {
415 : (void)(buf);
416 : (void)(len);
417 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtSetBufDataLen is not supported in this version. Please check.");
418 1 : const char_t *argList[] = {"func"};
419 1 : const char_t *argVal[] = {__func__};
420 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
421 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
422 : }
423 :
424 1 : aclError QueueProcessorHost::acltdtGetBufDataLen(const acltdtBuf buf, size_t *const len)
425 : {
426 : (void)(buf);
427 : (void)(len);
428 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufDataLen is not supported in this version. Please check.");
429 1 : const char_t *argList[] = {"func"};
430 1 : const char_t *argVal[] = {__func__};
431 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
432 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
433 : }
434 :
435 1 : aclError QueueProcessorHost::acltdtAppendBufChain(const acltdtBuf headBuf, const acltdtBuf buf)
436 : {
437 : (void)(buf);
438 : (void)(headBuf);
439 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtAppendBufChain is not supported in this version. Please check.");
440 1 : const char_t *argList[] = {"func"};
441 1 : const char_t *argVal[] = {__func__};
442 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
443 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
444 : }
445 :
446 1 : aclError QueueProcessorHost::acltdtGetBufChainNum(const acltdtBuf headBuf, uint32_t *const num)
447 : {
448 : (void)(headBuf);
449 : (void)(num);
450 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufChainNum is not supported in this version. Please check.");
451 1 : const char_t *argList[] = {"func"};
452 1 : const char_t *argVal[] = {__func__};
453 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
454 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
455 : }
456 :
457 1 : aclError QueueProcessorHost::acltdtGetBufFromChain(const acltdtBuf headBuf,
458 : const uint32_t index, acltdtBuf *const buf)
459 : {
460 : (void)(buf);
461 : (void)(headBuf);
462 : (void)(index);
463 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufFromChain is not supported in this version. Please check.");
464 1 : const char_t *argList[] = {"func"};
465 1 : const char_t *argVal[] = {__func__};
466 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
467 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
468 : }
469 : }
|
