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