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", qRouteList->routeList.size());
117 4 : return ACL_SUCCESS;
118 4 : }
119 :
120 1 : aclError QueueProcessorHost::acltdtQueryQueueRoutes(
121 : const acltdtQueueRouteQueryInfo* const queryInfo, acltdtQueueRouteList* const qRouteList)
122 : {
123 1 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(queryInfo);
124 1 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(qRouteList);
125 1 : ACL_LOG_INFO("Start to acltdtQueryQueueRoutes");
126 1 : int32_t deviceId = 0;
127 1 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtGetDevice(&deviceId), rtGetDevice);
128 : // get dst id
129 1 : int32_t dstPid = 0;
130 1 : ACL_REQUIRES_OK(GetDstInfo(deviceId, CP_PID, dstPid));
131 1 : rtEschedEventSummary_t eventSum = {0, 0U, 0, 0U, 0U, nullptr, 0U, 0};
132 1 : rtEschedEventReply_t ack = {nullptr, 0U, 0U};
133 1 : bqs::QsProcMsgRsp qsRsp = {0UL, 0, 0U, 0U, 0U, {0}};
134 1 : eventSum.pid = dstPid;
135 1 : eventSum.grpId = 0U;
136 1 : eventSum.eventId = RT_MQ_SCHED_EVENT_QS_MSG;
137 1 : eventSum.dstEngine = static_cast<uint32_t>(RT_MQ_DST_ENGINE_ACPU_DEVICE);
138 1 : ack.buf = reinterpret_cast<char_t*>(&qsRsp);
139 1 : ack.bufLen = sizeof(qsRsp);
140 1 : const std::lock_guard<std::recursive_mutex> lk(muForQueueCtrl_);
141 1 : size_t routeNum = 0UL;
142 1 : ACL_REQUIRES_OK(GetQueueRouteNum(queryInfo, deviceId, eventSum, ack, routeNum));
143 1 : ACL_REQUIRES_OK(QueryQueueRoutes(deviceId, queryInfo, routeNum, eventSum, ack, qRouteList));
144 1 : return ACL_SUCCESS;
145 1 : }
146 :
147 8 : aclError QueueProcessorHost::SendBindUnbindMsg(
148 : const int32_t deviceId, acltdtQueueRouteList* const qRouteList, const bool isBind, rtEschedEventSummary_t& eventSum,
149 : 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(
180 : (static_cast<uint8_t*>(devPtr) + offset), (routeSize - offset), &tmpRoute, sizeof(tmpRoute),
181 : RT_MEMCPY_HOST_TO_DEVICE);
182 8 : if (ret != ACL_RT_SUCCESS) {
183 0 : (void)rtFree(devPtr);
184 0 : devPtr = nullptr;
185 0 : return ret;
186 : }
187 8 : offset += sizeof(bqs::QueueRoute);
188 : }
189 :
190 8 : bqs::QueueRouteList bqsBindUnbindMsg = {0U, 0U, {0}};
191 8 : bqsBindUnbindMsg.routeListMsgAddr = reinterpret_cast<uintptr_t>(devPtr);
192 8 : eventSum.subeventId =
193 8 : isBind ? static_cast<uint32_t>(bqs::ACL_BIND_QUEUE) : static_cast<uint32_t>(bqs::ACL_UNBIND_QUEUE);
194 8 : eventSum.msgLen = sizeof(bqsBindUnbindMsg);
195 8 : eventSum.msg = reinterpret_cast<char_t*>(&bqsBindUnbindMsg);
196 8 : ret = rtEschedSubmitEventSync(deviceId, &eventSum, &ack);
197 8 : eventSum.msgLen = 0U;
198 8 : eventSum.msg = nullptr;
199 8 : if (ret != RT_ERROR_NONE) {
200 1 : (void)rtFree(devPtr);
201 1 : devPtr = nullptr;
202 1 : return ret;
203 : }
204 7 : bqs::QsProcMsgRsp* const rsp = reinterpret_cast<bqs::QsProcMsgRsp*>(ack.buf);
205 7 : if (rsp->retCode != 0) {
206 1 : ACL_LOG_INNER_ERROR("send connect qs failed, ret code is %d", rsp->retCode);
207 1 : (void)rtFree(devPtr);
208 1 : devPtr = nullptr;
209 1 : return ACL_ERROR_FAILURE;
210 : }
211 6 : offset = sizeof(bqs::QsRouteHead);
212 11 : for (size_t i = 0UL; i < qRouteList->routeList.size(); ++i) {
213 6 : bqs::QueueRoute retRoute = {0U, 0U, 0, 0, 0, 0UL, 0UL, {0}};
214 12 : ret = rtMemcpy(
215 6 : &retRoute, sizeof(retRoute), (static_cast<uint8_t*>(devPtr) + offset), sizeof(retRoute),
216 : RT_MEMCPY_DEVICE_TO_HOST);
217 6 : if (ret != ACL_RT_SUCCESS) {
218 1 : (void)rtFree(devPtr);
219 1 : devPtr = nullptr;
220 1 : return ret;
221 : }
222 5 : qRouteList->routeList[i].status = retRoute.status;
223 5 : ACL_LOG_INFO(
224 : "route %zu, srcqid is %u, dst pid is %u, status is %d", i, qRouteList->routeList[i].srcId,
225 : qRouteList->routeList[i].dstId, qRouteList->routeList[i].status);
226 5 : offset += sizeof(bqs::QueueRoute);
227 : }
228 5 : (void)rtFree(devPtr);
229 5 : devPtr = nullptr;
230 5 : return ret;
231 : }
232 :
233 7 : aclError QueueProcessorHost::QueryQueueRoutes(
234 : const int32_t deviceId, const acltdtQueueRouteQueryInfo* const queryInfo, const size_t routeNum,
235 : rtEschedEventSummary_t& eventSum, rtEschedEventReply_t& ack, acltdtQueueRouteList* const qRouteList) const
236 : {
237 7 : ACL_LOG_INFO("start to query queue route %zu", routeNum);
238 7 : if (routeNum == 0U) {
239 1 : return ACL_SUCCESS;
240 : }
241 6 : size_t routeListBody = 0U;
242 6 : ACL_CHECK_ASSIGN_SIZET_MULTI(routeNum, sizeof(bqs::QueueRoute), routeListBody);
243 6 : size_t routeSize = 0U;
244 6 : ACL_CHECK_ASSIGN_SIZET_ADD((sizeof(bqs::QsRouteHead) + sizeof(bqs::QueueRouteQuery)), routeListBody, routeSize);
245 6 : ACL_LOG_INFO("route size is %zu, queue route num is %zu", routeSize, qRouteList->routeList.size());
246 6 : void* devPtr = nullptr;
247 6 : constexpr uint32_t flags = RT_MEMORY_DEFAULT | RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY;
248 6 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtMalloc(&devPtr, routeSize, flags, acl::ACL_MODE_ID_U16), rtMalloc);
249 6 : ACL_CHECK_MALLOC_RESULT(devPtr);
250 6 : (void)rtMemset(devPtr, routeSize, 0U, routeSize);
251 6 : bqs::QsRouteHead head = {0U, 0U, 0U, 0UL};
252 6 : head.length = routeSize;
253 6 : head.routeNum = routeNum;
254 6 : head.subEventId = bqs::ACL_QUERY_QUEUE;
255 6 : auto ret = rtMemcpy(devPtr, routeSize, &head, sizeof(head), RT_MEMCPY_HOST_TO_DEVICE);
256 6 : if (ret != ACL_RT_SUCCESS) {
257 1 : (void)rtFree(devPtr);
258 1 : devPtr = nullptr;
259 1 : return ret;
260 : }
261 5 : size_t offset = sizeof(bqs::QsRouteHead);
262 5 : bqs::QueueRouteQuery routeQuery = {0UL, 0U, 0U, 0U, 0, 0, 0UL, {0}};
263 5 : routeQuery.queryType = static_cast<uint32_t>(queryInfo->mode);
264 5 : routeQuery.srcId = queryInfo->srcId;
265 5 : routeQuery.dstId = queryInfo->dstId;
266 5 : ret = rtMemcpy(
267 : (static_cast<uint8_t*>(devPtr) + offset), (routeSize - offset), &routeQuery, sizeof(routeQuery),
268 : RT_MEMCPY_HOST_TO_DEVICE);
269 5 : if (ret != ACL_RT_SUCCESS) {
270 1 : (void)rtFree(devPtr);
271 1 : devPtr = nullptr;
272 1 : return ret;
273 : }
274 :
275 4 : bqs::QueueRouteList qsCommonMsg = {0U, 0U, {0}};
276 4 : qsCommonMsg.routeListMsgAddr = reinterpret_cast<uintptr_t>(devPtr);
277 4 : eventSum.subeventId = bqs::ACL_QUERY_QUEUE;
278 4 : eventSum.msgLen = sizeof(qsCommonMsg);
279 4 : eventSum.msg = reinterpret_cast<char_t*>(&qsCommonMsg);
280 :
281 4 : ret = rtEschedSubmitEventSync(deviceId, &eventSum, &ack);
282 4 : eventSum.msgLen = 0U;
283 4 : eventSum.msg = nullptr;
284 4 : if (ret != RT_ERROR_NONE) {
285 1 : (void)rtFree(devPtr);
286 1 : devPtr = nullptr;
287 1 : return ret;
288 : }
289 3 : bqs::QsProcMsgRsp* const rsp = reinterpret_cast<bqs::QsProcMsgRsp*>(ack.buf);
290 3 : if (rsp->retCode != 0) {
291 1 : ACL_LOG_INNER_ERROR("query queue route failed, ret code is %d", rsp->retCode);
292 1 : (void)rtFree(devPtr);
293 1 : devPtr = nullptr;
294 1 : return ACL_ERROR_FAILURE;
295 : }
296 2 : offset = sizeof(bqs::QsRouteHead) + sizeof(bqs::QueueRouteQuery);
297 3 : for (size_t i = 0UL; i < routeNum; ++i) {
298 2 : bqs::QueueRoute retRoute = {0U, 0U, 0, 0, 0, 0UL, 0UL, {0}};
299 4 : ret = rtMemcpy(
300 2 : &retRoute, sizeof(retRoute), (static_cast<uint8_t*>(devPtr) + offset), sizeof(retRoute),
301 : RT_MEMCPY_DEVICE_TO_HOST);
302 2 : if (ret != ACL_RT_SUCCESS) {
303 1 : (void)rtFree(devPtr);
304 1 : devPtr = nullptr;
305 1 : return ret;
306 : }
307 1 : const acltdtQueueRoute tmpQueueRoute = {retRoute.srcId, retRoute.dstId, retRoute.status};
308 1 : qRouteList->routeList.push_back(tmpQueueRoute);
309 1 : ACL_LOG_INFO(
310 : "route %zu, srcqid is %u, dst pid is %u, status is %d", i, qRouteList->routeList[i].srcId,
311 : qRouteList->routeList[i].dstId, qRouteList->routeList[i].status);
312 1 : offset += sizeof(bqs::QueueRoute);
313 : }
314 1 : (void)rtFree(devPtr);
315 1 : devPtr = nullptr;
316 1 : ACL_LOG_INFO("Successfully to execute acltdtQueryQueueRoutes, queue route is %zu", qRouteList->routeList.size());
317 1 : return ACL_SUCCESS;
318 : }
319 :
320 1 : aclError QueueProcessorHost::acltdtEnqueue(const uint32_t qid, const acltdtBuf buf, const int32_t timeout)
321 : {
322 : (void)(qid);
323 : (void)(buf);
324 : (void)(timeout);
325 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtEnqueue is not supported in this version. Please check.");
326 1 : const char_t* argList[] = {"func"};
327 1 : const char_t* argVal[] = {__func__};
328 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
329 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
330 : }
331 :
332 1 : aclError QueueProcessorHost::acltdtDequeue(const uint32_t qid, acltdtBuf* const buf, const int32_t timeout)
333 : {
334 : (void)(qid);
335 : (void)(buf);
336 : (void)(timeout);
337 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtDequeue is not supported in this version. Please check.");
338 1 : const char_t* argList[] = {"func"};
339 1 : const char_t* argVal[] = {__func__};
340 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
341 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
342 : }
343 :
344 3 : aclError QueueProcessorHost::acltdtAllocBuf(const size_t size, const uint32_t type, acltdtBuf* const buf)
345 : {
346 : (void)(size);
347 : (void)(type);
348 : (void)(buf);
349 3 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtAllocBuf is not supported in this version. Please check.");
350 3 : const char_t* argList[] = {"func"};
351 3 : const char_t* argVal[] = {__func__};
352 3 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
353 3 : return ACL_ERROR_FEATURE_UNSUPPORTED;
354 : }
355 :
356 3 : aclError QueueProcessorHost::acltdtFreeBuf(acltdtBuf buf)
357 : {
358 : (void)(buf);
359 3 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtFreeBuf is not supported in this version. Please check.");
360 3 : const char_t* argList[] = {"func"};
361 3 : const char_t* argVal[] = {__func__};
362 3 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
363 3 : return ACL_ERROR_FEATURE_UNSUPPORTED;
364 : }
365 :
366 1 : aclError QueueProcessorHost::acltdtGetBufData(const acltdtBuf buf, void** const dataPtr, size_t* const size)
367 : {
368 : (void)(buf);
369 : (void)(dataPtr);
370 : (void)(size);
371 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufData is not supported in this version. Please check.");
372 1 : const char_t* argList[] = {"func"};
373 1 : const char_t* argVal[] = {__func__};
374 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
375 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
376 : }
377 :
378 1 : aclError QueueProcessorHost::acltdtGetBufUserData(
379 : const acltdtBuf buf, void* dataPtr, const size_t size, const size_t offset)
380 : {
381 : (void)(buf);
382 : (void)(dataPtr);
383 : (void)(size);
384 : (void)(offset);
385 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufUserData is not supported in this version. Please check.");
386 1 : const char_t* argList[] = {"func"};
387 1 : const char_t* argVal[] = {__func__};
388 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
389 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
390 : }
391 :
392 1 : aclError QueueProcessorHost::acltdtSetBufUserData(
393 : acltdtBuf buf, const void* dataPtr, const size_t size, const size_t offset)
394 : {
395 : (void)(buf);
396 : (void)(dataPtr);
397 : (void)(size);
398 : (void)(offset);
399 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtSetBufUserData is not supported in this version. Please check.");
400 1 : const char_t* argList[] = {"func"};
401 1 : const char_t* argVal[] = {__func__};
402 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
403 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
404 : }
405 :
406 1 : aclError QueueProcessorHost::acltdtCopyBufRef(const acltdtBuf buf, acltdtBuf* const newBuf)
407 : {
408 : (void)(buf);
409 : (void)(newBuf);
410 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtCopyBufRef is not supported in this version. Please check.");
411 1 : const char_t* argList[] = {"func"};
412 1 : const char_t* argVal[] = {__func__};
413 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
414 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
415 : }
416 :
417 1 : aclError QueueProcessorHost::acltdtSetBufDataLen(const acltdtBuf buf, const size_t len)
418 : {
419 : (void)(buf);
420 : (void)(len);
421 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtSetBufDataLen is not supported in this version. Please check.");
422 1 : const char_t* argList[] = {"func"};
423 1 : const char_t* argVal[] = {__func__};
424 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
425 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
426 : }
427 :
428 1 : aclError QueueProcessorHost::acltdtGetBufDataLen(const acltdtBuf buf, size_t* const len)
429 : {
430 : (void)(buf);
431 : (void)(len);
432 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufDataLen is not supported in this version. Please check.");
433 1 : const char_t* argList[] = {"func"};
434 1 : const char_t* argVal[] = {__func__};
435 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
436 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
437 : }
438 :
439 1 : aclError QueueProcessorHost::acltdtAppendBufChain(const acltdtBuf headBuf, const acltdtBuf buf)
440 : {
441 : (void)(buf);
442 : (void)(headBuf);
443 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtAppendBufChain is not supported in this version. Please check.");
444 1 : const char_t* argList[] = {"func"};
445 1 : const char_t* argVal[] = {__func__};
446 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
447 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
448 : }
449 :
450 1 : aclError QueueProcessorHost::acltdtGetBufChainNum(const acltdtBuf headBuf, uint32_t* const num)
451 : {
452 : (void)(headBuf);
453 : (void)(num);
454 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufChainNum is not supported in this version. Please check.");
455 1 : const char_t* argList[] = {"func"};
456 1 : const char_t* argVal[] = {__func__};
457 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
458 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
459 : }
460 :
461 1 : aclError QueueProcessorHost::acltdtGetBufFromChain(const acltdtBuf headBuf, const uint32_t index, acltdtBuf* const buf)
462 : {
463 : (void)(buf);
464 : (void)(headBuf);
465 : (void)(index);
466 1 : ACL_LOG_ERROR("[Unsupported][Feature]acltdtGetBufFromChain is not supported in this version. Please check.");
467 1 : const char_t* argList[] = {"func"};
468 1 : const char_t* argVal[] = {__func__};
469 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::UNSUPPORTED_SYSTEM_MSG, argList, argVal, 1UL);
470 1 : return ACL_ERROR_FEATURE_UNSUPPORTED;
471 : }
472 : } // namespace acl
|
