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