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 "zero_copy_acl_graph.h"
12 : #include "stream_utils.h"
13 : namespace hccl {
14 807 : ZeroCopyAclGraph::ZeroCopyAclGraph() : tagResourceIndex_(0), retryEnable_(false)
15 : {
16 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_BROADCAST);
17 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_ALLREDUCE);
18 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_REDUCE);
19 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_ALLTOALL);
20 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_ALLTOALLV);
21 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_REDUCE_SCATTER);
22 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_SEND);
23 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_RECEIVE);
24 807 : algoSet_.insert(HcclCMDType::HCCL_CMD_ALLGATHER);
25 807 : }
26 :
27 0 : std::string ZeroCopyAclGraph::GetTagPrefix()
28 : {
29 0 : std::stringstream ss;
30 0 : ss << std::hex << std::uppercase << (tagResourceIndex_++);
31 0 : return ss.str();
32 0 : }
33 :
34 74 : void ZeroCopyAclGraph::SetRetryEnable(bool retryEnable)
35 : {
36 74 : this->retryEnable_ = retryEnable;
37 74 : }
38 :
39 27 : bool ZeroCopyAclGraph::IsAclGraphZeroCopyAlgAvailable(HcclCMDType opType, OpParam &opParam)
40 : {
41 27 : bool isReduceOps = (
42 10 : opType == HCCL_CMD_ALLREDUCE ||
43 9 : opType == HCCL_CMD_REDUCE ||
44 37 : opType == HCCL_CMD_REDUCE_SCATTER ||
45 : opType == HCCL_CMD_REDUCE_SCATTER_V
46 : );
47 : // 非Reduce类算子，不受aclGraphZeroCopyEnable 用户配置值的影响，继续配置AclGraphZeroCopy的算法选择模式
48 27 : if (!isReduceOps == true) {
49 5 : return true;
50 : }
51 :
52 : // 检查用户的Aclgraph配置，如果配置了Aclgraph等于0并且当前是Reduce类算子，则退出AclgraphZeroCopy算法配置流程
53 22 : if (opParam.aclGraphZeroCopyEnable == 1) {
54 : // Reduce 类算子，但是保证性能优先，算法选择和单算自不一致。继续配置AclGraphZeroCopy的算法选择模式
55 2 : return true;
56 : }
57 20 : return false;
58 : }
59 :
60 67 : bool ZeroCopyAclGraph::SetAclGraphZeroCopyMode(
61 : DevType deviceType, HcclCMDType opType, OpParam &opParam, HcclAlg *impl, u64 bufferSize)
62 : {
63 67 : bool isInGraphCaputureZeroCopy = false;
64 67 : aclmdlRI rtModel = nullptr;
65 67 : bool isCapture = false;
66 67 : if (impl == nullptr) {
67 0 : return false;
68 : }
69 :
70 67 : if (deviceType != DevType::DEV_TYPE_910_93) {
71 47 : HCCL_INFO("[ZeroCopyAclGraph][SetAclGraphZeroCopyMode] Hccl doesn't support graph zero copy mode. current "
72 : "device is %d not DEV_TYPE_910_93",
73 : deviceType);
74 58 : return false;
75 : }
76 :
77 40 : bool isActivateAddr = ZeroCopyMemoryAgent::IsActivateCommMemoryAddr(opParam.inputPtr, opParam.inputSize) ||
78 20 : ZeroCopyMemoryAgent::IsActivateCommMemoryAddr(opParam.outputPtr, opParam.outputSize);
79 20 : if (opParam.isZeroCopy || opParam.supportZeroCopy || opParam.supportSymmetricMemory || isActivateAddr) {
80 0 : HCCL_INFO("[ZeroCopyAclGraph][SetAclGraphZeroCopyMode] Hccl can't support graph zero copy mode and operator "
81 : "zero copy at the same time.");
82 0 : return false;
83 : }
84 20 : if (IsAclGraphZeroCopyAlgAvailable(opType, opParam) == false) {
85 18 : HCCL_INFO("[ZeroCopyAclGraph][SetAclGraphZeroCopyMode] Hccl aclGraph was set disable mode.");
86 18 : return false;
87 : }
88 :
89 2 : GetStreamCaptureInfo(opParam.stream.ptr(), rtModel, isCapture);
90 2 : if (isCapture) {
91 0 : isInGraphCaputureZeroCopy = SetGraphMode(opType, opParam, impl, bufferSize);
92 : }
93 2 : return isInGraphCaputureZeroCopy;
94 : }
95 :
96 0 : bool ZeroCopyAclGraph::SetGraphMode(HcclCMDType opType, OpParam &opParam, HcclAlg *impl, u64 bufferSize)
97 : {
98 0 : if (!opParam.aicpuUnfoldMode || (GetExternalInputHcclAivMode() && (opType == HCCL_CMD_ALLTOALLV || opType == HCCL_CMD_BROADCAST))) {
99 0 : HCCL_INFO("[ZeroCopyAclGraph][SetAclGraphZeroCopyMode] Hccl can't support graph zero copy "
100 : "mode. Only support on aicpu mode aicpuUnfoldMode %d aiv %d",
101 : opParam.aicpuUnfoldMode,
102 : GetExternalInputHcclAivMode());
103 0 : return false;
104 : }
105 0 : if (IsAlgoSupportAclGraphZeroCopyMode(opType, opParam, impl, bufferSize)) {
106 0 : SetWorkflowMode(HcclWorkflowMode::HCCL_WORKFLOW_MODE_OPS_KERNEL_INFO_LIB);
107 0 : HCCL_INFO("[ZeroCopyAclGraph][SetAclGraphZeroCopyMode] Hccl set op %d workflow mode to "
108 : "HCCL_WORKFLOW_MODE_OPS_KERNEL_INFO_LIB "
109 : "graph zero copy mode.",
110 : opType);
111 0 : return true;
112 : }
113 0 : return false;
114 : }
115 :
116 0 : bool ZeroCopyAclGraph::AlgoCheck(OpParam &opParam, std::unique_ptr<CollAlgOperator> &algo, u64 bufferSize)
117 : {
118 0 : std::string algName;
119 0 : std::string newTag;
120 0 : if (opParam.aicpuUnfoldMode) {
121 : // 用于inplace支持重执行判断
122 0 : algo->SetRetryEnable(retryEnable_);
123 : }
124 0 : HcclResult res = algo->SelectAlg(opParam.tag, opParam, algName, newTag);
125 0 : if (res != HCCL_SUCCESS) {
126 0 : HCCL_INFO("[ZeroCopyAclGraph][AlgoCheck] could not select algo. result =%x", res);
127 0 : return false;
128 : }
129 :
130 0 : AlgResourceRequest resRequest;
131 0 : HcclResult ret = algo->CalcResRequest(algName, opParam, resRequest);
132 0 : if (ret == HCCL_SUCCESS) {
133 0 : if (IsScratchMemorySupportAclGraphZeroCopyMode(opParam, bufferSize, resRequest.scratchMemSize)) {
134 0 : opParam.tag = opParam.tag + GetTagPrefix();
135 0 : HCCL_INFO("[ZeroCopyAclGraph][AlgoCheck] scratch support.");
136 0 : return true;
137 : }
138 0 : HCCL_INFO("[ZeroCopyAclGraph][AlgoCheck] could not scratch support.");
139 : } else {
140 0 : HCCL_INFO("[ZeroCopyAclGraph][AlgoCheck] op %d could not calcResRequest.", opParam.opType);
141 : }
142 0 : return false;
143 0 : }
144 :
145 0 : bool ZeroCopyAclGraph::IsAlgoSupportAclGraphZeroCopyMode(
146 : HcclCMDType opType, OpParam &opParam, HcclAlg *impl, u64 bufferSize)
147 : {
148 0 : if (algoSet_.find(opType) != algoSet_.end()) {
149 0 : HcclWorkflowMode oldMode = GetWorkflowMode();
150 0 : SetWorkflowMode(HcclWorkflowMode::HCCL_WORKFLOW_MODE_OPS_KERNEL_INFO_LIB);
151 0 : std::unique_ptr<CollAlgOperator> algo = impl->GetAlgOperator(opType);
152 0 : if (algo == nullptr) {
153 0 : HCCL_INFO("[ZeroCopyAclGraph][IsAlgoSupportAclGraphZeroCopyMode] could not getAlgo.");
154 0 : return false;
155 : }
156 0 : if (AlgoCheck(opParam, algo, bufferSize)) {
157 0 : return true;
158 : }
159 0 : HCCL_INFO("[ZeroCopyAclGraph][IsAlgoSupportAclGraphZeroCopyMode] could not check algo.");
160 0 : SetWorkflowMode(oldMode);
161 0 : }
162 :
163 0 : return false;
164 : }
165 :
166 0 : bool ZeroCopyAclGraph::IsScratchMemorySupportAclGraphZeroCopyMode(
167 : const OpParam &opParam, u64 bufferSize, u64 scratchMemSize)
168 : {
169 0 : if (scratchMemSize <= bufferSize) {
170 0 : HCCL_INFO("[ZeroCopyAclGraph] OP %d support acl graph zero copy. scratchmemsize=%ul cclbuffer size=%ul",
171 : opParam.opType,
172 : scratchMemSize,
173 : bufferSize);
174 0 : return true;
175 : }
176 0 : HCCL_INFO("[ZeroCopyAclGraph] OP %d doesn't support acl graph zero copy. scratchmemsize=%ul cclbuffer size=%ul",
177 : opParam.opType,
178 : scratchMemSize,
179 : bufferSize);
180 0 : return false;
181 : }
182 : } // namespace hccl
|
