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 :
11 : #include "ccu_urma_channel.h"
12 :
13 : #include "hcomm_c_adpt.h"
14 :
15 : #include "orion_adpt_utils.h"
16 :
17 : #include "exception_handler.h"
18 : #include "comm_mems.h"
19 :
20 : #include "config_log.h"
21 :
22 : // 暂时引入orion
23 : #include "local_ub_rma_buffer.h"
24 :
25 : namespace hcomm {
26 :
27 60 : CcuUrmaChannel::CcuUrmaChannel(const EndpointHandle locEndpointHandle, const HcommChannelDesc& channelDesc)
28 60 : : locEndpointHandle_(locEndpointHandle),
29 60 : channelDesc_(channelDesc)
30 60 : {}
31 :
32 84 : CcuUrmaChannel::~CcuUrmaChannel()
33 : {
34 : // 先释放 transport/connection（CKE/XN、TP、远端 jetty QP unimport），
35 : // 再向 endpoint 的 CcuChannelCtxPool 归还 channel ctx / jetty ctx / wqeBB。
36 : // 顺序必须如此：CcuConnection 持有 batch 内 CcuJetty 裸指针。
37 60 : impl_.reset();
38 60 : if (ccuEndpoint_ != nullptr) {
39 25 : Hccl::LinkData linkData = BuildDefaultLinkData();
40 : HcclResult keyRet
41 25 : = EndpointDescPairToLinkData(ccuEndpoint_->GetEndpointDesc(), channelDesc_.remoteEndpoint, linkData);
42 25 : if (keyRet != HCCL_SUCCESS) {
43 0 : HCCL_ERROR("[CcuUrmaChannel][%s] failed to build link data for release, ret[%d].", __func__, keyRet);
44 0 : return;
45 : }
46 25 : auto* pool = ccuEndpoint_->GetCcuChannelCtxPool();
47 25 : if (pool != nullptr) {
48 15 : HcclResult releaseRet = pool->ReleaseChannel(linkData);
49 15 : if (releaseRet != HCCL_SUCCESS) {
50 0 : HCCL_WARNING("[CcuUrmaChannel][%s] release channel to pool failed, ret[%d].", __func__, releaseRet);
51 : }
52 : }
53 : }
54 84 : }
55 :
56 16 : HcclResult BuildBufferInfos(
57 : HcommMemHandle* memHandles, uint32_t memHandleNum, std::vector<CcuTransport::CclBufferInfo>& bufferInfos)
58 : {
59 32 : for (uint32_t i = 0; i < memHandleNum; ++i) {
60 16 : auto localRmaBuffer = reinterpret_cast<Hccl::LocalUbRmaBuffer*>(memHandles[i]);
61 16 : CHK_PTR_NULL(localRmaBuffer);
62 16 : auto buf = localRmaBuffer->GetBuf();
63 16 : CHK_PTR_NULL(buf);
64 16 : HCCL_INFO("[BuildBufferInfos] localRmaBuffer[%s]", localRmaBuffer->Describe().c_str());
65 :
66 16 : std::array<char, HCCL_RES_TAG_MAX_LEN> memInfo{};
67 16 : std::string tag = buf->GetMemInfo();
68 16 : if (UNLIKELY(tag.size() >= HCCL_RES_TAG_MAX_LEN)) {
69 0 : HCCL_ERROR("[BuildBufferInfos] tagSize exceeds limit[%u]", HCCL_RES_TAG_MAX_LEN);
70 0 : return HCCL_E_PARA;
71 : }
72 48 : CHK_SAFETY_FUNC_RET(memcpy_s(memInfo.data(), memInfo.size(), tag.c_str(), tag.size()));
73 16 : bufferInfos.emplace_back(
74 16 : localRmaBuffer->GetAddr(), static_cast<uint32_t>(localRmaBuffer->GetSize()), localRmaBuffer->GetTokenId(),
75 16 : localRmaBuffer->GetTokenValue(), hccl::ConvertHcclToCommMemType(buf->GetMemType()), memInfo);
76 16 : }
77 16 : return HCCL_SUCCESS;
78 : }
79 :
80 16 : static HcclResult CreateCcuTransport(
81 : UrmaEndpoint* ccuEndpoint, const Hccl::LinkData& linkData, Hccl::Socket* socket, HcommMemHandle* memHandles,
82 : uint32_t memHandleNum, uint32_t qos, uint32_t sqSize, std::unique_ptr<CcuTransport>& impl)
83 : {
84 16 : HCCL_INFO("[CcuUrmaChannel][%s] begin, sqSize[%u]", __func__, sqSize);
85 : // 当前ccu channel不支持按需申请cke
86 16 : CHK_PTR_NULL(ccuEndpoint);
87 16 : CHK_PTR_NULL(socket);
88 16 : CHK_PTR_NULL(memHandles);
89 :
90 16 : auto ret = HcclResult::HCCL_SUCCESS;
91 16 : auto* channelCtxPool = ccuEndpoint->GetCcuChannelCtxPool();
92 16 : CHK_PTR_NULL(channelCtxPool);
93 : // 申请ccu channel ctx， jetty ctx，wqebb，可能资源不足，需要回退
94 30 : ret = channelCtxPool->PrepareCreate({linkData}, sqSize);
95 15 : if (ret == HCCL_E_UNAVAIL) {
96 0 : HCCL_WARNING(
97 : "[CcuUrmaChannel][%s] prepare ccu channel ctx failed, "
98 : "ccu resources unavailable.",
99 : __func__);
100 0 : return ret;
101 : }
102 15 : CHK_RET(ret);
103 :
104 15 : CcuChannelCtxPool::CcuChannelCtx channelCtx{};
105 15 : CHK_RET(channelCtxPool->GetChannelCtx(linkData, channelCtx));
106 15 : const auto& channelInfo = channelCtx.first;
107 15 : const auto& ccuJettys = channelCtx.second;
108 :
109 15 : const auto& locAddr_ = linkData.GetLocalAddr();
110 15 : const auto& rmtAddr_ = linkData.GetRemoteAddr();
111 :
112 15 : CommAddr locAddr{}, rmtAddr{};
113 15 : CHK_RET(IpAddressToCommAddr(locAddr_, locAddr));
114 15 : CHK_RET(IpAddressToCommAddr(rmtAddr_, rmtAddr));
115 :
116 15 : CcuTransport::CcuConnectionType type_ = linkData.GetLinkProtocol() == Hccl::LinkProtocol::UB_CTP ?
117 : CcuTransport::CcuConnectionType::UB_CTP :
118 15 : CcuTransport::CcuConnectionType::UBC_TP;
119 :
120 15 : CcuTransport::CcuConnectionInfo connectionInfo{type_, locAddr, rmtAddr, channelInfo, ccuJettys, qos};
121 :
122 15 : std::vector<CcuTransport::CclBufferInfo> bufferInfos{};
123 15 : CHK_RET(BuildBufferInfos(memHandles, memHandleNum, bufferInfos));
124 :
125 : // 调用底层的创建函数 (CcuCreateTransport 通常是全局函数或静态函数)
126 : // 申请 xn cke可能失败，需要回退
127 15 : ret = CcuCreateTransport(socket, connectionInfo, bufferInfos, impl);
128 15 : if (ret == HCCL_E_UNAVAIL) {
129 0 : HCCL_WARNING("[CcuUrmaChannel][%s] failed, ccu resources unavailable.", __func__);
130 0 : return ret;
131 : }
132 15 : CHK_RET(ret);
133 :
134 15 : HCCL_INFO("[CcuUrmaChannel][%s] end, transport created.", __func__);
135 15 : return HCCL_SUCCESS;
136 15 : }
137 :
138 15 : static HcclResult CheckEndpointDesc(const EndpointDesc& locDesc, const EndpointDesc& rmtDesc)
139 : {
140 15 : if (locDesc.protocol != rmtDesc.protocol) {
141 0 : HCCL_ERROR(
142 : "[CcuUrmaChannel][%s] failed, endpoints protocols are not same, "
143 : "loc[%d] rmt[%d].",
144 : __func__, locDesc.protocol, rmtDesc.protocol);
145 0 : return HcclResult::HCCL_E_PARA;
146 : }
147 :
148 15 : if (locDesc.protocol != COMM_PROTOCOL_UB_CTP && locDesc.protocol != COMM_PROTOCOL_UBC_TP) {
149 0 : HCCL_ERROR("[CcuUrmaChannel][%s] failed, protocol[%d] are not supported in ccu.", __func__, locDesc.protocol);
150 0 : return HcclResult::HCCL_E_PARA;
151 : }
152 :
153 15 : return HcclResult::HCCL_SUCCESS;
154 : }
155 :
156 15 : HcclResult CcuUrmaChannel::Init()
157 : {
158 : EXCEPTION_HANDLE_BEGIN
159 15 : CHK_PTR_NULL(channelDesc_.socket);
160 15 : socket_ = reinterpret_cast<Hccl::Socket*>(channelDesc_.socket);
161 : // 当前socket在外部统一触发connect，建议之后改为异步建链流程内触发
162 :
163 15 : CHK_PTR_NULL(locEndpointHandle_);
164 15 : void* endpoint{nullptr};
165 15 : CHK_RET(static_cast<HcclResult>(HcommEndpointGet(locEndpointHandle_, &endpoint)));
166 15 : ccuEndpoint_ = dynamic_cast<UrmaEndpoint*>(static_cast<Endpoint*>(endpoint));
167 15 : CHK_PTR_NULL(ccuEndpoint_);
168 15 : const auto& locEndpointDesc = ccuEndpoint_->GetEndpointDesc();
169 :
170 15 : CHK_RET(CheckEndpointDesc(locEndpointDesc, channelDesc_.remoteEndpoint));
171 :
172 15 : Hccl::LinkData linkData = BuildDefaultLinkData();
173 15 : CHK_RET(EndpointDescPairToLinkData(locEndpointDesc, channelDesc_.remoteEndpoint, linkData));
174 :
175 15 : if (channelDesc_.memHandleNum == 0) {
176 0 : HCCL_ERROR("[CcuUrmaChannel][%s] failed, unsupported memHandleNum[%u].", __func__, channelDesc_.memHandleNum);
177 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
178 : }
179 15 : CHK_PTR_NULL(channelDesc_.memHandles);
180 :
181 15 : memHandles_.assign(channelDesc_.memHandles, channelDesc_.memHandles + channelDesc_.memHandleNum);
182 :
183 : // 当前建链不支持资源扩容，CCU资源默认固定为8
184 15 : HCCL_WARNING("[CcuUrmaChannel][%s] now only support notify num is 8.", __func__);
185 15 : HCCL_WARNING("[CcuUrmaChannel][%s] now only support to exchange hccl buffer.", __func__);
186 :
187 15 : channelStatus_ = ChannelStatus::INIT;
188 0 : EXCEPTION_HANDLE_END
189 15 : return HCCL_SUCCESS;
190 : }
191 :
192 16 : ChannelStatus CcuUrmaChannel::TryPrepareAndConstruct()
193 : {
194 16 : Hccl::LinkData linkData = BuildDefaultLinkData();
195 : HcclResult keyRet
196 16 : = EndpointDescPairToLinkData(ccuEndpoint_->GetEndpointDesc(), channelDesc_.remoteEndpoint, linkData);
197 16 : if (keyRet != HCCL_SUCCESS) {
198 0 : HCCL_ERROR("[CcuUrmaChannel][%s] failed to build link data, ret[%d].", __func__, keyRet);
199 0 : return ChannelStatus::FAILED;
200 : }
201 :
202 16 : HcclResult ret = CreateCcuTransport(
203 16 : ccuEndpoint_, linkData, socket_, memHandles_.data(), static_cast<uint32_t>(memHandles_.size()),
204 16 : channelDesc_.qos, channelDesc_.ubAttr.sqDepth, impl_);
205 16 : if (ret == HCCL_SUCCESS) {
206 15 : impl_->SetLocResStatus(CcuTransport::CcuResStatus::RES_OK);
207 15 : return ChannelStatus::INIT;
208 : }
209 : // 失败(资源不足或硬失败): 构造 msg-only transport 通知对端快速失败, 避免对端 120s 超时
210 1 : CcuTransport::CcuResStatus failStatus
211 1 : = (ret == HCCL_E_UNAVAIL) ? CcuTransport::CcuResStatus::RES_UNAVAIL : CcuTransport::CcuResStatus::RES_FAILED;
212 1 : HCCL_RUN_WARNING(
213 : "[CcuUrmaChannel][%s] CreateCcuTransport failed[%d], construct msg-only transport.", __func__, ret);
214 1 : HcclResult transRet = CcuTransport::ConstructMsgOnlyTransport(socket_, impl_, failStatus);
215 1 : if (transRet != HCCL_SUCCESS) {
216 0 : HCCL_ERROR("[CcuUrmaChannel][%s] ConstructMsgOnlyTransport failed[%d].", __func__, transRet);
217 0 : return ChannelStatus::FAILED;
218 : }
219 1 : return ChannelStatus::INIT;
220 : }
221 :
222 : // 状态机终态 -> 通道状态映射（含 LOC/RMT 资源不足优先级）
223 13 : static ChannelStatus MapTransStatusToChannelStatus(CcuTransport::TransStatus status, const CcuTransport& impl)
224 : {
225 13 : switch (status) {
226 3 : case CcuTransport::TransStatus::READY:
227 3 : return ChannelStatus::READY;
228 2 : case CcuTransport::TransStatus::SOCKET_TIMEOUT:
229 2 : HCCL_ERROR("[CcuUrmaChannel][%s] error status[%s].", __func__, status.Describe().c_str());
230 2 : return ChannelStatus::SOCKET_TIMEOUT;
231 7 : case CcuTransport::TransStatus::CONNECT_FAILED:
232 : // 资源不足终态映射(LOC 优先): 本端不足报 LOC, 否则若对端不足报 RMT, 否则普通 FAILED
233 7 : if (impl.IsLocResUnavailable()) {
234 2 : return ChannelStatus::RES_LOC_UNAVAIL;
235 : }
236 5 : if (impl.IsRmtResUnavailable()) {
237 1 : return ChannelStatus::RES_RMT_UNAVAIL;
238 : }
239 4 : HCCL_ERROR("[CcuUrmaChannel][%s] error status[%s].", __func__, status.Describe().c_str());
240 4 : return ChannelStatus::FAILED;
241 1 : default:
242 1 : return ChannelStatus::INIT;
243 : }
244 : }
245 :
246 30 : ChannelStatus CcuUrmaChannel::GetStatus()
247 : {
248 30 : std::lock_guard<std::mutex> lock(statusMtx_);
249 :
250 30 : if (ccuEndpoint_ == nullptr || socket_ == nullptr || memHandles_.empty()) {
251 1 : HCCL_ERROR(
252 : "[CcuUrmaChannel][%s] endpoint[%p], socket[%p], memHandleNum[%zu], Init() may not have succeeded.",
253 : __func__, ccuEndpoint_, socket_, memHandles_.size());
254 1 : channelStatus_ = ChannelStatus::FAILED;
255 1 : return channelStatus_;
256 : }
257 : // INIT 态内: locResStatus_==RES_UNKNOWN(或 impl_ 为空) 则构造 transport + 申请资源(仅一次)
258 29 : if (channelStatus_ == ChannelStatus::INIT) {
259 26 : if (!impl_ || impl_->GetLocResStatus() == CcuTransport::CcuResStatus::RES_UNKNOWN) {
260 16 : channelStatus_ = TryPrepareAndConstruct();
261 16 : return channelStatus_;
262 : }
263 : }
264 :
265 13 : if (!impl_) {
266 0 : HCCL_ERROR("[CcuUrmaChannel][%s] failed, impl is nullptr.", __func__);
267 0 : return ChannelStatus::FAILED;
268 : }
269 :
270 13 : CcuTransport::TransStatus status = impl_->GetStatus();
271 13 : ChannelStatus out = MapTransStatusToChannelStatus(status, *impl_);
272 13 : channelStatus_ = out;
273 :
274 13 : if (isFirstPrintChannelInfo_ && out == ChannelStatus::READY) {
275 2 : std::string channelInfo = "create channel info:channel handle[";
276 2 : channelInfo.append(std::to_string(reinterpret_cast<uint64_t>(this)));
277 2 : channelInfo.append("] ");
278 2 : HcclResult ret = impl_->Describe(channelInfo);
279 2 : if (ret != HCCL_SUCCESS) {
280 1 : HCCL_ERROR("[CcuUrmaChannel][%s] Describe channel info failed, ret=%d", __func__, ret);
281 1 : out = ChannelStatus::FAILED;
282 1 : channelStatus_ = out;
283 : } else {
284 1 : channelInfo.append(" TA[RM]"); // 目前TA只支持RM
285 1 : HCCL_CONFIG_DEBUG(hccl::HCCL_RES, "%s", channelInfo.c_str());
286 : }
287 2 : isFirstPrintChannelInfo_ = false;
288 2 : }
289 13 : return channelStatus_; // todo: AICPU 重新定义基类的状态后，需要修改为CONNECTING
290 30 : }
291 :
292 17 : uint32_t CcuUrmaChannel::GetDieId() const
293 : {
294 17 : if (!impl_) {
295 0 : return UINT32_MAX;
296 : }
297 :
298 17 : return impl_->GetDieId();
299 : }
300 :
301 36 : uint32_t CcuUrmaChannel::GetChannelId() const
302 : {
303 36 : if (!impl_) {
304 3 : return UINT32_MAX;
305 : }
306 33 : return impl_->GetChannelId();
307 : }
308 :
309 8 : HcclResult CcuUrmaChannel::GetRmtSignalAddrByIndex(uint32_t index, uint64_t& rmtCkeAddr) const
310 : {
311 8 : CHK_PTR_NULL(impl_);
312 8 : CHK_RET(impl_->GetRmtSignalAddrByIndex(index, rmtCkeAddr));
313 8 : return HcclResult::HCCL_SUCCESS;
314 : }
315 :
316 6 : HcclResult CcuUrmaChannel::GetRmtVarAddrByIndex(uint32_t index, uint64_t& rmtXnAddr) const
317 : {
318 6 : CHK_PTR_NULL(impl_);
319 6 : CHK_RET(impl_->GetRmtVarAddrByIndex(index, rmtXnAddr));
320 6 : return HcclResult::HCCL_SUCCESS;
321 : }
322 :
323 8 : HcclResult CcuUrmaChannel::GetRmtCcuBufferTokenInfo(uint32_t& rmtTokenId, uint32_t& rmtTokenValue) const
324 : {
325 8 : CHK_PTR_NULL(impl_);
326 8 : CHK_RET(impl_->GetRmtCcuBufferTokenInfo(rmtTokenId, rmtTokenValue));
327 8 : return HcclResult::HCCL_SUCCESS;
328 : }
329 :
330 12 : HcclResult CcuUrmaChannel::GetLocCkeByIndex(const uint32_t index, uint32_t& locCkeId) const
331 : {
332 12 : CHK_PTR_NULL(impl_);
333 12 : CHK_RET(impl_->GetLocCkeByIndex(index, locCkeId));
334 12 : return HcclResult::HCCL_SUCCESS;
335 : }
336 :
337 10 : HcclResult CcuUrmaChannel::GetLocXnByIndex(const uint32_t index, uint32_t& locXnId) const
338 : {
339 10 : CHK_PTR_NULL(impl_);
340 10 : CHK_RET(impl_->GetLocXnByIndex(index, locXnId));
341 10 : return HcclResult::HCCL_SUCCESS;
342 : }
343 :
344 7 : HcclResult CcuUrmaChannel::GetRmtCkeByIndex(const uint32_t index, uint32_t& rmtCkeId) const
345 : {
346 7 : CHK_PTR_NULL(impl_);
347 7 : CHK_RET(impl_->GetRmtCkeByIndex(index, rmtCkeId));
348 7 : return HcclResult::HCCL_SUCCESS;
349 : }
350 :
351 5 : HcclResult CcuUrmaChannel::GetRmtXnByIndex(const uint32_t index, uint32_t& rmtXnId) const
352 : {
353 5 : CHK_PTR_NULL(impl_);
354 5 : CHK_RET(impl_->GetRmtXnByIndex(index, rmtXnId));
355 5 : return HcclResult::HCCL_SUCCESS;
356 : }
357 :
358 0 : HcclResult CcuUrmaChannel::GetRmtWishCntXnAddr(const std::string& resGroupTag, uint64_t& wishCntXnAddr) const
359 : {
360 0 : CHK_PTR_NULL(impl_);
361 0 : CHK_RET(impl_->GetRmtWishCntXnAddr(resGroupTag, wishCntXnAddr));
362 0 : return HcclResult::HCCL_SUCCESS;
363 : }
364 :
365 0 : HcclResult CcuUrmaChannel::GetRmtBuffer(uint64_t& addr, uint32_t& size, uint32_t& tokenId, uint32_t& tokenValue) const
366 : {
367 0 : CHK_PTR_NULL(impl_);
368 0 : CcuTransport::CclBufferInfo bufInfo{};
369 0 : constexpr uint32_t bufNum = 0; // 当前不支持
370 0 : CHK_RET(impl_->GetRmtBuffer(bufInfo, bufNum));
371 :
372 0 : addr = bufInfo.addr;
373 0 : size = bufInfo.size;
374 0 : tokenId = bufInfo.tokenId;
375 0 : tokenValue = bufInfo.tokenValue;
376 0 : return HcclResult::HCCL_SUCCESS;
377 : }
378 :
379 0 : HcclResult CcuUrmaChannel::GetNotifyNum(uint32_t* notifyNum) const
380 : {
381 0 : CHK_PTR_NULL(impl_);
382 0 : CHK_RET(impl_->GetCkeNum(*notifyNum));
383 0 : return HcclResult::HCCL_SUCCESS;
384 : }
385 :
386 0 : HcclResult CcuUrmaChannel::GetRemoteMems(uint32_t* memNum, CommMem** remoteMem, char*** memInfos)
387 : {
388 0 : CHK_PTR_NULL(impl_);
389 0 : return impl_->GetRemoteMems(memNum, remoteMem, memInfos);
390 : }
391 :
392 2 : HcclResult CcuUrmaChannel::Clean()
393 : {
394 2 : CHK_PTR_NULL(impl_);
395 1 : impl_->Clean();
396 1 : return HcclResult::HCCL_SUCCESS;
397 : }
398 :
399 1 : HcclResult CcuUrmaChannel::Resume() { return HCCL_SUCCESS; }
400 :
401 0 : HcclResult CcuUrmaChannel::UpdateMemInfo(HcommMemHandle* memHandles, uint32_t memHandleNum)
402 : {
403 0 : CHK_PTR_NULL(impl_);
404 0 : std::vector<CcuTransport::CclBufferInfo> bufferVecTemp{};
405 0 : CHK_RET(BuildBufferInfos(memHandles, memHandleNum, bufferVecTemp));
406 0 : return impl_->UpdateMemInfo(bufferVecTemp);
407 0 : }
408 :
409 0 : HcclResult CcuUrmaChannel::NotifyRecord([[maybe_unused]] const uint32_t remoteNotifyIdx)
410 : {
411 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
412 0 : return HCCL_E_NOT_SUPPORT;
413 : }
414 :
415 : HcclResult
416 0 : CcuUrmaChannel::NotifyWait([[maybe_unused]] const uint32_t localNotifyIdx, [[maybe_unused]] const uint32_t timeout)
417 : {
418 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
419 0 : return HCCL_E_NOT_SUPPORT;
420 : }
421 :
422 0 : HcclResult CcuUrmaChannel::WriteWithNotify(
423 : [[maybe_unused]] void* dst, [[maybe_unused]] const void* src, [[maybe_unused]] const uint64_t len,
424 : [[maybe_unused]] uint32_t remoteNotifyIdx)
425 : {
426 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
427 0 : return HCCL_E_NOT_SUPPORT;
428 : }
429 :
430 : HcclResult
431 0 : CcuUrmaChannel::Write([[maybe_unused]] void* dst, [[maybe_unused]] const void* src, [[maybe_unused]] uint64_t len)
432 : {
433 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
434 0 : return HCCL_E_NOT_SUPPORT;
435 : }
436 :
437 : HcclResult
438 0 : CcuUrmaChannel::Read([[maybe_unused]] void* dst, [[maybe_unused]] const void* src, [[maybe_unused]] uint64_t len)
439 : {
440 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
441 0 : return HCCL_E_NOT_SUPPORT;
442 : }
443 :
444 0 : HcclResult CcuUrmaChannel::ChannelFence()
445 : {
446 0 : HCCL_INFO("[CcuUrmaChannel::%s] not supported yet.", __func__);
447 0 : return HCCL_E_NOT_SUPPORT;
448 : }
449 :
450 : } // namespace hcomm
|
