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 "dispatcher_pub.h"
12 : #ifndef HCCD
13 : #include "dispatcher_graph_pub.h"
14 : #endif
15 : #include "dispatcher_virtural_pub.h"
16 : #include "dispatcher_aicpu_pub.h"
17 : #include "dispatcher.h"
18 : #include "externalinput_pub.h"
19 : #include "adapter_hal.h"
20 :
21 : using namespace hccl;
22 : typedef HcclResult (*FftsCounterCallBack)(const HcclDispatcher&, Stream &);
23 : FftsCounterCallBack g_InitTaskCallback = nullptr;
24 : FftsCounterCallBack g_LaunchTaskCallback = nullptr;
25 41 : void RegisterInitTaskCallBack(HcclResult (*p1)(const HcclDispatcher &, hccl::Stream &))
26 : {
27 41 : g_InitTaskCallback = p1;
28 41 : }
29 :
30 41 : void RegisterLaunchTaskCallBack(HcclResult (*p1)(const HcclDispatcher &, hccl::Stream &))
31 : {
32 41 : g_LaunchTaskCallback = p1;
33 41 : }
34 :
35 1053 : HcclResult RegisterLoadTaskCallBack(HcclDispatcher dispatcherPtr, void *userPtr,
36 : void (*p1)(void *userPtr, void *param, u32 length))
37 :
38 : {
39 1053 : CHK_PTR_NULL(dispatcherPtr);
40 1053 : reinterpret_cast<DispatcherPub*>(dispatcherPtr)->RegLoadTaskCallBack(userPtr, p1);
41 1053 : return HCCL_SUCCESS;
42 : }
43 :
44 75 : HcclResult ForceProfOn(HcclDispatcher &dispatcherPtr, bool isForce)
45 : {
46 75 : CHK_PTR_NULL(dispatcherPtr);
47 75 : reinterpret_cast<DispatcherPub*>(dispatcherPtr)->ForceProf(isForce);
48 71 : return HCCL_SUCCESS;
49 : }
50 1061 : HcclResult HcclDispatcherInit(DispatcherType type, const s32 devicePhyId, HcclDispatcher *dispatcher)
51 : {
52 1061 : CHK_RET(DlProfFunc::GetInstance().DlProfFunctionInit());
53 1061 : CHK_PTR_NULL(dispatcher);
54 1061 : u32 deviceLogicId = INVALID_UINT;
55 1061 : if (static_cast<s32>(devicePhyId) != HOST_DEVICE_ID) {
56 1061 : CHK_RET(hrtGetDeviceIndexByPhyId(devicePhyId, deviceLogicId));
57 : } else {
58 0 : deviceLogicId = devicePhyId;
59 : }
60 :
61 1061 : DispatcherPub *pDispatcher = nullptr;
62 1061 : if (type == DispatcherType::DISPATCHER_NORMAL) {
63 540 : if (GetExternalInputHcclEnableFfts()) {
64 : // DispatcherGraph 不编到device侧的so里面
65 : #ifndef HCCD
66 111 : pDispatcher = new (std::nothrow) DispatcherGraph(deviceLogicId);
67 : #endif
68 : } else {
69 429 : pDispatcher = new (std::nothrow) DispatcherPub(deviceLogicId);
70 : }
71 521 : } else if (type == DispatcherType::DISPATCHER_VIRTURAL) {
72 521 : pDispatcher = new (std::nothrow) DispatcherVirtural(deviceLogicId);
73 : } else {
74 0 : HCCL_ERROR("Not support the dispatcher type[%d]", type);
75 0 : return HCCL_E_NOT_SUPPORT;
76 : }
77 1061 : CHK_PTR_NULL(pDispatcher);
78 1061 : HcclResult ret = pDispatcher->Init();
79 1061 : if (ret != HCCL_SUCCESS) {
80 0 : HCCL_ERROR("Dispatcher init failed, type[%d]", type);
81 0 : delete pDispatcher;
82 0 : pDispatcher = nullptr;
83 0 : return ret;
84 : }
85 1061 : *dispatcher = pDispatcher;
86 1061 : return HCCL_SUCCESS;
87 : }
88 :
89 1072 : HcclResult HcclDispatcherDestroy(HcclDispatcher dispatcherPtr)
90 : {
91 1072 : if (dispatcherPtr != nullptr) {
92 1072 : DispatcherPub* dispatcher = reinterpret_cast<DispatcherPub*>(dispatcherPtr);
93 1072 : delete dispatcher;
94 1070 : dispatcherPtr = nullptr;
95 : }
96 1070 : return HCCL_SUCCESS;
97 : }
98 :
99 92 : HcclResult HcclSetGlobalWorkSpace(HcclDispatcher dispatcherPtr, std::vector<void *> &globalWorkSpaceAddr)
100 : {
101 92 : CHK_PTR_NULL(dispatcherPtr);
102 92 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SetGlobalWorkSpace(globalWorkSpaceAddr);
103 : }
104 :
105 0 : HcclResult HcclSetNotifyWaitMode(HcclDispatcher dispatcherPtr, const SyncMode notifyWaitMode)
106 : {
107 0 : CHK_PTR_NULL(dispatcherPtr);
108 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SetNotifyWaitMode(notifyWaitMode);
109 : }
110 :
111 0 : HcclResult HcclGetNotifyWaitMode(HcclDispatcher dispatcherPtr, SyncMode *notifyWaitMode)
112 : {
113 0 : CHK_PTR_NULL(dispatcherPtr);
114 0 : CHK_PTR_NULL(notifyWaitMode);
115 :
116 0 : *notifyWaitMode = reinterpret_cast<DispatcherPub*>(dispatcherPtr)->GetNotifyWaitMode();
117 0 : return HCCL_SUCCESS;
118 : }
119 :
120 80 : HcclResult HcclD2DMemcpyAsync(HcclDispatcher dispatcherPtr, DeviceMem &dst, const DeviceMem &src,
121 : Stream &stream, const u32 remoteUserRank, const LinkType linkType)
122 : {
123 80 : CHK_PTR_NULL(dispatcherPtr);
124 80 : CHK_PTR_NULL(dst.ptr());
125 80 : CHK_PTR_NULL(src.ptr());
126 :
127 80 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->MemcpyAsync(dst, src, stream, remoteUserRank, linkType);
128 : }
129 :
130 0 : HcclResult HcclMemcpyAsync(HcclDispatcher dispatcherPtr, void *dst, const uint64_t destMax, const void *src,
131 : uint64_t count, const HcclRtMemcpyKind kind, Stream &stream, const u32 remoteUserRank,
132 : const LinkType linkType)
133 : {
134 0 : CHK_PTR_NULL(dispatcherPtr);
135 0 : CHK_PTR_NULL(dst);
136 0 : CHK_PTR_NULL(src);
137 :
138 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->MemcpyAsync(dst, destMax, src, count, kind,
139 0 : stream, remoteUserRank, linkType);
140 : }
141 :
142 9 : HcclResult HcclReduceAsync(HcclDispatcher dispatcherPtr, void *src, uint64_t count, const HcclDataType datatype,
143 : const HcclReduceOp reduceOp, Stream &stream, void *dst, const u32 remoteUserRank,
144 : const LinkType linkType, const u64 reduceAttr)
145 : {
146 9 : CHK_PTR_NULL(dispatcherPtr);
147 9 : CHK_PTR_NULL(dst);
148 9 : CHK_PTR_NULL(src);
149 :
150 9 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->ReduceAsync(src, count, datatype, reduceOp,
151 9 : stream, dst, remoteUserRank, linkType, reduceAttr);
152 : }
153 :
154 0 : HcclResult HcclDispatcherWaitValue(HcclDispatcher dispatcherPtr, hccl::Stream &stream, u64 waitAddr, u64 valueAddr, bool reset)
155 : {
156 0 : CHK_PTR_NULL(dispatcherPtr);
157 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->WaitValue(stream, waitAddr, valueAddr, reset);
158 : }
159 0 : HcclResult HcclDispatcherWriteValue(HcclDispatcher dispatcherPtr, hccl::Stream &stream, u64 writeAddr, u64 valueAddr)
160 : {
161 0 : CHK_PTR_NULL(dispatcherPtr);
162 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->WriteValue(stream, writeAddr, valueAddr);
163 : }
164 :
165 0 : HcclResult HcclSignalRecord(HcclDispatcher dispatcherPtr, HcclRtNotify signal, Stream &stream, u32 userRank,
166 : u64 offset, s32 stage, bool inchip, u64 signalAddr)
167 : {
168 0 : CHK_PTR_NULL(dispatcherPtr);
169 0 : CHK_PTR_NULL(signal);
170 :
171 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SignalRecord(signal, stream, userRank,
172 0 : offset, stage, inchip, signalAddr);
173 : }
174 0 : HcclResult HcclSignalWait(HcclDispatcher dispatcherPtr, HcclRtNotify signal, Stream &stream, u32 userRank,
175 : u32 remoteUserRank, s32 stage, bool inchip)
176 : {
177 0 : CHK_PTR_NULL(dispatcherPtr);
178 0 : CHK_PTR_NULL(signal);
179 :
180 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SignalWait(signal, stream,
181 0 : userRank, remoteUserRank, stage, inchip);
182 : }
183 :
184 9 : HcclResult LaunchTask(HcclDispatcher dispatcherPtr, Stream &stream)
185 : {
186 9 : CHK_PTR_NULL(dispatcherPtr);
187 9 : if (g_LaunchTaskCallback != nullptr) {
188 9 : CHK_RET(g_LaunchTaskCallback(dispatcherPtr, stream));
189 : }
190 9 : std::vector<Stream> subStreams;
191 9 : HcclResult ret = reinterpret_cast<DispatcherPub*>(dispatcherPtr)->LaunchTasksEx(stream, subStreams);
192 9 : return ret;
193 9 : }
194 :
195 94 : HcclResult LaunchTaskExtend(HcclDispatcher dispatcherPtr, Stream &stream, std::vector<Stream> &subStreams)
196 : {
197 94 : CHK_PTR_NULL(dispatcherPtr);
198 94 : if (g_LaunchTaskCallback != nullptr) {
199 94 : CHK_RET(g_LaunchTaskCallback(dispatcherPtr, stream));
200 : }
201 94 : return reinterpret_cast<DispatcherPub *>(dispatcherPtr)->LaunchTasksEx(stream, subStreams);
202 : }
203 :
204 56 : HcclResult InitTask(HcclDispatcher dispatcherPtr, hccl::Stream &stream, const bool enableCache,
205 : const std::string &key, bool useGraphConstructorV2)
206 : {
207 56 : CHK_PTR_NULL(dispatcherPtr);
208 :
209 56 : CHK_RET(reinterpret_cast<DispatcherPub*>(dispatcherPtr)->ResetGraphCtx(enableCache, key, useGraphConstructorV2));
210 56 : if (g_InitTaskCallback != nullptr) {
211 56 : CHK_RET(g_InitTaskCallback(dispatcherPtr, stream));
212 : }
213 56 : return HCCL_SUCCESS;
214 : }
215 :
216 0 : HcclResult AddRetryPreamble(HcclDispatcher dispatcherPtr, hccl::Stream &stream)
217 : {
218 0 : CHK_PTR_NULL(dispatcherPtr);
219 :
220 0 : CHK_RET(reinterpret_cast<DispatcherPub*>(dispatcherPtr)->AddRetryPreamble(stream));
221 0 : return HCCL_SUCCESS;
222 : }
223 :
224 2 : HcclResult SetNormalMode(HcclDispatcher dispatcherPtr)
225 : {
226 2 : CHK_PTR_NULL(dispatcherPtr);
227 :
228 0 : reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SetNormalMode();
229 :
230 0 : return HCCL_SUCCESS;
231 : }
232 :
233 0 : HcclResult HcclGetCallbackResult(HcclDispatcher dispatcherPtr)
234 : {
235 0 : CHK_PTR_NULL(dispatcherPtr);
236 :
237 0 : return reinterpret_cast<DispatcherPub*>(dispatcherPtr)->GetCallbackResult();
238 : }
239 :
240 0 : HcclResult StreamSync(HcclDispatcher dispatcherPtr, Stream &stream)
241 : {
242 0 : CHK_PTR_NULL(dispatcherPtr);
243 :
244 0 : CHK_RET(reinterpret_cast<DispatcherPub*>(dispatcherPtr)->StreamSync(stream));
245 0 : return HCCL_SUCCESS;
246 : }
247 :
248 11 : HcclResult HcclSetOpExecStatusCallback(HcclDispatcher dispatcherPtr,
249 : std::function<HcclResult()> checkOpExecStatusCallback)
250 : {
251 11 : CHK_RET(CheckRunSideIsDevice());
252 11 : CHK_PTR_NULL(dispatcherPtr);
253 :
254 11 : reinterpret_cast<DispatcherAiCpu*>(dispatcherPtr)->SetOpExecStatusCallback(checkOpExecStatusCallback);
255 11 : return HCCL_SUCCESS;
256 : }
257 :
258 11 : HcclResult HcclSetSqeTimeOut(HcclDispatcher dispatcherPtr, const u64 timeOut)
259 : {
260 11 : CHK_RET(CheckRunSideIsDevice());
261 11 : CHK_PTR_NULL(dispatcherPtr);
262 :
263 11 : reinterpret_cast<DispatcherAiCpu*>(dispatcherPtr)->SetSqeTimeOut(timeOut);
264 11 : return HCCL_SUCCESS;
265 : }
266 :
267 0 : HcclResult HcclSetSqFullWaitTimeOut(HcclDispatcher dispatcherPtr, const u64 timeOut)
268 : {
269 0 : CHK_RET(CheckRunSideIsDevice());
270 0 : CHK_PTR_NULL(dispatcherPtr);
271 :
272 0 : reinterpret_cast<DispatcherAiCpu*>(dispatcherPtr)->SetSqFullWaitTimeOut(timeOut);
273 0 : return HCCL_SUCCESS;
274 : }
275 :
276 0 : HcclResult HcclSetOpRingBufferIdx(HcclDispatcher dispatcherPtr, const u32 opRingBufferIdx)
277 : {
278 0 : CHK_RET(CheckRunSideIsDevice());
279 0 : CHK_PTR_NULL(dispatcherPtr);
280 :
281 0 : reinterpret_cast<DispatcherAiCpu*>(dispatcherPtr)->SetOpRingBufferIdx(opRingBufferIdx);
282 0 : return HCCL_SUCCESS;
283 : }
284 :
285 1042 : HcclResult HcclSetExecTimeOut(HcclDispatcher dispatcherPtr, s32 execTimeOut)
286 : {
287 1042 : CHK_PTR_NULL(dispatcherPtr);
288 1042 : CHK_RET(reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SetHcclExecTimeOut(execTimeOut));
289 1042 : return HCCL_SUCCESS;
290 : }
291 0 : HcclResult SetMultiQpMode(HcclDispatcher dispatcherPtr, bool multiQpMode)
292 : {
293 0 : CHK_PTR_NULL(dispatcherPtr);
294 :
295 0 : CHK_RET(reinterpret_cast<DispatcherPub*>(dispatcherPtr)->SetMultiQpMode(multiQpMode));
296 0 : return HCCL_SUCCESS;
297 : }
|
