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 <chrono>
11 : #include <unordered_map>
12 : #include "rtsq_a5.h"
13 : #include "log.h"
14 : #include "exception_util.h"
15 : #include "internal_exception.h"
16 : #include "sqe_build_a5.h"
17 : #include "sqe.h"
18 : #ifdef CCL_KERNEL_AICPU
19 : #include "aicpu_ts_primitives_c_adpt.h"
20 : #endif
21 :
22 : namespace Hccl {
23 : using namespace std;
24 : constexpr u32 RTSQ_A5_PART_ID = 0;
25 : constexpr u32 PRINT_INTERVAL = 30;
26 :
27 169 : RtsqA5::RtsqA5(u32 devPhyId, u32 streamId, u32 sqId) : RtsqBase(devPhyId, streamId, sqId)
28 : {
29 169 : SetTaskIdBySqeId();
30 169 : }
31 :
32 0 : RtsqA5::RtsqA5(u32 devPhyId, u32 streamId, u32 sqId, bool launchFlag) : RtsqBase(devPhyId, streamId, sqId)
33 : {
34 0 : SetTaskIdBySqeId();
35 0 : launchFlag_ = launchFlag;
36 0 : }
37 :
38 1 : void RtsqA5::Reset()
39 : {
40 1 : RtsqBase::Reset();
41 1 : pendingSqeCnt = 0;
42 1 : s32 sRet = memset_s(locBuf, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT, 0, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT);
43 1 : if (UNLIKELY(sRet != EOK)) {
44 0 : auto msg = StringFormat("[RtsqA5][Reset] locBuf memset fail. errorno[%d]", sRet);
45 0 : THROW<InternalException>(msg);
46 0 : }
47 3 : HCCL_INFO("[NsRecovery]RtsqA5::%s success", __func__);
48 1 : }
49 :
50 : // 计算head和tail之间的距离
51 6 : u32 RtsqA5::GetTailToHeadDist() const
52 : {
53 6 : if (UNLIKELY(sqHead_ == sqTail_)) { // 头尾相同，则距离大小为sq深度
54 4 : return sqDepth_;
55 : }
56 2 : return (sqTail_ < sqHead_) ? (sqHead_ - sqTail_) : (sqDepth_ - (sqTail_ - sqHead_));
57 : }
58 :
59 2 : void RtsqA5::MakeSureAvailableSpace()
60 : {
61 2 : u32 availableSpace = GetTailToHeadDist();
62 2 : auto startTime = std::chrono::steady_clock::now();
63 : #ifdef CCL_KERNEL_AICPU
64 : sqFullTimeout_ = GetSqFullTimeOut();
65 : #endif
66 2 : const std::chrono::seconds printInterval(PRINT_INTERVAL); // 打印间隔30s
67 2 : auto lastPrintTime = std::chrono::steady_clock::now() - printInterval;
68 6 : HCCL_INFO("[%s]sqId:%u, sqFullTimeout_: %u s, sqHead:%u, sqTail:%u, pendingSqeCnt:%u",
69 : __func__, sqId_, sqFullTimeout_, sqHead_, sqTail_, pendingSqeCnt);
70 :
71 2 : while (availableSpace <= pendingSqeCnt) {
72 0 : sqHead_ = QuerySqHead();
73 0 : availableSpace = GetTailToHeadDist();
74 0 : if (availableSpace > pendingSqeCnt) {
75 0 : break; // 避免head没更新导致假反压
76 : }
77 :
78 0 : auto curTime = std::chrono::steady_clock::now();
79 0 : if (UNLIKELY(curTime - lastPrintTime >= printInterval)) {
80 0 : HCCL_RUN_INFO("[%s]while loop, sqId:%u, sqHead:%u, sqTail:%u, availableSpace:%u, pendingSqeCnt:%u, "
81 : "sqFullTimeout_:%u s", __func__, sqId_, sqHead_, sqTail_, availableSpace, pendingSqeCnt, sqFullTimeout_);
82 0 : lastPrintTime = curTime;
83 : }
84 :
85 0 : CheckLaunchTaskStatus(startTime, curTime);
86 : #ifdef CCL_KERNEL_AICPU
87 : HcclResult ret = HandleDispatchAllStreams();
88 : if (UNLIKELY(ret != HCCL_SUCCESS)) {
89 : auto msg = StringFormat("RtsqA5::%s HandleDispatchAllStreams failed, ret = %d, sqId:%u, ", __func__, ret, sqId_);
90 : HCCL_ERROR("%s", msg.c_str());
91 : THROW<InternalException>(msg);
92 : }
93 : #endif
94 0 : if (checkOpExecStatusCallback_ != nullptr) {
95 0 : checkOpExecStatusCallback_();
96 : }
97 : }
98 2 : }
99 :
100 5 : void RtsqA5::CheckLaunchTaskStatus(const std::chrono::steady_clock::time_point &startTime,
101 : const std::chrono::steady_clock::time_point &curTime)
102 : {
103 5 : bool isTimeout = (sqFullTimeout_ == 0) ? false : ((curTime - startTime) >= std::chrono::seconds(sqFullTimeout_));
104 : // step1 检测是否launch超时，如果超时打印rtsq full的ERROR日志
105 5 : if (UNLIKELY(isTimeout)) {
106 6 : HCCL_ERROR("Rtsq full, sqFullTimeout_:%u. sqId:%u, sqHead:%u, sqTail:%u, pendingSqeCnt:%u",
107 : sqFullTimeout_, sqId_, sqHead_, sqTail_, pendingSqeCnt);
108 : }
109 :
110 5 : HcclResult checkRet = (checkExecStatusCallback_ != nullptr) ? checkExecStatusCallback_(isTimeout) : HCCL_SUCCESS;
111 : // step2 通信域状态为HCCL_COMM_STATUS_SUSPENDING状态，则终止launch不抛异
112 5 : if (UNLIKELY(checkRet == HCCL_E_SUSPENDING)) {
113 3 : pendingSqeCnt = 0;
114 3 : return;
115 : }
116 : // step3 调用回调检查执行状态：1、如果超时，打印taskException；2、如果通信域不可用，终止launch
117 2 : if (UNLIKELY(isTimeout || checkRet != HCCL_SUCCESS)) {
118 2 : THROW<InternalException>(StringFormat("[%s]stop launch Task, isTimeout[%d], checkRet[%d]",
119 : __func__, isTimeout, checkRet));
120 : }
121 : }
122 :
123 6 : void RtsqA5::CopyLocBufToSq()
124 : {
125 6 : u8 *sqCurrAddr = reinterpret_cast<u8 *>(sqBaseAddr_) + sqTail_ * RTSQ_SQE_SIZE;
126 6 : if (sqTail_ >= sqHead_) {
127 5 : u32 depthLeft = sqDepth_ - sqTail_;
128 5 : if (pendingSqeCnt <= depthLeft) { // 没有回绕
129 9 : HCCL_INFO("RtsqA5::%s copy sqe from sqe buffer, sqId_: %u, streamId_: %u, cur head: %u, cur tail: %u, size: %u, depth remain: %u",
130 : __func__, sqId_, streamId_, sqHead_, sqTail_, pendingSqeCnt, depthLeft);
131 3 : int ret = memcpy_sp(sqCurrAddr, pendingSqeCnt * AC_SQE_SIZE, locBuf, pendingSqeCnt * RTSQ_SQE_SIZE);
132 3 : if (UNLIKELY(ret != 0)) {
133 4 : THROW<InternalException>(StringFormat("RtsqA5::%s sqe memcpy_sp failed, ret = %d", __func__, ret));
134 : }
135 : } else {
136 6 : HCCL_INFO("RtsqA5::%s copy sqe twice, sqId_: %u, streamId_: %u, cur head: %u, cur tail: %u, cnt: %u, depth remain: %u",
137 : __func__, sqId_, streamId_, sqHead_, sqTail_, pendingSqeCnt, depthLeft);
138 : // 先拷贝rtsq里剩余空间大小
139 2 : int ret = memcpy_sp(sqCurrAddr, depthLeft * AC_SQE_SIZE, locBuf, depthLeft * RTSQ_SQE_SIZE);
140 2 : if (ret != 0) {
141 1 : THROW<InternalException>(
142 3 : StringFormat("RtsqA5::%s rtsq remaining space memcpy_sp failed, ret = %d", __func__, ret));
143 : }
144 : // 拷贝剩余sqe
145 1 : ret = memcpy_sp(reinterpret_cast<u8 *>(sqBaseAddr_), sqHead_ * RTSQ_SQE_SIZE, locBuf + depthLeft * RTSQ_SQE_SIZE,
146 : (pendingSqeCnt - depthLeft) * AC_SQE_SIZE);
147 1 : if (UNLIKELY(ret != 0)) {
148 0 : THROW<InternalException>(
149 0 : StringFormat("RtsqA5::%s remaining sqe memcpy_sp failed, ret = %d", __func__, ret));
150 : }
151 : }
152 : } else {
153 3 : HCCL_INFO("RtsqA5::%s copy sqe from sqe buffer, tail < head, sqId_: %u, streamId_: %u, cur head: %u, cur tail: %u, size: %u",
154 : __func__, sqId_, streamId_, sqHead_, sqTail_, pendingSqeCnt);
155 1 : int ret = memcpy_sp(sqCurrAddr, pendingSqeCnt * AC_SQE_SIZE, locBuf, pendingSqeCnt * RTSQ_SQE_SIZE);
156 1 : if (UNLIKELY(ret != 0)) {
157 0 : THROW<InternalException>(StringFormat("RtsqA5::%s sqe memcpy_sp failed, ret = %d", __func__, ret));
158 : }
159 : }
160 3 : }
161 :
162 : // 向芯片RTSQ VA中写入 SQE，并触发芯片执行
163 4 : void RtsqA5::LaunchTask()
164 : {
165 12 : HCCL_INFO("RtsqA5::%s: START, pendingSqeCnt[%u]", __func__, pendingSqeCnt);
166 :
167 4 : if (pendingSqeCnt == 0) { // 没有SQE ，直接返回
168 6 : HCCL_INFO("RtsqA5::%s: pendingSqeCnt is %u, return", __func__, pendingSqeCnt);
169 2 : return;
170 : }
171 : // 确保 rtsq 有足够空间放pending SQE
172 2 : MakeSureAvailableSpace();
173 :
174 2 : if (pendingSqeCnt == 0) {
175 0 : return;
176 : }
177 : // localBuffer拷贝到 RTSQ
178 2 : CopyLocBufToSq();
179 :
180 : // 更新tail，触发芯片执行
181 2 : u32 newTail = (sqTail_ + pendingSqeCnt) % sqDepth_;
182 2 : ConfigSqTail(newTail);
183 2 : sqTail_ = newTail;
184 :
185 : // 清空本地的locBuffer和sqeCnt数目
186 6 : HCCL_INFO("RtsqA5::%s: END, pendingSqeCnt[%u], sqHead_[%u] sqTail_[%u]", __func__, pendingSqeCnt, sqHead_, sqTail_);
187 2 : pendingSqeCnt = 0;
188 2 : (void)memset_s(locBuf, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT, 0, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT); // locBuffer清零
189 : }
190 :
191 2 : void RtsqA5::TryLaunchTask()
192 : {
193 2 : if (pendingSqeCnt == 0) {
194 1 : return;
195 : }
196 :
197 1 : sqHead_ = QuerySqHead();
198 1 : u32 availableSpace = GetTailToHeadDist();
199 1 : if (availableSpace <= pendingSqeCnt) {
200 0 : return;
201 : }
202 :
203 1 : CopyLocBufToSq();
204 :
205 1 : u32 newTail = (sqTail_ + pendingSqeCnt) % sqDepth_;
206 1 : ConfigSqTail(newTail);
207 1 : sqTail_ = newTail;
208 :
209 1 : pendingSqeCnt = 0;
210 1 : (void)memset_s(locBuf, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT, 0, RTSQ_SQE_SIZE * PER_LAUNCH_SQE_CNT);
211 3 : HCCL_INFO("RtsqA5::%s: END, pendingSqeCnt[%u], sqHead_[%u] sqTail_[%u]", __func__, pendingSqeCnt, sqHead_, sqTail_);
212 : }
213 :
214 33 : u8 *RtsqA5::GetCurrSqeBuffer()
215 : {
216 33 : return locBuf + pendingSqeCnt * RTSQ_SQE_SIZE;
217 : }
218 :
219 30 : void RtsqA5::RefreshInfo()
220 : {
221 30 : SetTaskIdBySqeId();
222 30 : pendingSqeCnt++;
223 :
224 : #ifdef CCL_KERNEL_AICPU
225 : if (launchFlag_ && !IsBatchLaunchMode()) {
226 : LaunchTask();
227 : return;
228 : }
229 : #endif
230 :
231 30 : if (pendingSqeCnt != PER_LAUNCH_SQE_CNT) {
232 30 : return;
233 : }
234 : // 挂起的sqe数量为128个，则需要向芯片RTSQ中写入task
235 0 : LaunchTask();
236 : }
237 :
238 1 : void RtsqA5::NotifyWait(u32 notifyId)
239 : {
240 1 : NotifyWait(notifyId, GetKernelExecTimeoutFromEnvConfig());
241 1 : }
242 :
243 10 : void RtsqA5::NotifyWait(u32 notifyId, u32 timeout)
244 : {
245 10 : BuildA5SqeNotifyWait(streamId_, taskId_, notifyId, timeout, GetCurrSqeBuffer());
246 30 : HCCL_INFO("RtsqA5::NotifyWait: streamId %u, taskId %u, notifyId %u, timeout %u", streamId_, taskId_, notifyId, timeout);
247 10 : RefreshInfo();
248 10 : }
249 :
250 1 : void RtsqA5::NotifyRecordLoc(u32 notifyId)
251 : {
252 1 : BuildA5SqeNotifyRecord(streamId_, taskId_, notifyId, GetCurrSqeBuffer());
253 3 : HCCL_INFO("RtsqA5::NotifyRecordLoc: streamId %u, taskId %u, notifyId %u", streamId_, taskId_, notifyId);
254 1 : RefreshInfo();
255 1 : }
256 :
257 1 : void RtsqA5::Cnt1toNNotifyWait(u32 notifyId, u32 value)
258 : {
259 1 : BuildA5SqeCnt1toNNotifyWait(streamId_, taskId_, notifyId, value, GetCurrSqeBuffer());
260 3 : HCCL_INFO("RtsqA5::Cnt1toNNotifyWait: streamId %u, taskId %u, notifyId %u", streamId_, taskId_, notifyId);
261 1 : RefreshInfo();
262 1 : }
263 :
264 1 : void RtsqA5::Cnt1toNNotifyRecord(u32 notifyId, u32 value)
265 : {
266 1 : BuildA5SqeCnt1toNNotifyRecord(streamId_, taskId_, notifyId, value, GetCurrSqeBuffer());
267 3 : HCCL_INFO("RtsqA5::Cnt1toNNotifyWait: streamId %u, taskId %u, notifyId %u", streamId_, taskId_, notifyId);
268 1 : RefreshInfo();
269 1 : }
270 :
271 1 : void RtsqA5::CntNto1NotifyWait(u32 notifyId, u32 value)
272 : {
273 1 : BuildA5SqeCntNto1NotifyWait(streamId_, taskId_, notifyId, value, GetCurrSqeBuffer());
274 3 : HCCL_INFO("RtsqA5::CntNto1NotifyWait: streamId %u, taskId %u, notifyId %u", streamId_, taskId_, notifyId);
275 1 : RefreshInfo();
276 1 : }
277 :
278 1 : void RtsqA5::CntNto1NotifyRecord(u32 notifyId, u32 value)
279 : {
280 1 : BuildA5SqeCntNto1NotifyRecord(streamId_, taskId_, notifyId, value, GetCurrSqeBuffer());
281 3 : HCCL_INFO("RtsqA5::CntNto1NotifyRecord: streamId %u, taskId %u, notifyId %u", streamId_, taskId_, notifyId);
282 1 : RefreshInfo();
283 1 : }
284 :
285 1 : void RtsqA5::SdmaCopy(u64 srcAddr, u64 dstAddr, u32 size, u32 partId)
286 : {
287 : // 不带reduce的拷贝，opcode填0
288 : (void)partId;
289 1 : BuildA5SqeSdmaCopy(streamId_, taskId_, dstAddr, srcAddr, size, RTSQ_A5_PART_ID, 0, GetCurrSqeBuffer());
290 3 : HCCL_INFO("RtsqA5::SdmaCopy: streamId %u, taskId %u, srcAddr 0x%llx, dstAddr 0x%llx, size %u", streamId_, taskId_,
291 : srcAddr, dstAddr, size);
292 1 : RefreshInfo();
293 1 : }
294 :
295 : const std::unordered_map<ReduceOp, RtStarsMemcpyAsyncOperationKind, EnumClassHash> ReduceOpToStarsOpKindMap
296 : = {{ReduceOp::SUM, RtStarsMemcpyAsyncOperationKind::RT_STARS_MEMCPY_ASYNC_OP_KIND_ADD},
297 : {ReduceOp::MAX, RtStarsMemcpyAsyncOperationKind::RT_STARS_MEMCPY_ASYNC_OP_KIND_MAX},
298 : {ReduceOp::MIN, RtStarsMemcpyAsyncOperationKind::RT_STARS_MEMCPY_ASYNC_OP_KIND_MIN},
299 : {ReduceOp::EQUAL, RtStarsMemcpyAsyncOperationKind::RT_STARS_MEMCPY_ASYNC_OP_KIND_EQUAL}};
300 :
301 : const std::unordered_map<DataType, RtStarsMemcpyAsyncDataType, EnumClassHash> DataTypeToStarsDataTypeMap
302 : = {{DataType::INT8, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_INT8},
303 : {DataType::INT16, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_INT16},
304 : {DataType::INT32, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_INT32},
305 : {DataType::FP16, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_FP16},
306 : {DataType::FP32, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_FP32},
307 : {DataType::BFP16, RtStarsMemcpyAsyncDataType::RT_STARS_MEMCPY_ASYNC_DATA_TYPE_BFP16}};
308 :
309 3 : void RtsqA5::SdmaReduce(u64 srcAddr, u64 dstAddr, u32 size, u32 partId, const ReduceIn &reduceIn)
310 : {
311 : (void)partId;
312 3 : if (UNLIKELY(ReduceOpToStarsOpKindMap.find(reduceIn.reduceOp) == ReduceOpToStarsOpKindMap.end()
313 : || DataTypeToStarsDataTypeMap.find(reduceIn.dataType) == DataTypeToStarsDataTypeMap.end())) {
314 3 : THROW<InternalException>(StringFormat("Sdma does not support reduceOp %s dataType %s",
315 3 : reduceIn.reduceOp.Describe().c_str(),
316 3 : reduceIn.dataType.Describe().c_str()));
317 : }
318 :
319 2 : u8 op = static_cast<u8>(ReduceOpToStarsOpKindMap.at(reduceIn.reduceOp));
320 2 : u8 type = static_cast<u8>(DataTypeToStarsDataTypeMap.at(reduceIn.dataType));
321 :
322 2 : BuildA5SqeSdmaCopy(streamId_, taskId_, dstAddr, srcAddr, size, RTSQ_A5_PART_ID, (op | type), GetCurrSqeBuffer());
323 6 : HCCL_INFO("RtsqA5::SdmaReduce: streamId %u, taskId %u, srcAddr 0x%llx, dstAddr 0x%llx, size %u", streamId_, taskId_,
324 : srcAddr, dstAddr, size);
325 2 : RefreshInfo();
326 2 : }
327 :
328 2 : bool RtsqA5::IsRtsqQueueSpaceSufficient()
329 : {
330 : // 判断逻辑与rtsq内部保持一致，rtsq剩余空间需要大于（rtsq挂起的任务数量+本次任务）
331 2 : u32 availableSpace = GetTailToHeadDist();
332 2 : if (availableSpace > pendingSqeCnt + 1) {
333 1 : return true;
334 : }
335 :
336 : // 否则的话，需要再次查询一次head，确认是否是因为head没有更新导致空间不足，如果查询后空间仍然不足，则返回false
337 1 : sqHead_ = QuerySqHead();
338 1 : availableSpace = GetTailToHeadDist();
339 :
340 1 : return (availableSpace > pendingSqeCnt + 1);
341 : }
342 :
343 3 : HcclResult RtsqA5::SetPreStreamSyncReady()
344 : {
345 3 : isPreStreamSync = true;
346 3 : return HCCL_SUCCESS;
347 : }
348 :
349 4 : HcclResult RtsqA5::SetPreStreamSyncFin()
350 : {
351 4 : isPreStreamSync = false;
352 4 : return HCCL_SUCCESS;
353 : }
354 :
355 89 : bool RtsqA5::GetPreStreamSyncStatus()
356 : {
357 89 : return isPreStreamSync;
358 : }
359 :
360 1 : void RtsqA5::UbDbSend(const UbJettyLiteId &jettyLiteId, u16 piValue)
361 : {
362 : // piValue需要使用u16数据类型，保证自然增长，用于判断是否翻转
363 1 : BuildA5SqeUbDbSend(streamId_, taskId_, jettyLiteId, piValue, GetCurrSqeBuffer());
364 3 : HCCL_INFO("RtsqA5::UbDbSend: piValue(UbPi):%u, SqTail(Rtsq Pi):%u", piValue, sqTail_);
365 1 : RefreshInfo();
366 1 : }
367 :
368 6 : void RtsqA5::RdmaDbSend(const uint64_t &dbAddr, const uint64_t &dbValue)
369 : {
370 6 : BuildA5SqeRdmaDbSend(streamId_, taskId_, dbAddr, dbValue, GetCurrSqeBuffer());
371 18 : HCCL_INFO("RtsqA5::RdmaDbSend: RdmaDbSend Sqe: %s, dbAddr:0x%llx, dbValue:0x%llx, SqTail(Rtsq Pi):%u",
372 : Bytes2hex(GetCurrSqeBuffer(), RTSQ_SQE_SIZE).c_str(), dbAddr, dbValue, sqTail_);
373 6 : RefreshInfo();
374 6 : }
375 :
376 1 : void RtsqA5::CCoreNotifyWait(u64 waitAddr, u64 curTurnCntAddr, bool last)
377 : {
378 1 : BuildA5SqeCCoreNotifyWait(streamId_, taskId_, waitAddr, curTurnCntAddr, last, GetCurrSqeBuffer());
379 3 : HCCL_INFO("RtsqA5::CCoreNotifyWait: streamId %u, taskId %u, waitAddr %llu, curTurnCntAddr %llu, last %d", streamId_,
380 : taskId_, waitAddr, curTurnCntAddr, last);
381 1 : RefreshInfo();
382 1 : }
383 :
384 1 : void RtsqA5::CCoreNotifyRecord(u64 recordAddr, u64 curTurnCntAddr)
385 : {
386 1 : BuildA5SqeCCoreNotifyRecord(streamId_, taskId_, recordAddr, curTurnCntAddr, GetCurrSqeBuffer());
387 3 : HCCL_INFO("RtsqA5::CCoreNotifyRecord: streamId %u, taskId %u, recordAddr %llu, curTurnCntAddr %llu", streamId_, taskId_,
388 : recordAddr, curTurnCntAddr);
389 1 : RefreshInfo();
390 1 : }
391 :
392 0 : void RtsqA5::P2PWriteValue(u64 remoteAddr, u32 writeValue)
393 : {
394 0 : BuildA5SqeP2pWriteValue(streamId_, taskId_, remoteAddr, writeValue, GetCurrSqeBuffer());
395 0 : HCCL_INFO("RtsqA5::P2PWriteValue: streamId %u, taskId %u, remoteAddr %llu, writeValue %llu",
396 : streamId_, taskId_, remoteAddr, writeValue);
397 0 : RefreshInfo();
398 0 : }
399 : }
|
