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 "hccl_aicpu_transport_interface.h"
12 :
13 : #include <sstream>
14 : #include "common/aicpu_hccl_def.h"
15 : #include "common/aicpu_sqe_context.h"
16 : #include "profiling_manager_device.h"
17 : #include "framework/aicpu_hccl_process.h"
18 : #include "utils/hccl_aicpu_utils.h"
19 :
20 : extern "C" {
21 0 : __attribute__((visibility("default"))) uint32_t RunTransportRoceTx(void* args)
22 : {
23 0 : CHK_PTR_NULL(args);
24 0 : PostSendTaskParam* SRInfo = reinterpret_cast<PostSendTaskParam*>(args);
25 : // Check Local Flag
26 0 : uint32_t lfKey = SRInfo->lfKey;
27 0 : uint32_t rfKey = SRInfo->rfKey;
28 0 : HcclQpInfoV2 qpInfo = SRInfo->qpInfo;
29 0 : hccl::Transport::Buffer localFlagBufforWrite[3];
30 0 : hccl::Transport::Buffer localFlagBufforCheck[3];
31 0 : hccl::Transport::Buffer remoteFlagBuf[3];
32 0 : uint32_t* lFlagAddr = reinterpret_cast<uint32_t*>(SRInfo->localFlagAddr);
33 0 : uint32_t* rFlagAddr = reinterpret_cast<uint32_t*>(SRInfo->remoteFlagAddr);
34 0 : const uint64_t timeout = SRInfo->timeOut;
35 :
36 : // Init Flag Area
37 0 : HcclResult ret = AicpuHcclProcess::InitAsyncFlag(
38 : lFlagAddr, rFlagAddr, localFlagBufforCheck, localFlagBufforWrite, remoteFlagBuf);
39 0 : if (ret != HCCL_SUCCESS) {
40 0 : HCCL_ERROR(
41 : "[AiCpuKernel][RunTransportRoceTx]InitAsyncFlag Failed, lFlagAddr is [%p], rFlagAddr is [%p], "
42 : "localFlagBufforCheck is [%p], localFlagBufforWrite is [%p], remoteFlagBuf is [%p].",
43 : lFlagAddr, rFlagAddr, localFlagBufforCheck, localFlagBufforWrite, remoteFlagBuf);
44 0 : return ret;
45 : }
46 : // start write flag 1
47 0 : ret = HcclAicpuUtils::PostSend(
48 : lfKey, rfKey, qpInfo, remoteFlagBuf[0], localFlagBufforWrite[0], true); // RDMA WriteFlag
49 0 : if (ret != HCCL_SUCCESS) {
50 0 : HCCL_ERROR(
51 : "[AiCpuKernel][RunTransportRoceTx]PostSendFlag Failed, lfKey is [%u], rfKey is [%u], qpInfo.qpPtr is [%p]"
52 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
53 : "remoteFlagBuf.size is [%u]",
54 : lfKey, rfKey, qpInfo.qpPtr, localFlagBufforWrite[0].addr, localFlagBufforWrite[0].size,
55 : remoteFlagBuf[0].addr, remoteFlagBuf[0].size);
56 0 : return ret;
57 : }
58 : // 轮询等待flag 1
59 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 1, timeout);
60 0 : if (ret != HCCL_SUCCESS) {
61 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceTx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
62 0 : return ret;
63 : }
64 : // 向对端开始写数据
65 0 : uint32_t lKey = SRInfo->lKey;
66 0 : uint32_t rKey = SRInfo->rKey;
67 0 : hccl::Transport::Buffer remoteBuf;
68 0 : remoteBuf.addr = reinterpret_cast<void*>(SRInfo->remoteAddr);
69 0 : remoteBuf.size = static_cast<uint32_t>(SRInfo->dataSize);
70 0 : hccl::Transport::Buffer localBuf;
71 0 : localBuf.addr = reinterpret_cast<void*>(SRInfo->localAddr);
72 0 : localBuf.size = static_cast<uint32_t>(SRInfo->dataSize);
73 0 : ret = HcclAicpuUtils::PostSend(lKey, rKey, qpInfo, remoteBuf, localBuf, true); // RDMA WriteData
74 0 : if (ret != HCCL_SUCCESS) {
75 0 : HCCL_ERROR(
76 : "[AiCpuKernel][RunTransportRoceTx]PostSendData Failed, lKey is [%u], rKey is [%u],"
77 : "qpInfo.qpPtr is [%llx],remoteBuf.addr is [%llx], remoteBuf.size is [%u], localBuf.addr is [%llx],"
78 : "localBuf.size is [%u]",
79 : lKey, rKey, qpInfo.qpPtr, remoteBuf.addr, remoteBuf.size, localBuf.addr, localBuf.size);
80 0 : return ret;
81 : }
82 :
83 : // 写完数据发个flag 2，告知对端数据已经写过去了
84 0 : ret = HcclAicpuUtils::PostSend(
85 : lfKey, rfKey, qpInfo, remoteFlagBuf[1], localFlagBufforWrite[1], true); // RDMA WriteFlag
86 0 : if (ret != HCCL_SUCCESS) {
87 0 : HCCL_ERROR(
88 : "[AiCpuKernel][RunTransportRoceTx]PostSendFlag Failed, now Operation is WriteFlag, lfKey is [%u], rfKey is "
89 : "[%u],"
90 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
91 : "remoteFlagBuf.size is [%u]",
92 : lfKey, rfKey, localFlagBufforWrite[1].addr, localFlagBufforWrite[1].size, remoteFlagBuf[1].addr,
93 : remoteFlagBuf[1].size);
94 0 : return ret;
95 : }
96 : // 轮询等待flag 2
97 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 2, timeout);
98 0 : if (ret != HCCL_SUCCESS) {
99 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceTx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
100 0 : return ret;
101 : }
102 : // 再发个flag 3，尾同步
103 0 : ret = HcclAicpuUtils::PostSend(
104 : lfKey, rfKey, qpInfo, remoteFlagBuf[2], localFlagBufforWrite[2], true); // RDMA WriteFlag
105 0 : if (ret != HCCL_SUCCESS) {
106 0 : HCCL_ERROR(
107 : "[AiCpuKernel][RunTransportRoceTx]PostSendFlag Failed, now Operation is WriteFlag, lfKey is [%u], rfKey is "
108 : "[%u],"
109 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
110 : "remoteFlagBuf.size is [%u]",
111 : lfKey, rfKey, localFlagBufforWrite[2].addr, localFlagBufforWrite[2].size, remoteFlagBuf[2].addr,
112 : remoteFlagBuf[2].size);
113 0 : return ret;
114 : }
115 : // 轮询等待flag 3
116 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 3, timeout);
117 0 : if (ret != HCCL_SUCCESS) {
118 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceTx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
119 0 : return ret;
120 : }
121 0 : HCCL_INFO("[AiCpuKernel][RunTransportRoceTx]Kernel run success");
122 0 : return HCCL_SUCCESS;
123 : }
124 :
125 0 : __attribute__((visibility("default"))) uint32_t RunTransportRoceRx(void* args)
126 : {
127 0 : CHK_PTR_NULL(args);
128 0 : PostSendTaskParam* SRInfo = reinterpret_cast<PostSendTaskParam*>(args);
129 0 : HcclQpInfoV2 qpInfo = SRInfo->qpInfo;
130 0 : uint32_t lfKey = SRInfo->lfKey;
131 0 : uint32_t rfKey = SRInfo->rfKey;
132 0 : hccl::Transport::Buffer localFlagBufforWrite[3];
133 0 : hccl::Transport::Buffer localFlagBufforCheck[3];
134 0 : hccl::Transport::Buffer remoteFlagBuf[3];
135 :
136 0 : uint32_t* lFlagAddr = reinterpret_cast<uint32_t*>(SRInfo->localFlagAddr);
137 0 : uint32_t* rFlagAddr = reinterpret_cast<uint32_t*>(SRInfo->remoteFlagAddr);
138 0 : uint64_t timeout = SRInfo->timeOut;
139 : // Init Flag Area
140 0 : HcclResult ret = AicpuHcclProcess::InitAsyncFlag(
141 : lFlagAddr, rFlagAddr, localFlagBufforCheck, localFlagBufforWrite, remoteFlagBuf);
142 0 : if (ret != HCCL_SUCCESS) {
143 0 : HCCL_ERROR(
144 : "[AiCpuKernel][RunTransportRoceTx]InitAsyncFlag Failed, lFlagAddr is [%p], rFlagAddr is [%p], "
145 : "localFlagBufforCheck is [%p], localFlagBufforWrite is [%p], remoteFlagBuf is [%p].",
146 : lFlagAddr, rFlagAddr, localFlagBufforCheck, localFlagBufforWrite, remoteFlagBuf);
147 0 : return ret;
148 : }
149 : // start write flag 1
150 0 : ret = HcclAicpuUtils::PostSend(
151 : lfKey, rfKey, qpInfo, remoteFlagBuf[0], localFlagBufforWrite[0], true); // RDMA WriteFlag
152 0 : if (ret != HCCL_SUCCESS) {
153 0 : HCCL_ERROR(
154 : "[AiCpuKernel][RunTransportRoceRx]PostSendFlag Failed, lfKey is [%u], rfKey is [%u], qpInfo.qpPtr is [%p]"
155 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
156 : "remoteFlagBuf.size is [%u]",
157 : lfKey, rfKey, qpInfo.qpPtr, localFlagBufforWrite[0].addr, localFlagBufforWrite[0].size,
158 : remoteFlagBuf[0].addr, remoteFlagBuf[0].size);
159 0 : return ret;
160 : }
161 : // 轮询等待flag 1
162 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 1, timeout);
163 0 : if (ret != HCCL_SUCCESS) {
164 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceRx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
165 0 : return ret;
166 : }
167 :
168 0 : ret = HcclAicpuUtils::PostSend(
169 : lfKey, rfKey, qpInfo, remoteFlagBuf[1], localFlagBufforWrite[1], true); // RDMA WriteFlag
170 0 : if (ret != HCCL_SUCCESS) {
171 0 : HCCL_ERROR(
172 : "[AiCpuKernel][RunTransportRoceRx]PostSendFlag Failed, now Operation is WriteFlag, lfKey is [%u], rfKey is "
173 : "[%u],"
174 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
175 : "remoteFlagBuf.size is [%u]",
176 : lfKey, rfKey, localFlagBufforWrite[1].addr, localFlagBufforWrite[1].size, remoteFlagBuf[1].addr,
177 : remoteFlagBuf[1].size);
178 0 : return ret;
179 : }
180 : // 轮询等待flag 2
181 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 2, timeout);
182 0 : if (ret != HCCL_SUCCESS) {
183 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceRx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
184 0 : return ret;
185 : }
186 : // 再发个flag 3，尾同步
187 0 : ret = HcclAicpuUtils::PostSend(
188 : lfKey, rfKey, qpInfo, remoteFlagBuf[2], localFlagBufforWrite[2], true); // RDMA WriteFlag
189 0 : if (ret != HCCL_SUCCESS) {
190 0 : HCCL_ERROR(
191 : "[AiCpuKernel][RunTransportRoceRx]PostSendFlag Failed, now Operation is WriteFlag, lfKey is [%u], rfKey is "
192 : "[%u],"
193 : "localFlagBufforWrite.addr is [%llx], localFlagBufforWrite.size is [%u],remoteFlagBuf.addr is [%llx],"
194 : "remoteFlagBuf.size is [%u]",
195 : lfKey, rfKey, localFlagBufforWrite[2].addr, localFlagBufforWrite[2].size, remoteFlagBuf[2].addr,
196 : remoteFlagBuf[2].size);
197 0 : return ret;
198 : }
199 : // 轮询等待flag 3
200 0 : ret = AicpuHcclProcess::WaitAsyncFlag(localFlagBufforCheck, 3, timeout);
201 0 : if (ret != HCCL_SUCCESS) {
202 0 : HCCL_ERROR("[AiCpuKernel][RunTransportRoceRx]WaitFlag Failed lfKey %u rfKey %u.", lfKey, rfKey);
203 0 : return ret;
204 : }
205 0 : HCCL_INFO("[AiCpuKernel][RunTransportRoceRx]Kernel run success");
206 0 : return HCCL_SUCCESS;
207 : }
208 : } // extern "C"
|
