Line data Source code
1 : /**
2 : * Copyright (c) 2026 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 "ts_aicpu_sqe_adapter.h"
11 : #include "aicpusd_event_manager.h"
12 : #include "aicpusd_event_process.h"
13 : #include "aicpusd_msg_send.h"
14 : #include "dump_task.h"
15 : namespace AicpuSchedule {
16 21 : TsAicpuSqeAdapter::TsAicpuSqeAdapter(const TsAicpuSqe& sqe)
17 21 : : TsMsgAdapter(sqe.pid, sqe.cmd_type, sqe.vf_id, sqe.tid, sqe.ts_id), aicpuSqe_(sqe), invalidSqe_(false)
18 : {
19 21 : aicpusd_info("Adapter initialized: message_format=sqe.");
20 21 : }
21 :
22 2 : TsAicpuSqeAdapter::TsAicpuSqeAdapter() : TsMsgAdapter(), aicpuSqe_({}), invalidSqe_(true)
23 : {
24 2 : aicpusd_info("Adapter initialized: message_format=sqe valid=false.");
25 2 : }
26 :
27 4 : bool TsAicpuSqeAdapter::IsAdapterInvaildParameter() const
28 : {
29 4 : return invalidSqe_;
30 : }
31 :
32 1 : void TsAicpuSqeAdapter::GetAicpuDataDumpInfo(AicpuDataDumpInfo& info)
33 : {
34 1 : TsToAicpuDataDump tmpInfo = aicpuSqe_.u.ts_to_aicpu_datadump;
35 1 : aicpusd_info(
36 : "Dump request(sqe): model=%u stream=%u task=%u debug_stream=%u debug_task=%u "
37 : "ack_stream=%u ack_task=%u.",
38 : tmpInfo.model_id, tmpInfo.stream_id, tmpInfo.task_id, tmpInfo.stream_id1, tmpInfo.task_id1,
39 : tmpInfo.ack_stream_id, tmpInfo.ack_task_id);
40 1 : info.dump_task_id = tmpInfo.task_id;
41 1 : info.dump_stream_id = tmpInfo.stream_id;
42 1 : info.debug_dump_task_id = tmpInfo.task_id1;
43 1 : info.debug_dump_stream_id = tmpInfo.stream_id1;
44 1 : info.is_model = (tmpInfo.model_id != INVALID_VALUE16);
45 1 : info.is_debug = ((tmpInfo.task_id1 != INVALID_VALUE16) && (tmpInfo.stream_id1 != INVALID_VALUE16));
46 1 : info.file_name_stream_id = info.is_debug ? tmpInfo.stream_id1 : tmpInfo.stream_id;
47 1 : info.file_name_task_id = static_cast<uint32_t>(info.is_debug ? tmpInfo.task_id1 : tmpInfo.task_id);
48 1 : }
49 :
50 1 : void TsAicpuSqeAdapter::GetAicpuDumpFFTSPlusDataInfo(AicpuDumpFFTSPlusDataInfo& info)
51 : {
52 1 : aicpusd_info("Get FFTS+ dump info.");
53 1 : info.i = aicpuSqe_.u.ts_to_aicpu_ffts_plus_datadump;
54 1 : return;
55 : }
56 :
57 2 : bool TsAicpuSqeAdapter::IsOpMappingDumpTaskInfoVaild(const AicpuOpMappingDumpTaskInfo& info) const
58 : {
59 1 : const bool isOutOfRange = (info.proto_info_task_id > INVALID_VALUE16) || (info.proto_info_stream_id > INVALID_VALUE16) ||
60 3 : (info.stream_id > INVALID_VALUE16) || (info.task_id > INVALID_VALUE16);
61 2 : return !isOutOfRange;
62 : }
63 :
64 0 : void TsAicpuSqeAdapter::GetAicpuDumpTaskInfo(AicpuOpMappingDumpTaskInfo& opmappingInfo, AicpuDumpTaskInfo& dumpTaskInfo)
65 : {
66 0 : opmappingInfo.proto_info_task_id &= 0xFFFFU;
67 0 : aicpusd_info(
68 : "Dump task mapping: proto_task=%u proto_stream=%u mapped_task=%u mapped_stream=%u",
69 : opmappingInfo.proto_info_task_id, opmappingInfo.proto_info_stream_id, opmappingInfo.task_id,
70 : opmappingInfo.stream_id);
71 0 : dumpTaskInfo.task_id =
72 0 : opmappingInfo.proto_info_task_id == INVALID_VALUE16 ? opmappingInfo.task_id : opmappingInfo.proto_info_task_id;
73 0 : dumpTaskInfo.stream_id = opmappingInfo.proto_info_stream_id == INVALID_VALUE16 ? opmappingInfo.stream_id :
74 : opmappingInfo.proto_info_stream_id;
75 0 : dumpTaskInfo.context_id = INVALID_VALUE16;
76 0 : dumpTaskInfo.thread_id = INVALID_VALUE16;
77 0 : }
78 :
79 1 : void TsAicpuSqeAdapter::GetAicpuDataDumpInfoLoad(AicpuDataDumpInfoLoad& info)
80 : {
81 1 : TsToAicpuDataDumpInfoLoad tmpinfo = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo;
82 1 : aicpusd_info(
83 : "Dump load request: address=%p length=%u task=%u stream=%u.", tmpinfo.dumpinfoPtr,
84 : tmpinfo.length, tmpinfo.task_id, tmpinfo.stream_id);
85 1 : info.dumpinfoPtr = tmpinfo.dumpinfoPtr;
86 1 : info.length = tmpinfo.length;
87 1 : info.task_id = tmpinfo.task_id;
88 1 : info.stream_id = tmpinfo.stream_id;
89 1 : }
90 :
91 1 : int32_t TsAicpuSqeAdapter::AicpuDumpResponseToTs(const int32_t result)
92 : {
93 1 : TsAicpuSqe aicpuSqe{};
94 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
95 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
96 1 : aicpuSqe.tid = tid_;
97 1 : aicpuSqe.ts_id = tsId_;
98 1 : aicpuSqe.cmd_type = AICPU_DATADUMP_RESPONSE;
99 1 : aicpuSqe.u.aicpu_dump_resp.result_code = static_cast<uint16_t>(result);
100 1 : aicpuSqe.u.aicpu_dump_resp.cmd_type = AICPU_DATADUMP_REPORT;
101 1 : uint32_t handleId = 0U;
102 1 : if (cmdType_ == AICPU_FFTS_PLUS_DATADUMP_REPORT) {
103 0 : aicpusd_info("Dump response path: mode=ffts_plus.");
104 0 : TsToAicpuFFTSPlusDataDump info = aicpuSqe_.u.ts_to_aicpu_ffts_plus_datadump;
105 0 : uint32_t ackStreamId = info.stream_id;
106 0 : uint32_t ackTaskId = info.task_id;
107 0 : if ((info.task_id1 != INVALID_VALUE16) && (info.stream_id1 != INVALID_VALUE16)) {
108 0 : ackStreamId = info.stream_id1;
109 0 : ackTaskId = info.task_id1;
110 : }
111 0 : aicpuSqe.u.aicpu_dump_resp.task_id = ackTaskId;
112 0 : aicpuSqe.u.aicpu_dump_resp.stream_id = ackStreamId;
113 0 : aicpuSqe.u.aicpu_dump_resp.reserved = info.reserved[0];
114 0 : handleId = info.model_id;
115 : } else {
116 1 : aicpuSqe.u.aicpu_dump_resp.task_id = aicpuSqe_.u.ts_to_aicpu_datadump.ack_task_id;
117 1 : aicpuSqe.u.aicpu_dump_resp.stream_id = aicpuSqe_.u.ts_to_aicpu_datadump.ack_stream_id;
118 1 : aicpuSqe.u.aicpu_dump_resp.reserved = aicpuSqe_.u.ts_to_aicpu_datadump.reserved[0];
119 1 : handleId = aicpuSqe_.u.ts_to_aicpu_datadump.model_id;
120 : }
121 1 : aicpusd_info(
122 : "Dump response: message_type=%u result=%u ack_stream=%u ack_task=%u.", aicpuSqe.cmd_type, result,
123 : aicpuSqe.u.aicpu_dump_resp.stream_id, aicpuSqe.u.aicpu_dump_resp.task_id);
124 2 : return ResponseToTs(aicpuSqe, handleId, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
125 : }
126 :
127 1 : int32_t TsAicpuSqeAdapter::AicpuDataDumpLoadResponseToTs(const int32_t result)
128 : {
129 1 : TsAicpuSqe aicpuSqe{};
130 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
131 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
132 1 : aicpuSqe.tid = tid_;
133 1 : aicpuSqe.ts_id = tsId_;
134 1 : aicpuSqe.cmd_type = AICPU_DATADUMP_RESPONSE;
135 1 : aicpuSqe.u.aicpu_dump_resp.result_code = static_cast<uint16_t>(result);
136 1 : aicpuSqe.u.aicpu_dump_resp.cmd_type = AICPU_DATADUMP_LOADINFO;
137 1 : aicpuSqe.u.aicpu_dump_resp.task_id = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo.task_id;
138 1 : aicpuSqe.u.aicpu_dump_resp.stream_id = aicpuSqe_.u.ts_to_aicpu_datadumploadinfo.stream_id;
139 1 : aicpuSqe.u.aicpu_dump_resp.reserved = STARS_DATADUMP_LOAD_INFO;
140 1 : aicpusd_info(
141 : "Dump load response: message_type=%u result=%u stream=%u task=%u.", aicpuSqe.cmd_type, result,
142 : aicpuSqe.u.aicpu_dump_resp.stream_id, aicpuSqe.u.aicpu_dump_resp.task_id);
143 2 : return ResponseToTs(aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
144 : }
145 :
146 1 : void TsAicpuSqeAdapter::GetAicpuModelOperateInfo(AicpuModelOperateInfo& info)
147 : {
148 1 : TsAicpuModelOperate tmpInfo = aicpuSqe_.u.aicpu_model_operate;
149 1 : aicpusd_info("Model operation request: argument=%p operation=%u model=%u task=%u.",
150 : tmpInfo.arg_ptr,
151 : tmpInfo.cmd_type,
152 : tmpInfo.model_id,
153 : tmpInfo.task_id);
154 1 : info.arg_ptr = tmpInfo.arg_ptr;
155 1 : info.cmd_type = tmpInfo.cmd_type;
156 1 : info.model_id = tmpInfo.model_id;
157 1 : info.stream_id = tmpInfo.sq_id; // sq_id in rts actually is stream id
158 1 : info.task_id = tmpInfo.task_id;
159 1 : info.reserved[0] = tmpInfo.reserved;
160 2 : return;
161 : }
162 :
163 1 : int32_t TsAicpuSqeAdapter::AicpuModelOperateResponseToTs(const int32_t result, const uint32_t subEvent)
164 : {
165 1 : TsAicpuModelOperate tmpInfo = aicpuSqe_.u.aicpu_model_operate;
166 1 : TsAicpuSqe aicpuSqe = {};
167 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
168 1 : aicpuSqe.cmd_type = AICPU_MODEL_OPERATE_RESPONSE;
169 1 : aicpuSqe.vf_id = vfId_;
170 1 : aicpuSqe.tid = tid_;
171 1 : aicpuSqe.ts_id = tsId_;
172 1 : aicpuSqe.u.aicpu_model_operate_resp.cmd_type = AICPU_MODEL_OPERATE;
173 1 : aicpuSqe.u.aicpu_model_operate_resp.sub_cmd_type = tmpInfo.cmd_type;
174 1 : aicpuSqe.u.aicpu_model_operate_resp.model_id = tmpInfo.model_id;
175 1 : aicpuSqe.u.aicpu_model_operate_resp.result_code = static_cast<uint16_t>(result);
176 1 : aicpuSqe.u.aicpu_model_operate_resp.task_id = tmpInfo.task_id;
177 1 : aicpuSqe.u.aicpu_model_operate_resp.sq_id = tmpInfo.sq_id;
178 1 : aicpusd_info("Model operation response: message_type=%u result=%u", cmdType_, result);
179 1 : hwts_response_t hwtsResp = {};
180 1 : hwtsResp.result = static_cast<uint32_t>(result);
181 1 : hwtsResp.status =
182 1 : (result == AICPU_SCHEDULE_OK) ? static_cast<uint32_t>(TASK_SUCC) : static_cast<uint32_t>(TASK_FAIL);
183 1 : hwtsResp.msg = PtrToPtr<TsAicpuSqe, char_t>(&aicpuSqe);
184 1 : hwtsResp.len = static_cast<int32_t>(sizeof(TsAicpuSqe));
185 2 : return ResponseToTs(hwtsResp, AicpuDrvManager::GetInstance().GetDeviceId(), EVENT_TS_CTRL_MSG, subEvent);
186 : }
187 :
188 0 : void TsAicpuSqeAdapter::AicpuActiveStreamSetMsg(ActiveStreamInfo& info)
189 : {
190 0 : TsAicpuSqe aicpuSqe = {};
191 0 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
192 0 : aicpuSqe.cmd_type = AICPU_ACTIVE_STREAM;
193 0 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
194 0 : aicpuSqe.tid = 0U; // no need tid
195 0 : aicpuSqe.ts_id = info.ts_id;
196 0 : aicpuSqe.u.aicpu_active_stream.stream_id = info.stream_id;
197 0 : aicpuSqe.u.aicpu_active_stream.aicpu_stamp = info.aicpu_stamp;
198 0 : aicpusd_info("Active stream update: message_type=%u stream=%u stamp=%u.",
199 : aicpuSqe.cmd_type,
200 : aicpuSqe.u.aicpu_active_stream.stream_id,
201 : aicpuSqe.u.aicpu_active_stream.aicpu_stamp);
202 0 : AicpuMsgSend::SetTsDevSendMsgAsync(info.device_id, static_cast<uint32_t>(info.ts_id), aicpuSqe, info.handle_id);
203 0 : }
204 :
205 1 : void TsAicpuSqeAdapter::GetAicpuMsgVersionInfo(AicpuMsgVersionInfo& info)
206 : {
207 1 : TsAicpuMsgVersion tmpInfo = aicpuSqe_.u.aicpu_msg_version;
208 1 : aicpusd_info("Version request: magic=%u version=%hu.", tmpInfo.magic_num, tmpInfo.version);
209 1 : info.magic_num = tmpInfo.magic_num;
210 1 : info.version = tmpInfo.version;
211 1 : }
212 :
213 1 : int32_t TsAicpuSqeAdapter::AicpuMsgVersionResponseToTs(const int32_t result)
214 : {
215 1 : TsAicpuMsgInfo msgInfo{};
216 1 : msgInfo.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
217 1 : msgInfo.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
218 1 : msgInfo.tid = tid_;
219 1 : msgInfo.ts_id = tsId_;
220 1 : msgInfo.cmd_type = cmdType_;
221 1 : msgInfo.u.aicpu_resp.result_code = static_cast<uint16_t>(result);
222 1 : msgInfo.u.aicpu_resp.task_id = INVALID_VALUE32;
223 1 : aicpusd_info("Version response: message_type=%u result=%u stream=%u task=%u.",
224 : msgInfo.cmd_type,
225 : msgInfo.u.aicpu_resp.result_code,
226 : msgInfo.u.aicpu_resp.stream_id,
227 : msgInfo.u.aicpu_resp.task_id);
228 2 : return ResponseToTs(msgInfo, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(msgInfo.ts_id));
229 : }
230 :
231 1 : void TsAicpuSqeAdapter::GetAicpuTaskReportInfo(AicpuTaskReportInfo& info)
232 : {
233 1 : TsToAicpuTaskReport tmpInfo = aicpuSqe_.u.ts_to_aicpu_task_report;
234 1 : aicpusd_info("Task report request: task=%u model=%u result=%u stream=%u",
235 : tmpInfo.task_id,
236 : tmpInfo.model_id,
237 : tmpInfo.result_code,
238 : tmpInfo.stream_id);
239 1 : info.task_id = tmpInfo.task_id;
240 1 : info.model_id = tmpInfo.model_id;
241 1 : info.stream_id = tmpInfo.stream_id;
242 1 : info.result_code = tmpInfo.result_code;
243 1 : }
244 1 : int32_t TsAicpuSqeAdapter::ErrorMsgResponseToTs(ErrMsgRspInfo& rspInfo)
245 : {
246 1 : TsAicpuSqe aicpuSqe{};
247 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
248 1 : aicpuSqe.cmd_type = AICPU_ERR_MSG_REPORT;
249 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
250 1 : aicpuSqe.tid = 0U; // no need tid
251 1 : aicpuSqe.ts_id = static_cast<uint8_t>(rspInfo.ts_id);
252 1 : aicpuSqe.u.aicpu_err_msg_report.result_code = rspInfo.err_code;
253 1 : aicpuSqe.u.aicpu_err_msg_report.stream_id = static_cast<uint16_t>(rspInfo.stream_id);
254 1 : aicpuSqe.u.aicpu_err_msg_report.task_id = static_cast<uint16_t>(rspInfo.task_id);
255 1 : aicpuSqe.u.aicpu_err_msg_report.offset = static_cast<uint16_t>(rspInfo.offset);
256 1 : aicpusd_info("Error response: message_type=%u result=%u response_stream=%u response_task=%u",
257 : aicpuSqe.cmd_type,
258 : rspInfo.err_code,
259 : rspInfo.stream_id,
260 : rspInfo.task_id);
261 2 : return ResponseToTs(aicpuSqe, rspInfo.model_id, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
262 : }
263 :
264 0 : int32_t TsAicpuSqeAdapter::AicpuNoticeTsPidResponse(const uint32_t deviceId) const
265 : {
266 0 : TsAicpuSqe aicpuSqe = {};
267 0 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid()); // host pid
268 0 : aicpuSqe.cmd_type = AICPU_NOTICE_TS_PID;
269 0 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
270 0 : aicpusd_info("Notice TS pid response: device_id=%u pid=%u vf=%u.", deviceId, aicpuSqe.pid, aicpuSqe.vf_id);
271 0 : return ResponseToTs(aicpuSqe, 0U, deviceId, 0U);
272 : }
273 :
274 1 : void TsAicpuSqeAdapter::GetAicpuTimeOutConfigInfo(AicpuTimeOutConfigInfo& info)
275 : {
276 1 : aicpusd_info("Get timeout config.");
277 1 : info.i = aicpuSqe_.u.ts_to_aicpu_timeout_cfg;
278 1 : return;
279 : }
280 :
281 1 : int32_t TsAicpuSqeAdapter::AicpuTimeOutConfigResponseToTs(const int32_t result)
282 : {
283 1 : TsAicpuSqe aicpuSqe{};
284 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
285 1 : aicpuSqe.cmd_type = AICPU_TIMEOUT_CONFIG_RESPONSE;
286 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
287 1 : aicpuSqe.tid = tid_;
288 1 : aicpuSqe.ts_id = tsId_;
289 1 : aicpuSqe.u.aicpu_timeout_cfg_resp.result = result;
290 1 : aicpusd_info("Timeout config response: message_type=%u result=%u.", aicpuSqe.cmd_type, result);
291 2 : return ResponseToTs(aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), aicpuSqe.ts_id);
292 : }
293 :
294 1 : void TsAicpuSqeAdapter::GetAicpuInfoLoad(AicpuInfoLoad& info)
295 : {
296 1 : TsToAicpuInfoLoad tmpinfo = aicpuSqe_.u.ts_to_aicpu_info;
297 1 : aicpusd_info("Info load request: address=%p length=%u stream=%u task=%u",
298 : tmpinfo.aicpuInfoPtr,
299 : tmpinfo.length,
300 : tmpinfo.stream_id,
301 : tmpinfo.task_id);
302 1 : info.aicpuInfoPtr = tmpinfo.aicpuInfoPtr;
303 1 : info.length = tmpinfo.length;
304 1 : info.stream_id = tmpinfo.stream_id;
305 1 : info.task_id = tmpinfo.task_id;
306 1 : }
307 :
308 1 : int32_t TsAicpuSqeAdapter::AicpuInfoLoadResponseToTs(const int32_t result)
309 : {
310 1 : TsAicpuSqe aicpuSqe{};
311 1 : TsToAicpuInfoLoad tmpInfo = aicpuSqe_.u.ts_to_aicpu_info;
312 1 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
313 1 : aicpuSqe.tid = tid_;
314 1 : aicpuSqe.ts_id = tsId_;
315 1 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
316 1 : aicpuSqe.cmd_type = AICPU_INFO_LOAD_RESPONSE;
317 1 : aicpuSqe.u.aicpu_resp.cmd_type = AICPU_INFO_LOAD;
318 1 : aicpuSqe.u.aicpu_resp.task_id = tmpInfo.task_id;
319 1 : aicpuSqe.u.aicpu_resp.result_code = static_cast<uint16_t>(result);
320 1 : aicpuSqe.u.aicpu_resp.stream_id = tmpInfo.stream_id;
321 1 : aicpusd_info("Info load response: message_type=%u result=%u stream=%u task=%u.",
322 : aicpuSqe.cmd_type,
323 : result,
324 : tmpInfo.stream_id,
325 : tmpInfo.task_id);
326 2 : return ResponseToTs(aicpuSqe, 0U, AicpuDrvManager::GetInstance().GetDeviceId(), static_cast<uint32_t>(aicpuSqe.ts_id));
327 : }
328 :
329 1 : void TsAicpuSqeAdapter::GetAicErrReportInfo(AicErrReportInfo& info)
330 : {
331 1 : aicpusd_info("Get AIC error report info.");
332 1 : info.u.aicError = aicpuSqe_.u.ts_to_aicpu_aic_err_report;
333 1 : return;
334 : }
335 :
336 2 : int32_t TsAicpuSqeAdapter::AicpuRecordResponseToTs(AicpuRecordInfo& info)
337 : {
338 : TsAicpuSqe aicpuSqe;
339 2 : aicpuSqe.pid = static_cast<uint32_t>(AicpuDrvManager::GetInstance().GetHostPid());
340 2 : aicpuSqe.cmd_type = AICPU_RECORD;
341 2 : aicpuSqe.vf_id = static_cast<uint8_t>(AicpuDrvManager::GetInstance().GetVfId());
342 2 : aicpuSqe.tid = 0U; // notify is no need tid
343 2 : aicpuSqe.ts_id = info.ts_id;
344 2 : aicpuSqe.u.aicpu_record.record_type = info.record_type;
345 2 : aicpuSqe.u.aicpu_record.record_id = info.record_id;
346 2 : aicpuSqe.u.aicpu_record.fault_task_id = info.fault_task_id;
347 2 : aicpuSqe.u.aicpu_record.fault_stream_id = info.fault_stream_id;
348 2 : aicpuSqe.u.aicpu_record.ret_code = info.ret_code;
349 2 : const bool retSucc = info.ret_code == 0U ? true : false;
350 2 : aicpusd_info("Record response: pid=%u message_type=%u vf=%u tid=%u ts=%u record_type=%u "
351 : "record_id=%u fault_task=%u fault_stream=%u result=%u",
352 : aicpuSqe.pid,
353 : aicpuSqe.cmd_type,
354 : aicpuSqe.vf_id,
355 : aicpuSqe.tid,
356 : aicpuSqe.ts_id,
357 : aicpuSqe.u.aicpu_record.record_type,
358 : aicpuSqe.u.aicpu_record.record_id,
359 : aicpuSqe.u.aicpu_record.fault_task_id,
360 : aicpuSqe.u.aicpu_record.fault_stream_id,
361 : aicpuSqe.u.aicpu_record.ret_code);
362 2 : if (!retSucc) {
363 1 : return ResponseToTs(aicpuSqe, 0U, info.dev_id, static_cast<uint32_t>(info.ts_id));
364 : }
365 1 : aicpusd_info("Record response: path=halTsDevRecord.");
366 1 : int32_t ret = halTsDevRecord(info.dev_id, static_cast<uint32_t>(info.ts_id), static_cast<uint32_t>(info.record_type), info.record_id);
367 1 : if (static_cast<uint32_t>(ret) != static_cast<uint32_t>(DRV_ERROR_NONE)) {
368 0 : aicpusd_err(
369 : "Record notify failed: send_ret=%d notify_id=%u response_result=%d.", ret, info.record_id, info.ret_code);
370 0 : return AICPU_SCHEDULE_ERROR_FROM_DRV;
371 : }
372 1 : return AICPU_SCHEDULE_OK;
373 : }
374 : } // namespace AicpuSchedule
|
