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