Star637
238
代码
代码
Issues34
Pull Requests89
Actions
项目讨论
Wiki
分析
Star637
238
已合并
refactor: clarify SIMT launch and internal option semantics #1774
yrz1027创建于 19 天前
refactor: clarify SIMT launch and internal option semantics #1774
已合并
yrz1027创建于 19 天前
从yrz1027/graph-autofusionfix/rename-simt-dcache-semantics合入到cann/graph-autofusionmaster
共 11 个文件变更+247-404
Msuper_kernel/include/super_kernel/super_kernel.h+1-6
@@ -60,12 +60,7 @@ enum class aclskOptionType : uint32_t {
60 SK_OPTION_MAX60 SK_OPTION_MAX
61};61};
62 62 
63-enum class SkInnerOptionType : uint32_t {63+enum class SkInnerOptionType : uint32_t { MIX_KERNEL_SPLIT = 0, SIMT_OP_SUPPORT = 1, SK_INNER_OPTION_MAX };
64- ENABLE_MIX_KERNEL_SPLIT = 0,
65- ENABLE_SIMT_OP_CHECK = 1,
66- ENABLE_SET_DYN_UBUF_SIZE = 2,
67- SK_INNER_OPTION_MAX
68-};
69 64 
70typedef struct aclskPreloadOption {65typedef struct aclskPreloadOption {
71 uint32_t preloadMode;66 uint32_t preloadMode;
Msuper_kernel/src/aot/sk_node.cpp+71-67
@@ -823,32 +823,30 @@ bool SuperKernelBaseNode::Update(const UpdateContext &ctx) {
823 return true;823 return true;
824}824}
825 825 
826-void SuperKernelBaseNode::LogNodeUpdateResult(const aclmdlRITaskParams *resultParams) const {826+void SuperKernelBaseNode::LogNodeUpdateResult(const aclmdlRITaskParams *paramsToLog) const {
827 std::ostringstream oss;827 std::ostringstream oss;
828 oss << "node update result: nodeId=" << nodeId;828 oss << "node update result: nodeId=" << nodeId;
829- if (resultParams == nullptr) {829+ if (paramsToLog == nullptr) {
830 oss << ", type=INVALID";830 oss << ", type=INVALID";
831 SK_LOGI("%s", oss.str().c_str());831 SK_LOGI("%s", oss.str().c_str());
832 return;832 return;
833 }833 }
834 834 
835- oss << ", type=" << GetUpdateTargetTypeName(resultParams->type);835+ oss << ", type=" << GetUpdateTargetTypeName(paramsToLog->type);
836- switch (resultParams->type) {836+ switch (paramsToLog->type) {
837 case ACL_MODEL_RI_TASK_KERNEL:837 case ACL_MODEL_RI_TASK_KERNEL:
838- oss << ", opInfoPtr=" << resultParams->opInfoPtr << ", opInfoSize=" << resultParams->opInfoSize838+ oss << ", opInfoPtr=" << paramsToLog->opInfoPtr << ", opInfoSize=" << paramsToLog->opInfoSize
839- << ", funcHandle=" << resultParams->kernelTaskParams.funcHandle839+ << ", funcHandle=" << paramsToLog->kernelTaskParams.funcHandle
840- << ", args=" << resultParams->kernelTaskParams.args840+ << ", args=" << paramsToLog->kernelTaskParams.args << ", argsSize=" << paramsToLog->kernelTaskParams.argsSize
841- << ", argsSize=" << resultParams->kernelTaskParams.argsSize841+ << ", numBlocks=" << static_cast<uint32_t>(paramsToLog->kernelTaskParams.numBlocks);
842- << ", numBlocks=" << static_cast<uint32_t>(resultParams->kernelTaskParams.numBlocks);
843 break;842 break;
844 case ACL_MODEL_RI_TASK_VALUE_WRITE:843 case ACL_MODEL_RI_TASK_VALUE_WRITE:
845- oss << ", addr=" << resultParams->valueWriteTaskParams.devAddr << ", value=0x" << std::hex844+ oss << ", addr=" << paramsToLog->valueWriteTaskParams.devAddr << ", value=0x" << std::hex
846- << resultParams->valueWriteTaskParams.value << std::dec;845+ << paramsToLog->valueWriteTaskParams.value << std::dec;
847 break;846 break;
848 case ACL_MODEL_RI_TASK_VALUE_WAIT:847 case ACL_MODEL_RI_TASK_VALUE_WAIT:
849- oss << ", addr=" << resultParams->valueWaitTaskParams.devAddr << ", value=0x" << std::hex848+ oss << ", addr=" << paramsToLog->valueWaitTaskParams.devAddr << ", value=0x" << std::hex
850- << resultParams->valueWaitTaskParams.value << ", flag=0x" << resultParams->valueWaitTaskParams.flag849+ << paramsToLog->valueWaitTaskParams.value << ", flag=0x" << paramsToLog->valueWaitTaskParams.flag << std::dec;
851- << std::dec;
852 break;850 break;
853 default:851 default:
854 break;852 break;
@@ -1062,22 +1060,18 @@ void SuperKernelKernelNode::IdentifyAndHandleSimtKernel(const SuperKernelOptions
1062 nodeInfos.kernelInfos.hasAllocUbufSize = false;1060 nodeInfos.kernelInfos.hasAllocUbufSize = false;
1063 nodeInfos.kernelInfos.dynUbufSize = 0;1061 nodeInfos.kernelInfos.dynUbufSize = 0;
1064 nodeInfos.kernelInfos.allocUbufSize = 0;1062 nodeInfos.kernelInfos.allocUbufSize = 0;
1065- if (opts == nullptr) {1063+ if (opts == nullptr || !opts->IsInnerOptionEnabled(SkInnerOptionType::SIMT_OP_SUPPORT)) {
1066- return;
1067- }
1068- const auto *simtCheckOpt = opts->GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);
1069- if (simtCheckOpt == nullptr || simtCheckOpt->GetIntValue() != 1) {
1070 return;1064 return;
1071 }1065 }
1072 SkKernelType kernelType = nodeInfos.kernelInfos.kernelType;1066 SkKernelType kernelType = nodeInfos.kernelInfos.kernelType;
1073 bool hasAivSection = (kernelType == SkKernelType::AIV_ONLY || kernelType == SkKernelType::MIX_AIV_1_0 ||1067 bool hasAivSection = (kernelType == SkKernelType::AIV_ONLY || kernelType == SkKernelType::MIX_AIV_1_0 ||
1074 kernelType == SkKernelType::MIX_AIC_1_1 || kernelType == SkKernelType::MIX_AIC_1_2);1068 kernelType == SkKernelType::MIX_AIC_1_1 || kernelType == SkKernelType::MIX_AIC_1_2);
1075 if (!hasAivSection) {1069 if (!hasAivSection) {
1076- SK_LOGI("IdentifyAndHandleSimtKernel: %s has no AIV section (kernelType=%s), skip SIMT check", Format().c_str(),1070+ SK_LOGI("IdentifyAndHandleSimtKernel: %s has no AIV section (kernelType=%s), skip SIMT analysis", Format().c_str(),
1077 to_string(kernelType));1071 to_string(kernelType));
1078 return;1072 return;
1079 }1073 }
1080- SK_LOGI("IdentifyAndHandleSimtKernel: checking for %s, kernelType=%s, nodeId=%lu", Format().c_str(),1074+ SK_LOGI("IdentifyAndHandleSimtKernel: analyzing %s, kernelType=%s, nodeId=%lu", Format().c_str(),
1081 to_string(kernelType), nodeId);1075 to_string(kernelType), nodeId);
1082 uint32_t aivType = 0;1076 uint32_t aivType = 0;
1083 rtError_t ret = rtFunctionGetMetaInfo(taskParams.kernelTaskParams.funcHandle, RT_FUNCTION_TYPE_AIV_TYPE_FLAG,1077 rtError_t ret = rtFunctionGetMetaInfo(taskParams.kernelTaskParams.funcHandle, RT_FUNCTION_TYPE_AIV_TYPE_FLAG,
@@ -1113,15 +1107,17 @@ void SuperKernelKernelNode::IdentifyAndHandleSimtKernel(const SuperKernelOptions
1113 return;1107 return;
1114}1108}
1115 1109 
1116-bool SuperKernelKernelNode::SetupLaunchKernelCfgWithDynUbuf(size_t minAvailableUbufSize) {1110+bool SuperKernelKernelNode::SetupLaunchKernelCfg(aclrtFuncHandle funcHandle, size_t skMaxDcacheSize,
1117- launchKernelAttrs_.clear();1111+ std::vector<aclrtLaunchKernelAttr> &launchKernelAttrs,
1112+ aclrtLaunchKernelCfg &launchKernelCfg) const {
1113+ launchKernelAttrs.clear();
1118 const aclrtLaunchKernelCfg *originCfg = taskParams.kernelTaskParams.cfg;1114 const aclrtLaunchKernelCfg *originCfg = taskParams.kernelTaskParams.cfg;
1119 if (originCfg != nullptr && originCfg->attrs != nullptr) {1115 if (originCfg != nullptr && originCfg->attrs != nullptr) {
1120- launchKernelAttrs_.reserve(originCfg->numAttrs + 1);1116+ launchKernelAttrs.reserve(originCfg->numAttrs + 1);
1121 for (size_t attrIdx = 0; attrIdx < originCfg->numAttrs; ++attrIdx) {1117 for (size_t attrIdx = 0; attrIdx < originCfg->numAttrs; ++attrIdx) {
1122 const aclrtLaunchKernelAttr &originAttr = originCfg->attrs[attrIdx];1118 const aclrtLaunchKernelAttr &originAttr = originCfg->attrs[attrIdx];
1123 if (originAttr.id != ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE) {1119 if (originAttr.id != ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE) {
1124- launchKernelAttrs_.push_back(originAttr);1120+ launchKernelAttrs.push_back(originAttr);
1125 }1121 }
1126 }1122 }
1127 }1123 }
@@ -1129,31 +1125,26 @@ bool SuperKernelKernelNode::SetupLaunchKernelCfgWithDynUbuf(size_t minAvailableU
1129 aclrtLaunchKernelAttr dynUbufAttr{};1125 aclrtLaunchKernelAttr dynUbufAttr{};
1130 dynUbufAttr.id = ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE;1126 dynUbufAttr.id = ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE;
1131 size_t skAllocUbufSize = 0;1127 size_t skAllocUbufSize = 0;
1132- if (!GetFunctionAllocUbufSize(taskParams.kernelTaskParams.funcHandle, skAllocUbufSize, Format())) {1128+ if (!GetFunctionAllocUbufSize(funcHandle, skAllocUbufSize, Format())) {
1133 return false;1129 return false;
1134 }1130 }
1135- if (minAvailableUbufSize > SK_TOTAL_UB_SIZE || skAllocUbufSize > SK_TOTAL_UB_SIZE - minAvailableUbufSize) {1131+ if (skMaxDcacheSize > SK_TOTAL_UB_SIZE || skAllocUbufSize > SK_TOTAL_UB_SIZE - skMaxDcacheSize) {
1136 SK_LOGE(1132 SK_LOGE(
1137- "invalid dyn ubuf calculation for %s, totalUbSize=%zu, minAvailableUbufSize=%zu, "1133+ "invalid dyn ubuf calculation for %s, totalUbSize=%zu, skMaxDcacheSize=%zu, "
1138 "skAllocUbufSize=%zu",1134 "skAllocUbufSize=%zu",
1139- Format().c_str(), SK_TOTAL_UB_SIZE, minAvailableUbufSize, skAllocUbufSize);1135+ Format().c_str(), SK_TOTAL_UB_SIZE, skMaxDcacheSize, skAllocUbufSize);
1140 return false;1136 return false;
1141 }1137 }
1142- size_t finalDynUbufSize = SK_TOTAL_UB_SIZE - minAvailableUbufSize - skAllocUbufSize;1138+ size_t skEntryDynUbufSize = SK_TOTAL_UB_SIZE - skMaxDcacheSize - skAllocUbufSize;
1143- if (finalDynUbufSize > std::numeric_limits<uint32_t>::max()) {1139+ dynUbufAttr.value.dynUBufSize = static_cast<uint32_t>(skEntryDynUbufSize);
1144- SK_LOGE("dynUbufSize exceeds uint32_t range for %s, dynUbufSize=%zu", Format().c_str(), finalDynUbufSize);1140+ launchKernelAttrs.push_back(dynUbufAttr);
1145- return false;
1146- }
1147- dynUbufAttr.value.dynUBufSize = static_cast<uint32_t>(finalDynUbufSize);
1148- launchKernelAttrs_.push_back(dynUbufAttr);
1149 1141 
1150- launchKernelCfg_.attrs = launchKernelAttrs_.data();1142+ launchKernelCfg.attrs = launchKernelAttrs.data();
1151- launchKernelCfg_.numAttrs = launchKernelAttrs_.size();1143+ launchKernelCfg.numAttrs = launchKernelAttrs.size();
1152- taskParams.kernelTaskParams.cfg = &launchKernelCfg_;
1153 SK_LOGI(1144 SK_LOGI(
1154- "Set dyn ubuf launch cfg for %s, minAvailableUbufSize=%zu, skAllocUbufSize=%zu, "1145+ "Set dyn ubuf launch cfg for %s, skMaxDcacheSize=%zu, skAllocUbufSize=%zu, "
1155- "finalDynUbufSize=%zu, attrCount=%zu",1146+ "skEntryDynUbufSize=%zu, attrCount=%zu",
1156- Format().c_str(), minAvailableUbufSize, skAllocUbufSize, finalDynUbufSize, launchKernelCfg_.numAttrs);1147+ Format().c_str(), skMaxDcacheSize, skAllocUbufSize, skEntryDynUbufSize, launchKernelCfg.numAttrs);
1157 return true;1148 return true;
1158}1149}
1159 1150 
@@ -1201,7 +1192,8 @@ bool SuperKernelKernelNode::Update(const UpdateContext &ctx) {
1201 SK_LOGE("Failed to update base node for %s", Format().c_str());1192 SK_LOGE("Failed to update base node for %s", Format().c_str());
1202 return false;1193 return false;
1203 }1194 }
1204- const aclmdlRITaskParams *resultParams = nullptr;1195+ aclmdlRITaskParams updateParams{};
1196+ bool hasUpdateParams = false;
1205 1197 
1206 if (ctx.customParams != nullptr && ctx.customParams->type != 0) {1198 if (ctx.customParams != nullptr && ctx.customParams->type != 0) {
1207 // check update value1199 // check update value
@@ -1218,38 +1210,48 @@ bool SuperKernelKernelNode::Update(const UpdateContext &ctx) {
1218 Format().c_str());1210 Format().c_str());
1219 break;1211 break;
1220 }1212 }
1213+ updateParams = *ctx.customParams;
1221 // update kernel with custom params for stream sync1214 // update kernel with custom params for stream sync
1222- aclError aclRet = aclmdlRITaskSetParams(*originTask, ctx.customParams);1215+ aclError aclRet = aclmdlRITaskSetParams(*originTask, &updateParams);
1223 if (aclRet != ACL_SUCCESS) {1216 if (aclRet != ACL_SUCCESS) {
1224 SK_LOGE("Failed to set kernel with custom params for %s", Format().c_str());1217 SK_LOGE("Failed to set kernel with custom params for %s", Format().c_str());
1225 return false;1218 return false;
1226 }1219 }
1227 // Sync taskParams for JSON dump1220 // Sync taskParams for JSON dump
1228- taskParams = *ctx.customParams;1221+ taskParams = updateParams;
1229- resultParams = &taskParams;1222+ hasUpdateParams = true;
1230 } else if (ctx.launchInfo != nullptr && ctx.launchInfo->entryInfo.skEntryFunc != nullptr) {1223 } else if (ctx.launchInfo != nullptr && ctx.launchInfo->entryInfo.skEntryFunc != nullptr) {
1231- taskParams.kernelTaskParams.args = static_cast<void *>(ctx.launchInfo->devArgs.Get());1224+ updateParams = taskParams;
1232- taskParams.kernelTaskParams.argsSize = ctx.launchInfo->devArgs.Get()->skHeader.totalSize;1225+ updateParams.type = ACL_MODEL_RI_TASK_KERNEL;
1233- taskParams.kernelTaskParams.isHostArgs = true;1226+ updateParams.opInfoPtr = ctx.launchInfo->cacheInfo;
1234- 1227+ updateParams.opInfoSize = ctx.launchInfo->cacheopInfoSize;
1235- taskParams.kernelTaskParams.funcHandle = ctx.launchInfo->entryInfo.skEntryFunc;1228+ updateParams.kernelTaskParams.args = static_cast<void *>(ctx.launchInfo->devArgs.Get());
1236- taskParams.kernelTaskParams.numBlocks = ctx.launchInfo->entryInfo.numBlocks;1229+ updateParams.kernelTaskParams.argsSize = ctx.launchInfo->devArgs.Get()->skHeader.totalSize;
1237- taskParams.type = ACL_MODEL_RI_TASK_KERNEL;1230+ updateParams.kernelTaskParams.isHostArgs = true;
1238- taskParams.opInfoPtr = ctx.launchInfo->cacheInfo;1231+ updateParams.kernelTaskParams.funcHandle = ctx.launchInfo->entryInfo.skEntryFunc;
1239- taskParams.opInfoSize = ctx.launchInfo->cacheopInfoSize;1232+ updateParams.kernelTaskParams.numBlocks = ctx.launchInfo->entryInfo.numBlocks;
1240- if (ctx.launchInfo->hasMinAvailableUbufSize &&1233+ aclrtLaunchKernelCfg *originCfg = taskParams.kernelTaskParams.cfg;
1241- !SetupLaunchKernelCfgWithDynUbuf(ctx.launchInfo->minAvailableUbufSize)) {1234+ updateParams.kernelTaskParams.cfg = originCfg;
1242- SK_LOGE("Failed to setup dyn ubuf launch cfg for kernel node %s", Format().c_str());1235+ std::vector<aclrtLaunchKernelAttr> launchKernelAttrs;
1243- return false;1236+ aclrtLaunchKernelCfg launchKernelCfg{};
1237+ if (ctx.launchInfo->useSimtEntry) {
1238+ if (!SetupLaunchKernelCfg(updateParams.kernelTaskParams.funcHandle, ctx.launchInfo->skMaxDcacheSize,
1239+ launchKernelAttrs, launchKernelCfg)) {
1240+ SK_LOGE("Failed to setup dyn ubuf launch cfg for kernel node %s", Format().c_str());
1241+ return false;
1242+ }
1243+ updateParams.kernelTaskParams.cfg = &launchKernelCfg;
1244 }1244 }
1245 1245 
1246- aclError aclRet = aclmdlRITaskSetParams(*originTask, &taskParams);1246+ aclError aclRet = aclmdlRITaskSetParams(*originTask, &updateParams);
1247+ updateParams.kernelTaskParams.cfg = originCfg;
1247 1248 
1248 if (aclRet != ACL_SUCCESS) {1249 if (aclRet != ACL_SUCCESS) {
1249 SK_LOGE("Failed to update kernel node %s", Format().c_str());1250 SK_LOGE("Failed to update kernel node %s", Format().c_str());
1250 return false;1251 return false;
1251 }1252 }
1252- resultParams = &taskParams;1253+ taskParams = updateParams;
1254+ hasUpdateParams = true;
1253 } else {1255 } else {
1254 aclError aclRet = InValidateNode();1256 aclError aclRet = InValidateNode();
1255 if (aclRet != ACL_SUCCESS) {1257 if (aclRet != ACL_SUCCESS) {
@@ -1257,7 +1259,7 @@ bool SuperKernelKernelNode::Update(const UpdateContext &ctx) {
1257 }1259 }
1258 }1260 }
1259 1261 
1260- LogNodeUpdateResult(resultParams);1262+ LogNodeUpdateResult(hasUpdateParams ? &updateParams : nullptr);
1261 return true;1263 return true;
1262}1264}
1263 1265 
@@ -1361,7 +1363,8 @@ bool SuperKernelMemoryNode::Update(const UpdateContext &ctx) {
1361 SK_LOGE("Failed to update base node for %s", Format().c_str());1363 SK_LOGE("Failed to update base node for %s", Format().c_str());
1362 return false;1364 return false;
1363 }1365 }
1364- const aclmdlRITaskParams *resultParams = nullptr;1366+ aclmdlRITaskParams updateParams{};
1367+ bool hasUpdateParams = false;
1365 1368 
1366 if (ctx.customParams != nullptr && ctx.customParams->type != 0) {1369 if (ctx.customParams != nullptr && ctx.customParams->type != 0) {
1367 // check update value1370 // check update value
@@ -1378,15 +1381,16 @@ bool SuperKernelMemoryNode::Update(const UpdateContext &ctx) {
1378 Format().c_str());1381 Format().c_str());
1379 break;1382 break;
1380 }1383 }
1384+ updateParams = *ctx.customParams;
1381 // update memory node with custom params for stream sync1385 // update memory node with custom params for stream sync
1382- aclError aclRet = aclmdlRITaskSetParams(*originTask, ctx.customParams);1386+ aclError aclRet = aclmdlRITaskSetParams(*originTask, &updateParams);
1383 if (aclRet != ACL_SUCCESS) {1387 if (aclRet != ACL_SUCCESS) {
1384 SK_LOGE("Failed to set custom params on memory node %s", Format().c_str());1388 SK_LOGE("Failed to set custom params on memory node %s", Format().c_str());
1385 return false;1389 return false;
1386 }1390 }
1387 // Sync taskParams for JSON dump1391 // Sync taskParams for JSON dump
1388- taskParams = *ctx.customParams;1392+ taskParams = updateParams;
1389- resultParams = &taskParams;1393+ hasUpdateParams = true;
1390 } else {1394 } else {
1391 aclError aclRet = InValidateNode();1395 aclError aclRet = InValidateNode();
1392 if (aclRet != ACL_SUCCESS) {1396 if (aclRet != ACL_SUCCESS) {
@@ -1394,7 +1398,7 @@ bool SuperKernelMemoryNode::Update(const UpdateContext &ctx) {
1394 }1398 }
1395 }1399 }
1396 1400 
1397- LogNodeUpdateResult(resultParams);1401+ LogNodeUpdateResult(hasUpdateParams ? &updateParams : nullptr);
1398 return true;1402 return true;
1399}1403}
1400 1404 
Msuper_kernel/src/aot/sk_node.h+4-4
@@ -534,7 +534,7 @@ class SuperKernelBaseNode {
534 534 
535 protected:535 protected:
536 aclmdlRITaskParams taskParams;536 aclmdlRITaskParams taskParams;
537- void LogNodeUpdateResult(const aclmdlRITaskParams *resultParams) const;537+ void LogNodeUpdateResult(const aclmdlRITaskParams *paramsToLog) const;
538 const char *GetUpdateTargetTypeName(aclmdlRITaskType type) const;538 const char *GetUpdateTargetTypeName(aclmdlRITaskType type) const;
539 uint32_t notifyExpandVecNum;539 uint32_t notifyExpandVecNum;
540 uint32_t notifyExpandCubeNum;540 uint32_t notifyExpandCubeNum;
@@ -594,14 +594,14 @@ class SuperKernelKernelNode : public SuperKernelBaseNode {
594 594 
595 private:595 private:
596 void IdentifyAndHandleSimtKernel(const SuperKernelOptionsManager *opts);596 void IdentifyAndHandleSimtKernel(const SuperKernelOptionsManager *opts);
597- bool SetupLaunchKernelCfgWithDynUbuf(size_t minAvailableUbufSize);597+ bool SetupLaunchKernelCfg(aclrtFuncHandle funcHandle, size_t skMaxDcacheSize,
598+ std::vector<aclrtLaunchKernelAttr> &launchKernelAttrs,
599+ aclrtLaunchKernelCfg &launchKernelCfg) const;
598 600 
599 bool isScopeBegin = false;601 bool isScopeBegin = false;
600 bool isScopeEnd = false;602 bool isScopeEnd = false;
601 bool isPlaceholder = false;603 bool isPlaceholder = false;
602 std::string scopeName;604 std::string scopeName;
603- std::vector<aclrtLaunchKernelAttr> launchKernelAttrs_;
604- aclrtLaunchKernelCfg launchKernelCfg_{};
605};605};
606 606 
607class SuperKernelMemoryNode : public SuperKernelBaseNode {607class SuperKernelMemoryNode : public SuperKernelBaseNode {
Msuper_kernel/src/aot/sk_optimizer.cpp+5-2
@@ -281,8 +281,11 @@ bool SuperKernelOptimizer::Schedule(SuperKernelScopeInfo &scopeInfo, SuperKernel
281 SK_LOGE("schedule failed: build launch info failed");281 SK_LOGE("schedule failed: build launch info failed");
282 return false;282 return false;
283 }283 }
284- SK_LOGI("schedule scope: build finished, entryType=%s, entryFuncHandle=%p, skFuncName=%s",284+ SK_LOGI(
285- to_string(launchInfo.entryInfo.entryType), launchInfo.entryInfo.skEntryFunc, launchInfo.skFuncName.c_str());285+ "schedule scope: build finished, entryType=%s, entryFuncHandle=%p, skFuncName=%s, useSimtEntry=%d, "
286+ "skMaxDcacheSize=%zu",
287+ to_string(launchInfo.entryInfo.entryType), launchInfo.entryInfo.skEntryFunc, launchInfo.skFuncName.c_str(),
288+ static_cast<int>(launchInfo.useSimtEntry), launchInfo.skMaxDcacheSize);
286 289 
287 if (!Update(scopeInfo, graph, launchInfo)) {290 if (!Update(scopeInfo, graph, launchInfo)) {
288 SK_LOGE("schedule failed: scope update failed");291 SK_LOGE("schedule failed: scope update failed");
Msuper_kernel/src/aot/sk_options_manager.cpp+42-98
@@ -131,39 +131,23 @@ const DefaultOptionFactoryEntry *FindDefaultOptionFactory(aclskOptionType optTyp
131 return nullptr;131 return nullptr;
132}132}
133 133 
134-using DefaultInnerOptionFactory = std::unique_ptr<OptOptionBase> (*)();134+struct InnerOptionInfo {
135- 135+ SkInnerOptionType optionType;
136-struct DefaultInnerOptionFactoryEntry {136+ std::unique_ptr<OptOptionBase> (*factory)();
137- SkInnerOptionType optType;
138- DefaultInnerOptionFactory factory;
139};137};
140 138 
141-const std::array<DefaultInnerOptionFactoryEntry, static_cast<size_t>(SkInnerOptionType::SK_INNER_OPTION_MAX)>139+const std::array<InnerOptionInfo, static_cast<size_t>(SkInnerOptionType::SK_INNER_OPTION_MAX)> DEFAULT_INNER_OPTIONS = {
142- DEFAULT_INNER_OPTION_FACTORIES = {{140+ {
143- {SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT,141+ {SkInnerOptionType::MIX_KERNEL_SPLIT,
144 []() -> std::unique_ptr<OptOptionBase> {142 []() -> std::unique_ptr<OptOptionBase> {
145- return std::make_unique<NumberOptOption>("enable_mix_kernel_split", aclskOptionType::SK_OPTION_MAX, 0, 0, 1);143+ return std::make_unique<NumberOptOption>("mix_kernel_split", aclskOptionType::SK_OPTION_MAX, 0, 0, 1);
146 }},144 }},
147- {SkInnerOptionType::ENABLE_SIMT_OP_CHECK,145+ {SkInnerOptionType::SIMT_OP_SUPPORT,
148 []() -> std::unique_ptr<OptOptionBase> {146 []() -> std::unique_ptr<OptOptionBase> {
149- return std::make_unique<NumberOptOption>("enable_simt_op_check", aclskOptionType::SK_OPTION_MAX, 0, 0, 1);147+ return std::make_unique<NumberOptOption>("simt_op_support", aclskOptionType::SK_OPTION_MAX, 0, 0, 1);
150- }},
151- {SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE,
152- []() -> std::unique_ptr<OptOptionBase> {
153- return std::make_unique<NumberOptOption>("enable_set_dyn_ubuf_size", aclskOptionType::SK_OPTION_MAX, 0, 0,
154- 1);
155 }},148 }},
156 }};149 }};
157 150 
158-const DefaultInnerOptionFactoryEntry *FindDefaultInnerOptionFactory(SkInnerOptionType optType) {
159- for (const auto &entry : DEFAULT_INNER_OPTION_FACTORIES) {
160- if (entry.optType == optType) {
161- return &entry;
162- }
163- }
164- return nullptr;
165-}
166- 
167uint32_t GetValidatedUintValue(const std::string &optionName, uint32_t value, uint32_t defaultValue, uint32_t minValue,151uint32_t GetValidatedUintValue(const std::string &optionName, uint32_t value, uint32_t defaultValue, uint32_t minValue,
168 uint32_t maxValue) {152 uint32_t maxValue) {
169 if (value < minValue || value > maxValue) {153 if (value < minValue || value > maxValue) {
@@ -378,20 +362,9 @@ const OptOptionBase *SuperKernelOptionsManager::GetOption(aclskOptionType optTyp
378 return iter->second.get();362 return iter->second.get();
379}363}
380 364 
381-OptOptionBase *SuperKernelOptionsManager::GetOption(SkInnerOptionType optType) {365+bool SuperKernelOptionsManager::IsInnerOptionEnabled(SkInnerOptionType optionType) const {
382- auto iter = innerOptionMap.find(optType);366+ const auto iter = innerOptionMap.find(optionType);
383- if (iter == innerOptionMap.end()) {367+ return iter != innerOptionMap.end() && iter->second != nullptr && iter->second->GetIntValue() == 1;
384- return nullptr;
385- }
386- return iter->second.get();
387-}
388- 
389-const OptOptionBase *SuperKernelOptionsManager::GetOption(SkInnerOptionType optType) const {
390- auto iter = innerOptionMap.find(optType);
391- if (iter == innerOptionMap.end()) {
392- return nullptr;
393- }
394- return iter->second.get();
395}368}
396 369 
397bool SuperKernelOptionsManager::MatchKernelNameInList(const std::vector<std::string> &kernelList,370bool SuperKernelOptionsManager::MatchKernelNameInList(const std::vector<std::string> &kernelList,
@@ -507,58 +480,41 @@ void SuperKernelOptionsManager::RegisterDefaultSkOptions() {
507}480}
508 481 
509void SuperKernelOptionsManager::RegisterDefaultInnerOptions() {482void SuperKernelOptionsManager::RegisterDefaultInnerOptions() {
510- for (int32_t i = 0; i < static_cast<int32_t>(SkInnerOptionType::SK_INNER_OPTION_MAX); ++i) {483+ for (const auto &option : DEFAULT_INNER_OPTIONS) {
511- auto type = static_cast<SkInnerOptionType>(i);484+ if (innerOptionMap.find(option.optionType) == innerOptionMap.end()) {
512- if (innerOptionMap.find(type) != innerOptionMap.end()) {485+ innerOptionMap[option.optionType] = option.factory();
513- continue;
514 }486 }
515- const auto *entry = FindDefaultInnerOptionFactory(type);
516- if (entry == nullptr) {
517- continue;
518- }
519- innerOptionMap[type] = entry->factory();
520 }487 }
521}488}
522 489 
523-void SuperKernelOptionsManager::ApplySoCSpecificOptions() {490+void SuperKernelOptionsManager::ApplyArchSpecificOptions() {
524- std::string socName = GetSocName();491+ const SkKernelArch kernelArch = GetCurrentSkKernelArch();
525- bool isDav3510 = GetCurrentSkKernelArch() == SkKernelArch::DAV_3510;492+ const auto enableOption = [this](SkInnerOptionType optionType) {
526- if (isDav3510) {493+ const auto iter = innerOptionMap.find(optionType);
527- auto *mixSplitOpt = GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);494+ if (iter != innerOptionMap.end() && iter->second != nullptr) {
528- if (mixSplitOpt != nullptr) {495+ iter->second->SetValue(1);
529- mixSplitOpt->SetValue(1);
530 }496 }
497+ };
531 498 
532- auto *simtCheckOpt = GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);499+ switch (kernelArch) {
533- if (simtCheckOpt != nullptr) {500+ case SkKernelArch::DAV_3510:
534- simtCheckOpt->SetValue(1);501+ enableOption(SkInnerOptionType::MIX_KERNEL_SPLIT);
535- }502+ enableOption(SkInnerOptionType::SIMT_OP_SUPPORT);
536- 503+ break;
537- auto *setDynUbufSizeOpt = GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);504+ case SkKernelArch::DAV_2201:
538- if (setDynUbufSizeOpt != nullptr) {505+ default:
539- setDynUbufSizeOpt->SetValue(1);506+ break;
540- }
541 }507 }
542 508 
543- SK_LOGI(509+ SK_LOGI("ApplyArchSpecificOptions: kernelArch=%s, mixKernelSplit=%d, simtOpSupport=%d", to_string(kernelArch),
544- "ApplySoCSpecificOptions: socName=%s, "510+ static_cast<int>(IsInnerOptionEnabled(SkInnerOptionType::MIX_KERNEL_SPLIT)),
545- "enableMixKernelSplit=%u, enableSimtOpCheck=%u, enableSetDynUbufSize=%u",511+ static_cast<int>(IsInnerOptionEnabled(SkInnerOptionType::SIMT_OP_SUPPORT)));
546- socName.c_str(),
547- GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT) != nullptr
548- ? GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT)->GetIntValue()
549- : 0,
550- GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK) != nullptr
551- ? GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK)->GetIntValue()
552- : 0,
553- GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE) != nullptr
554- ? GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE)->GetIntValue()
555- : 0);
556}512}
557 513 
558void SuperKernelOptionsManager::RegisterDefaultOptions() {514void SuperKernelOptionsManager::RegisterDefaultOptions() {
559 RegisterDefaultSkOptions();515 RegisterDefaultSkOptions();
560 RegisterDefaultInnerOptions();516 RegisterDefaultInnerOptions();
561- ApplySoCSpecificOptions();517+ ApplyArchSpecificOptions();
562}518}
563 519 
564void SuperKernelOptionsManager::SetOptOptionValue(const aclskOption *option) {520void SuperKernelOptionsManager::SetOptOptionValue(const aclskOption *option) {
@@ -833,30 +789,18 @@ nlohmann::ordered_json SuperKernelOptionsManager::ToJson() const {
833 }789 }
834 790 
835 nlohmann::ordered_json innerOptionsJson = nlohmann::ordered_json::object();791 nlohmann::ordered_json innerOptionsJson = nlohmann::ordered_json::object();
836- for (int32_t i = 0; i < static_cast<int32_t>(SkInnerOptionType::SK_INNER_OPTION_MAX); ++i) {792+ for (const auto &option : DEFAULT_INNER_OPTIONS) {
837- auto type = static_cast<SkInnerOptionType>(i);793+ const auto iter = innerOptionMap.find(option.optionType);
838- const auto iter = innerOptionMap.find(type);
839 if (iter == innerOptionMap.end() || iter->second == nullptr) {794 if (iter == innerOptionMap.end() || iter->second == nullptr) {
840 continue;795 continue;
841 }796 }
842 797 
843- const OptOptionBase *opt = iter->second.get();798+ const OptOptionBase *innerOption = iter->second.get();
844- nlohmann::ordered_json optJson;799+ nlohmann::ordered_json optionJson;
845- optJson["name"] = opt->GetName();800+ optionJson["name"] = innerOption->GetName();
846- optJson["type"] = static_cast<int>(type);801+ optionJson["type"] = static_cast<int>(option.optionType);
847- 802+ optionJson["value"] = IsInnerOptionEnabled(option.optionType);
848- switch (type) {803+ innerOptionsJson[innerOption->GetName()] = optionJson;
849- case SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT:
850- case SkInnerOptionType::ENABLE_SIMT_OP_CHECK:
851- case SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE:
852- optJson["value"] = opt->GetIntValue();
853- break;
854- default:
855- optJson["value"] = nullptr;
856- break;
857- }
858- 
859- innerOptionsJson[opt->GetName()] = optJson;
860 }804 }
861 optionsJson["inner_options"] = innerOptionsJson;805 optionsJson["inner_options"] = innerOptionsJson;
862 806 
Msuper_kernel/src/aot/sk_options_manager.h+5-6
@@ -240,12 +240,11 @@ class SuperKernelOptionsManager {
240 bool EnableDebug() const;240 bool EnableDebug() const;
241 241 
242 /*!242 /*!
243- * \brief Get an inner option by its type243+ * \brief Check whether an internal option is enabled
244- * \param optType The inner option type to retrieve244+ * \param optionType Internal option type
245- * \return Pointer to the option, or nullptr if not found245+ * \return True if the option is enabled
246 */246 */
247- OptOptionBase *GetOption(SkInnerOptionType optType);247+ bool IsInnerOptionEnabled(SkInnerOptionType optionType) const;
248- const OptOptionBase *GetOption(SkInnerOptionType optType) const;
249 248 
250 /*!249 /*!
251 * \brief Set option value from an aclskOption structure250 * \brief Set option value from an aclskOption structure
@@ -269,7 +268,7 @@ class SuperKernelOptionsManager {
269 void RegisterDefaultOptions();268 void RegisterDefaultOptions();
270 void RegisterDefaultSkOptions();269 void RegisterDefaultSkOptions();
271 void RegisterDefaultInnerOptions();270 void RegisterDefaultInnerOptions();
272- void ApplySoCSpecificOptions();271+ void ApplyArchSpecificOptions();
273 272 
274 std::unordered_map<aclskOptionType, std::unique_ptr<OptOptionBase>> optionMap;273 std::unordered_map<aclskOptionType, std::unique_ptr<OptOptionBase>> optionMap;
275 std::unordered_map<SkInnerOptionType, std::unique_ptr<OptOptionBase>> innerOptionMap;274 std::unordered_map<SkInnerOptionType, std::unique_ptr<OptOptionBase>> innerOptionMap;
Msuper_kernel/src/aot/sk_task_builder.cpp+27-32
@@ -131,15 +131,15 @@ SkQueueType InferFirstKernelEventQueueType(const std::vector<SuperKernelBaseNode
131 return SkQueueType::UNKNOWN;131 return SkQueueType::UNKNOWN;
132}132}
133 133 
134-struct SimtAvailableUbufInfo {134+struct SimtDcacheSizeResult {
135- bool success = true;135+ bool isValid = true;
136- bool hasMinAvailableUbufSize = false;136+ bool hasSimtTask = false;
137- size_t minAvailableUbufSize = 0;137+ size_t skMaxDcacheSize = 0;
138};138};
139 139 
140-SimtAvailableUbufInfo GetMinSimtAvailableUbufSize(const std::vector<SuperKernelBaseNode *> &tasks) {140+SimtDcacheSizeResult CalculateSimtDcacheSize(const std::vector<SuperKernelBaseNode *> &tasks) {
141- SimtAvailableUbufInfo availableUbufInfo;141+ SimtDcacheSizeResult dcacheSizeResult;
142- size_t minAvailableUbufSize = SK_TOTAL_UB_SIZE;142+ size_t skMaxDcacheSize = SK_TOTAL_UB_SIZE;
143 for (const auto *task : tasks) {143 for (const auto *task : tasks) {
144 if (task == nullptr || task->GetNodeType() != SkNodeType::NODE_KERNEL) {144 if (task == nullptr || task->GetNodeType() != SkNodeType::NODE_KERNEL) {
145 continue;145 continue;
@@ -148,11 +148,12 @@ SimtAvailableUbufInfo GetMinSimtAvailableUbufSize(const std::vector<SuperKernelB
148 if (!kernelInfo.isSimtOp) {148 if (!kernelInfo.isSimtOp) {
149 continue;149 continue;
150 }150 }
151+ dcacheSizeResult.hasSimtTask = true;
151 if (!kernelInfo.hasDynUbufSize || !kernelInfo.hasAllocUbufSize) {152 if (!kernelInfo.hasDynUbufSize || !kernelInfo.hasAllocUbufSize) {
152 SK_LOGE("SIMT kernel lacks ubuf size info, nodeId=%lu, hasDynUbufSize=%d, hasAllocUbufSize=%d", task->GetNodeId(),153 SK_LOGE("SIMT kernel lacks ubuf size info, nodeId=%lu, hasDynUbufSize=%d, hasAllocUbufSize=%d", task->GetNodeId(),
153 kernelInfo.hasDynUbufSize, kernelInfo.hasAllocUbufSize);154 kernelInfo.hasDynUbufSize, kernelInfo.hasAllocUbufSize);
154- availableUbufInfo.success = false;155+ dcacheSizeResult.isValid = false;
155- return availableUbufInfo;156+ return dcacheSizeResult;
156 }157 }
157 if (kernelInfo.dynUbufSize > SK_TOTAL_UB_SIZE ||158 if (kernelInfo.dynUbufSize > SK_TOTAL_UB_SIZE ||
158 kernelInfo.allocUbufSize > SK_TOTAL_UB_SIZE - kernelInfo.dynUbufSize) {159 kernelInfo.allocUbufSize > SK_TOTAL_UB_SIZE - kernelInfo.dynUbufSize) {
@@ -160,17 +161,16 @@ SimtAvailableUbufInfo GetMinSimtAvailableUbufSize(const std::vector<SuperKernelB
160 "SIMT kernel ubuf size exceeds total ub size, nodeId=%lu, dynUbufSize=%zu, "161 "SIMT kernel ubuf size exceeds total ub size, nodeId=%lu, dynUbufSize=%zu, "
161 "allocUbufSize=%zu, totalUbSize=%zu",162 "allocUbufSize=%zu, totalUbSize=%zu",
162 task->GetNodeId(), kernelInfo.dynUbufSize, kernelInfo.allocUbufSize, SK_TOTAL_UB_SIZE);163 task->GetNodeId(), kernelInfo.dynUbufSize, kernelInfo.allocUbufSize, SK_TOTAL_UB_SIZE);
163- availableUbufInfo.success = false;164+ dcacheSizeResult.isValid = false;
164- return availableUbufInfo;165+ return dcacheSizeResult;
165 }166 }
166- availableUbufInfo.hasMinAvailableUbufSize = true;167+ size_t taskMaxDcacheSize = SK_TOTAL_UB_SIZE - kernelInfo.dynUbufSize - kernelInfo.allocUbufSize;
167- minAvailableUbufSize =168+ skMaxDcacheSize = std::min(skMaxDcacheSize, taskMaxDcacheSize);
S
Ssjtulxh18 天前

这个语义看起来很奇怪啊，叫的是max， 求得是min

likedislike
yrz1027
yrz1027
18 天前 评论：
168- std::min(minAvailableUbufSize, SK_TOTAL_UB_SIZE - kernelInfo.dynUbufSize - kernelInfo.allocUbufSize);
169 }169 }
170- if (availableUbufInfo.hasMinAvailableUbufSize) {170+ if (dcacheSizeResult.hasSimtTask) {
171- availableUbufInfo.minAvailableUbufSize = minAvailableUbufSize;171+ dcacheSizeResult.skMaxDcacheSize = skMaxDcacheSize;
172 }172 }
173- return availableUbufInfo;173+ return dcacheSizeResult;
174}174}
175 175 
176bool MatchKernelOption(const SuperKernelOptionsManager &opts, const std::vector<std::string> &kernelList,176bool MatchKernelOption(const SuperKernelOptionsManager &opts, const std::vector<std::string> &kernelList,
@@ -2412,8 +2412,7 @@ SkBuildResult SkTaskBuilder::Build(std::string skFuncName, const std::vector<Sup
2412 splitBinCount = splitOptions->GetIntValue();2412 splitBinCount = splitOptions->GetIntValue();
2413 }2413 }
2414 2414 
2415- auto *mixSplitOpt = opts.GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);2415+ if (opts.IsInnerOptionEnabled(SkInnerOptionType::MIX_KERNEL_SPLIT)) {
2416- if (mixSplitOpt != nullptr && mixSplitOpt->GetIntValue() == 1) {
2417 if (!PrecomputeSyncRelationsByMixGroups(tasks)) {2416 if (!PrecomputeSyncRelationsByMixGroups(tasks)) {
2418 SK_LOGE("Build failed: precompute sync relations with mix kernel split failed");2417 SK_LOGE("Build failed: precompute sync relations with mix kernel split failed");
2419 return {};2418 return {};
@@ -2644,16 +2643,15 @@ SkBuildResult SkTaskBuilder::Build(std::string skFuncName, const std::vector<Sup
2644 }2643 }
2645 2644 
2646 bool useSimtEntry = false;2645 bool useSimtEntry = false;
2647- size_t minAvailableUbufSize = 0;2646+ size_t skMaxDcacheSize = 0;
2648- const auto *setDynUbufSizeOpt = opts.GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);2647+ if (opts.IsInnerOptionEnabled(SkInnerOptionType::SIMT_OP_SUPPORT)) {
2649- if (setDynUbufSizeOpt != nullptr && setDynUbufSizeOpt->GetIntValue() == 1) {2648+ const SimtDcacheSizeResult dcacheSizeResult = CalculateSimtDcacheSize(tasks);
2650- const SimtAvailableUbufInfo availableUbufInfo = GetMinSimtAvailableUbufSize(tasks);2649+ if (!dcacheSizeResult.isValid) {
2651- if (!availableUbufInfo.success) {2650+ SK_LOGE("Build failed: SIMT ubuf size validation failed");
2652- SK_LOGE("Build failed: get SIMT min available ubuf size failed");
2653 return {};2651 return {};
2654 }2652 }
2655- useSimtEntry = availableUbufInfo.hasMinAvailableUbufSize;2653+ useSimtEntry = dcacheSizeResult.hasSimtTask;
2656- minAvailableUbufSize = availableUbufInfo.minAvailableUbufSize;2654+ skMaxDcacheSize = dcacheSizeResult.skMaxDcacheSize;
2657 }2655 }
2658 2656 
2659 SK_LOGI("Get entry info...");2657 SK_LOGI("Get entry info...");
@@ -2677,11 +2675,8 @@ SkBuildResult SkTaskBuilder::Build(std::string skFuncName, const std::vector<Sup
2677 launchInfo.entryInfo = std::move(entryInfo);2675 launchInfo.entryInfo = std::move(entryInfo);
2678 launchInfo.devArgs = std::move(devArgs);2676 launchInfo.devArgs = std::move(devArgs);
2679 launchInfo.skFuncName = skFuncName;2677 launchInfo.skFuncName = skFuncName;
2680- launchInfo.hasMinAvailableUbufSize = useSimtEntry;2678+ launchInfo.useSimtEntry = useSimtEntry;
2681- launchInfo.minAvailableUbufSize = minAvailableUbufSize;2679+ launchInfo.skMaxDcacheSize = skMaxDcacheSize;
2682- if (useSimtEntry) {
2683- SK_LOGI("Build launch info with SIMT min available ubuf size, minAvailableUbufSize=%zu", minAvailableUbufSize);
2684- }
2685 2680 
2686 // Generate task queue JSON for aggregation2681 // Generate task queue JSON for aggregation
2687 SK_LOGI("SkTaskToQueueJson: generating task queue JSON for scopeId=%u", scopeId);2682 SK_LOGI("SkTaskToQueueJson: generating task queue JSON for scopeId=%u", scopeId);
Msuper_kernel/src/aot/sk_types.h+6-6
@@ -212,7 +212,7 @@ struct SkTask {
212 return sizeof(TaskQue) + queue->taskCnt * sizeof(TaskInfo);212 return sizeof(TaskQue) + queue->taskCnt * sizeof(TaskInfo);
213 }213 }
214 214 
215- SkTask() : numBlocks(0), funcCnt(0){};215+ SkTask() : numBlocks(0), funcCnt(0) {};
216 SkTask(const SkTask &) = delete;216 SkTask(const SkTask &) = delete;
217 SkTask &operator=(const SkTask &) = delete;217 SkTask &operator=(const SkTask &) = delete;
218 SkTask(SkTask &&) = default;218 SkTask(SkTask &&) = default;
@@ -258,11 +258,11 @@ struct SkHostEntryInfo {
258struct CacheopInfoBasic {258struct CacheopInfoBasic {
259 uint32_t taskType; // 算子的任务类型259 uint32_t taskType; // 算子的任务类型
260 uint32_t numBlocks; // blockdim260 uint32_t numBlocks; // blockdim
261- uint64_t nodeId; //算子名的hashid261+ uint64_t nodeId; // 算子名的hashid
262- uint64_t opType; //算子类型的hashid262+ uint64_t opType; // 算子类型的hashid
263 uint64_t attrId{0}; // 本次attr拼接放这里263 uint64_t attrId{0}; // 本次attr拼接放这里
264 uint64_t reserve2{0}; // 不做处理264 uint64_t reserve2{0}; // 不做处理
265- uint32_t opFlag; //记录op属性标记的bitmap，bit0代表是否使能了HF32265+ uint32_t opFlag; // 记录op属性标记的bitmap，bit0代表是否使能了HF32
266 uint32_t tensorNum; // tensor个数266 uint32_t tensorNum; // tensor个数
267 MsrofTensorData tensorData[0];267 MsrofTensorData tensorData[0];
268};268};
@@ -273,8 +273,8 @@ struct SkLaunchInfo {
273 void *273 void *
274 cacheInfo; // sk融合算子的shape信息，由sk_optimizer.cpp在构建launchInfo时填充，实际类型是CacheopInfoBasic，包含一个可变长度的tensorData数组274 cacheInfo; // sk融合算子的shape信息，由sk_optimizer.cpp在构建launchInfo时填充，实际类型是CacheopInfoBasic，包含一个可变长度的tensorData数组
275 size_t cacheopInfoSize;275 size_t cacheopInfoSize;
276- size_t minAvailableUbufSize = 0;276+ size_t skMaxDcacheSize = 0; // 所有 SIMT 子任务共同允许的最大 DCache 大小
277- bool hasMinAvailableUbufSize = false;277+ bool useSimtEntry = false; // 是否选择 SIMT entry 并配置对应的动态 UBUF
278 void *eventGmAddr; // 事件记录 GM 地址278 void *eventGmAddr; // 事件记录 GM 地址
279 uint64_t modelIdIndex{0}; // modelId index registered on host279 uint64_t modelIdIndex{0}; // modelId index registered on host
280 uint32_t skId; // SK 标识280 uint32_t skId; // SK 标识
Msuper_kernel/tests/aot/ut/test_sk_node.cpp+39-50
@@ -47,6 +47,10 @@ std::unique_ptr<aclmdlRITask> MakeTaskHandle(TestRITask &task) {
47 return std::make_unique<aclmdlRITask>(reinterpret_cast<aclmdlRITask>(&task));47 return std::make_unique<aclmdlRITask>(reinterpret_cast<aclmdlRITask>(&task));
48}48}
49 49 
50+void SetSimtOpSupportCapability(SuperKernelOptionsManager &options, uint32_t value) {
51+ options.innerOptionMap[SkInnerOptionType::SIMT_OP_SUPPORT]->SetValue(value);
52+}
53+ 
50} // namespace54} // namespace
51 55 
52class SkNodeTest : public testing::Test {56class SkNodeTest : public testing::Test {
@@ -624,6 +628,9 @@ TEST_F(SkNodeTest, KernelUpdate_LaunchInfoDynUbufAppendsLaunchCfg) {
624 task.params.type = ACL_MODEL_RI_TASK_KERNEL;628 task.params.type = ACL_MODEL_RI_TASK_KERNEL;
625 task.params.kernelTaskParams.funcHandle = reinterpret_cast<aclrtFuncHandle>(0x3018);629 task.params.kernelTaskParams.funcHandle = reinterpret_cast<aclrtFuncHandle>(0x3018);
626 task.params.kernelTaskParams.numBlocks = 1;630 task.params.kernelTaskParams.numBlocks = 1;
631+ task.params.reserved0[0] = 0x12;
632+ task.params.reserved1[0] = 0x34;
633+ task.params.kernelTaskParams.rsv[0] = 0x56;
627 634 
628 aclrtLaunchKernelAttr originAttr{};635 aclrtLaunchKernelAttr originAttr{};
629 originAttr.id = ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE;636 originAttr.id = ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE;
@@ -644,22 +651,33 @@ TEST_F(SkNodeTest, KernelUpdate_LaunchInfoDynUbufAppendsLaunchCfg) {
644 launchInfo.entryInfo.numBlocks = 2;651 launchInfo.entryInfo.numBlocks = 2;
645 ASSERT_TRUE(launchInfo.devArgs.Init(sizeof(SkDeviceEntryArgs)));652 ASSERT_TRUE(launchInfo.devArgs.Init(sizeof(SkDeviceEntryArgs)));
646 launchInfo.devArgs.Get()->skHeader.totalSize = sizeof(SkDeviceEntryArgs);653 launchInfo.devArgs.Get()->skHeader.totalSize = sizeof(SkDeviceEntryArgs);
647- launchInfo.hasMinAvailableUbufSize = true;654+ launchInfo.useSimtEntry = true;
648- launchInfo.minAvailableUbufSize = 32768;655+ launchInfo.skMaxDcacheSize = 32768;
649 SetFunctionAllocUbufSize(4096);656 SetFunctionAllocUbufSize(4096);
650 657 
658+ std::vector<aclrtLaunchKernelAttr> launchKernelAttrs;
659+ aclrtLaunchKernelCfg launchKernelCfg{};
660+ ASSERT_TRUE(node.SetupLaunchKernelCfg(task.params.kernelTaskParams.funcHandle, launchInfo.skMaxDcacheSize,
661+ launchKernelAttrs, launchKernelCfg));
662+ ASSERT_EQ(launchKernelCfg.numAttrs, 2U);
663+ ASSERT_NE(launchKernelCfg.attrs, nullptr);
664+ EXPECT_EQ(launchKernelCfg.attrs[0].id, ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE);
665+ EXPECT_EQ(launchKernelCfg.attrs[0].value.schemMode, 1U);
666+ EXPECT_EQ(launchKernelCfg.attrs[1].id, ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE);
667+ EXPECT_EQ(launchKernelCfg.attrs[1].value.dynUBufSize, SK_TOTAL_UB_SIZE - 32768U - 4096U);
668+ 
651 UpdateContext ctx{};669 UpdateContext ctx{};
652 ctx.launchInfo = &launchInfo;670 ctx.launchInfo = &launchInfo;
653 EXPECT_TRUE(node.Update(ctx));671 EXPECT_TRUE(node.Update(ctx));
654 672 
655 const auto &params = node.GetTaskParams();673 const auto &params = node.GetTaskParams();
656- ASSERT_NE(params.kernelTaskParams.cfg, nullptr);674+ EXPECT_EQ(params.kernelTaskParams.cfg, &originCfg);
657- ASSERT_EQ(params.kernelTaskParams.cfg->numAttrs, 2U);675+ EXPECT_EQ(params.reserved0[0], 0x12U);
658- ASSERT_NE(params.kernelTaskParams.cfg->attrs, nullptr);676+ EXPECT_EQ(params.reserved1[0], 0x34U);
659- EXPECT_EQ(params.kernelTaskParams.cfg->attrs[0].id, ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE);677+ EXPECT_EQ(params.kernelTaskParams.rsv[0], 0x56U);
660- EXPECT_EQ(params.kernelTaskParams.cfg->attrs[0].value.schemMode, 1U);678+ EXPECT_EQ(task.params.reserved0[0], 0x12U);
661- EXPECT_EQ(params.kernelTaskParams.cfg->attrs[1].id, ACL_RT_LAUNCH_KERNEL_ATTR_DYN_UBUF_SIZE);679+ EXPECT_EQ(task.params.reserved1[0], 0x34U);
662- EXPECT_EQ(params.kernelTaskParams.cfg->attrs[1].value.dynUBufSize, SK_TOTAL_UB_SIZE - 32768U - 4096U);680+ EXPECT_EQ(task.params.kernelTaskParams.rsv[0], 0x56U);
663}681}
664 682 
665TEST_F(SkNodeTest, MemoryUpdate_CustomParamsSyncTaskParamsForDump) {683TEST_F(SkNodeTest, MemoryUpdate_CustomParamsSyncTaskParamsForDump) {
@@ -1998,7 +2016,7 @@ aclError FakeAclrtGetFunctionAttributeMix12(aclrtFuncHandle funcHandle, aclrtFun
1998 return ACL_SUCCESS;2016 return ACL_SUCCESS;
1999}2017}
2000 2018 
2001-TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_NullOpts_SkipCheck) {2019+TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_NullOptions_SkipCheck) {
2002 UtSkNodeRITaskInternal task{};2020 UtSkNodeRITaskInternal task{};
2003 task.taskId = 2001;2021 task.taskId = 2001;
2004 task.type = ACL_MODEL_RI_TASK_KERNEL;2022 task.type = ACL_MODEL_RI_TASK_KERNEL;
@@ -2015,7 +2033,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_NullOpts_SkipCheck) {
2015 EXPECT_FALSE(node.nodeInfos.kernelInfos.isSimtOp);2033 EXPECT_FALSE(node.nodeInfos.kernelInfos.isSimtOp);
2016}2034}
2017 2035 
2018-TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_SimtCheckDisabled_SkipCheck) {2036+TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_SimtOpSupportDisabled_SkipAnalysis) {
2019 UtSkNodeRITaskInternal task{};2037 UtSkNodeRITaskInternal task{};
2020 task.taskId = 2002;2038 task.taskId = 2002;
2021 task.type = ACL_MODEL_RI_TASK_KERNEL;2039 task.type = ACL_MODEL_RI_TASK_KERNEL;
@@ -2025,9 +2043,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_SimtCheckDisabled_SkipCheck) {
2025 2043 
2026 SuperKernelOptionsManager opts;2044 SuperKernelOptionsManager opts;
2027 opts.RegisterDefaultOptions();2045 opts.RegisterDefaultOptions();
2028- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2046+ SetSimtOpSupportCapability(opts, 0);
2029- ASSERT_NE(simtOpt, nullptr);
2030- simtOpt->SetValue(0);
2031 2047 
2032 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));2048 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));
2033 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeAivOnly));2049 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeAivOnly));
@@ -2048,10 +2064,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_AicOnly_SkipCheck) {
2048 2064 
2049 SuperKernelOptionsManager opts;2065 SuperKernelOptionsManager opts;
2050 opts.RegisterDefaultOptions();2066 opts.RegisterDefaultOptions();
2051- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2067+ SetSimtOpSupportCapability(opts, 1);
2052- ASSERT_NE(simtOpt, nullptr);
2053- simtOpt->SetValue(1);
2054- 
2055 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));2068 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));
2056 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeAicOnly));2069 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeAicOnly));
2057 MOCKER(aclrtFunctionGetBinary).stubs().will(invoke(FakeAclrtFunctionGetBinaryNonNull));2070 MOCKER(aclrtFunctionGetBinary).stubs().will(invoke(FakeAclrtFunctionGetBinaryNonNull));
@@ -2072,10 +2085,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_MixAic10_SkipCheck) {
2072 2085 
2073 SuperKernelOptionsManager opts;2086 SuperKernelOptionsManager opts;
2074 opts.RegisterDefaultOptions();2087 opts.RegisterDefaultOptions();
2075- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2088+ SetSimtOpSupportCapability(opts, 1);
2076- ASSERT_NE(simtOpt, nullptr);
2077- simtOpt->SetValue(1);
2078- 
2079 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));2089 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));
2080 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeMixAic10));2090 MOCKER(aclrtGetFunctionAttribute).stubs().will(invoke(FakeAclrtGetFunctionAttributeMixAic10));
2081 MOCKER(aclrtFunctionGetBinary).stubs().will(invoke(FakeAclrtFunctionGetBinaryNonNull));2091 MOCKER(aclrtFunctionGetBinary).stubs().will(invoke(FakeAclrtFunctionGetBinaryNonNull));
@@ -2096,10 +2106,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_AivOnly_NotSimtType) {
2096 2106 
2097 SuperKernelOptionsManager opts;2107 SuperKernelOptionsManager opts;
2098 opts.RegisterDefaultOptions();2108 opts.RegisterDefaultOptions();
2099- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2109+ SetSimtOpSupportCapability(opts, 1);
2100- ASSERT_NE(simtOpt, nullptr);
2101- simtOpt->SetValue(1);
2102- 
2103 SetSimtAivType(0);2110 SetSimtAivType(0);
2104 2111 
2105 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));2112 MOCKER(aclrtGetFunctionName).stubs().will(invoke(FakeAclrtGetFunctionNameRegular));
@@ -2122,10 +2129,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_AivOnly_SimtType3) {
2122 2129 
2123 SuperKernelOptionsManager opts;2130 SuperKernelOptionsManager opts;
2124 opts.RegisterDefaultOptions();2131 opts.RegisterDefaultOptions();
2125- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2132+ SetSimtOpSupportCapability(opts, 1);
2126- ASSERT_NE(simtOpt, nullptr);
2127- simtOpt->SetValue(1);
2128- 
2129 SetSimtAivType(3);2133 SetSimtAivType(3);
2130 SkUtSetAclrtFunctionAvailDynUbufSize(4096);2134 SkUtSetAclrtFunctionAvailDynUbufSize(4096);
2131 SetFunctionAllocUbufSize(1024);2135 SetFunctionAllocUbufSize(1024);
@@ -2161,10 +2165,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_AivOnly_SimtType4) {
2161 2165 
2162 SuperKernelOptionsManager opts;2166 SuperKernelOptionsManager opts;
2163 opts.RegisterDefaultOptions();2167 opts.RegisterDefaultOptions();
2164- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2168+ SetSimtOpSupportCapability(opts, 1);
2165- ASSERT_NE(simtOpt, nullptr);
2166- simtOpt->SetValue(1);
2167- 
2168 SetSimtAivType(4);2169 SetSimtAivType(4);
2169 SkUtSetAclrtFunctionAvailDynUbufSize(8192);2170 SkUtSetAclrtFunctionAvailDynUbufSize(8192);
2170 SetFunctionAllocUbufSize(2048);2171 SetFunctionAllocUbufSize(2048);
@@ -2200,10 +2201,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_Mix11_SimtType) {
2200 2201 
2201 SuperKernelOptionsManager opts;2202 SuperKernelOptionsManager opts;
2202 opts.RegisterDefaultOptions();2203 opts.RegisterDefaultOptions();
2203- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2204+ SetSimtOpSupportCapability(opts, 1);
2204- ASSERT_NE(simtOpt, nullptr);
2205- simtOpt->SetValue(1);
2206- 
2207 SetSimtAivType(3);2205 SetSimtAivType(3);
2208 SkUtSetAclrtFunctionAvailDynUbufSize(12288);2206 SkUtSetAclrtFunctionAvailDynUbufSize(12288);
2209 SetFunctionAllocUbufSize(4096);2207 SetFunctionAllocUbufSize(4096);
@@ -2239,10 +2237,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_Mix12_SimtType) {
2239 2237 
2240 SuperKernelOptionsManager opts;2238 SuperKernelOptionsManager opts;
2241 opts.RegisterDefaultOptions();2239 opts.RegisterDefaultOptions();
2242- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2240+ SetSimtOpSupportCapability(opts, 1);
2243- ASSERT_NE(simtOpt, nullptr);
2244- simtOpt->SetValue(1);
2245- 
2246 SetSimtAivType(4);2241 SetSimtAivType(4);
2247 SkUtSetAclrtFunctionAvailDynUbufSize(16384);2242 SkUtSetAclrtFunctionAvailDynUbufSize(16384);
2248 SetFunctionAllocUbufSize(8192);2243 SetFunctionAllocUbufSize(8192);
@@ -2278,10 +2273,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_DynUbufQueryFailed) {
2278 2273 
2279 SuperKernelOptionsManager opts;2274 SuperKernelOptionsManager opts;
2280 opts.RegisterDefaultOptions();2275 opts.RegisterDefaultOptions();
2281- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2276+ SetSimtOpSupportCapability(opts, 1);
2282- ASSERT_NE(simtOpt, nullptr);
2283- simtOpt->SetValue(1);
2284- 
2285 SetSimtAivType(3);2277 SetSimtAivType(3);
2286 SkUtSetAclrtFunctionGetAvailDynUbufPerBlockRet(ACL_ERROR_FAILURE);2278 SkUtSetAclrtFunctionGetAvailDynUbufPerBlockRet(ACL_ERROR_FAILURE);
2287 2279 
@@ -2307,10 +2299,7 @@ TEST_F(SkNodeTest, IdentifyAndHandleSimtKernel_AllocUbufQueryFailed) {
2307 2299 
2308 SuperKernelOptionsManager opts;2300 SuperKernelOptionsManager opts;
2309 opts.RegisterDefaultOptions();2301 opts.RegisterDefaultOptions();
2310- auto *simtOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);2302+ SetSimtOpSupportCapability(opts, 1);
2311- ASSERT_NE(simtOpt, nullptr);
2312- simtOpt->SetValue(1);
2313- 
2314 SetSimtAivType(3);2303 SetSimtAivType(3);
2315 SkUtSetAclrtFunctionAvailDynUbufSize(4096);2304 SkUtSetAclrtFunctionAvailDynUbufSize(4096);
2316 SetRtFunctionGetMetaInfoRet(-1);2305 SetRtFunctionGetMetaInfoRet(-1);
Msuper_kernel/tests/aot/ut/test_sk_options_manager.cpp+24-112
@@ -41,6 +41,16 @@ class SuperKernelOptionsManagerTest : public testing::Test {
41 std::unique_ptr<SuperKernelOptionsManager> opts_test;41 std::unique_ptr<SuperKernelOptionsManager> opts_test;
42};42};
43 43 
44+namespace {
45+SkKernelArch FakeGetCurrentSkKernelArchDav3510() {
46+ return SkKernelArch::DAV_3510;
47+}
48+ 
49+SkKernelArch FakeGetCurrentSkKernelArchDav2201() {
50+ return SkKernelArch::DAV_2201;
51+}
52+} // namespace
53+ 
44// ==================== OptOptionBase 基类测试 ====================54// ==================== OptOptionBase 基类测试 ====================
45 55 
46TEST_F(SuperKernelOptionsManagerTest, OptOptionBase_GetName) {56TEST_F(SuperKernelOptionsManagerTest, OptOptionBase_GetName) {
@@ -1409,129 +1419,31 @@ TEST_F(SuperKernelOptionsManagerTest, ToJson_UbufLockIgnoreKernelNullKernelList)
1409 EXPECT_TRUE(json["ubuf_lock_ignore_kernel"]["value"].empty());1419 EXPECT_TRUE(json["ubuf_lock_ignore_kernel"]["value"].empty());
1410}1420}
1411 1421 
1412-TEST_F(SuperKernelOptionsManagerTest, GetInnerOption_EnableMixKernelSplit) {1422+TEST_F(SuperKernelOptionsManagerTest, InnerOptions_Dav2201Disabled) {
1423+ MOCKER(GetCurrentSkKernelArch).stubs().will(invoke(FakeGetCurrentSkKernelArchDav2201));
1413 opts_test->RegisterDefaultOptions();1424 opts_test->RegisterDefaultOptions();
1414- auto *opt = opts_test->GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);
1415- ASSERT_NE(opt, nullptr);
1416- EXPECT_EQ(opt->GetName(), "enable_mix_kernel_split");
1417- EXPECT_EQ(opt->GetIntValue(), 0);
1418-}
1419 1425 
1420-TEST_F(SuperKernelOptionsManagerTest, GetInnerOption_EnableSimtOpCheck) {1426+ EXPECT_FALSE(opts_test->IsInnerOptionEnabled(SkInnerOptionType::MIX_KERNEL_SPLIT));
1421- opts_test->RegisterDefaultOptions();1427+ EXPECT_FALSE(opts_test->IsInnerOptionEnabled(SkInnerOptionType::SIMT_OP_SUPPORT));
1422- auto *opt = opts_test->GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);1428+ EXPECT_FALSE(opts_test->IsInnerOptionEnabled(static_cast<SkInnerOptionType>(100)));
1423- ASSERT_NE(opt, nullptr);
1424- EXPECT_EQ(opt->GetName(), "enable_simt_op_check");
1425- EXPECT_EQ(opt->GetIntValue(), 0);
1426-}
1427 1429 
1428-TEST_F(SuperKernelOptionsManagerTest, GetInnerOption_EnableSetDynUbufSize) {
1429- opts_test->RegisterDefaultOptions();
1430- auto *opt = opts_test->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);
1431- ASSERT_NE(opt, nullptr);
1432- EXPECT_EQ(opt->GetName(), "enable_set_dyn_ubuf_size");
1433- EXPECT_EQ(opt->GetIntValue(), 0);
1434-}
1435- 
1436-TEST_F(SuperKernelOptionsManagerTest, GetInnerOption_InvalidType) {
1437- opts_test->RegisterDefaultOptions();
1438- auto *opt = opts_test->GetOption(static_cast<SkInnerOptionType>(100));
1439- EXPECT_EQ(opt, nullptr);
1440-}
1441- 
1442-TEST_F(SuperKernelOptionsManagerTest, ToJson_InnerOptionsContent) {
1443- opts_test->RegisterDefaultOptions();
1444 nlohmann::ordered_json json = opts_test->ToJson();1430 nlohmann::ordered_json json = opts_test->ToJson();
1445 ASSERT_TRUE(json.contains("inner_options"));1431 ASSERT_TRUE(json.contains("inner_options"));
1446- EXPECT_TRUE(json["inner_options"].contains("enable_mix_kernel_split"));1432+ EXPECT_FALSE(json["inner_options"]["mix_kernel_split"]["value"]);
1447- EXPECT_TRUE(json["inner_options"].contains("enable_simt_op_check"));1433+ EXPECT_FALSE(json["inner_options"]["simt_op_support"]["value"]);
1448- EXPECT_TRUE(json["inner_options"].contains("enable_set_dyn_ubuf_size"));
1449- EXPECT_EQ(json["inner_options"]["enable_mix_kernel_split"]["value"], 0);
1450- EXPECT_EQ(json["inner_options"]["enable_simt_op_check"]["value"], 0);
1451- EXPECT_EQ(json["inner_options"]["enable_set_dyn_ubuf_size"]["value"], 0);
1452}1434}
1453 1435 
1454-TEST_F(SuperKernelOptionsManagerTest, ApplySoCSpecificOptions_NonAscend950) {1436+TEST_F(SuperKernelOptionsManagerTest, InnerOptions_Dav3510Enabled) {
1437+ MOCKER(GetCurrentSkKernelArch).stubs().will(invoke(FakeGetCurrentSkKernelArchDav3510));
1455 opts_test->RegisterDefaultOptions();1438 opts_test->RegisterDefaultOptions();
1456- auto *mixSplitOpt = opts_test->GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);
1457- auto *simtCheckOpt = opts_test->GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);
1458- auto *setDynUbufSizeOpt = opts_test->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);
1459- ASSERT_NE(mixSplitOpt, nullptr);
1460- ASSERT_NE(simtCheckOpt, nullptr);
1461- ASSERT_NE(setDynUbufSizeOpt, nullptr);
1462- EXPECT_EQ(mixSplitOpt->GetIntValue(), 0);
1463- EXPECT_EQ(simtCheckOpt->GetIntValue(), 0);
1464- EXPECT_EQ(setDynUbufSizeOpt->GetIntValue(), 0);
1465-}
1466 1439 
1467-namespace {1440+ EXPECT_TRUE(opts_test->IsInnerOptionEnabled(SkInnerOptionType::MIX_KERNEL_SPLIT));
1468-const char *FakeSocName_Ascend950ForOptions() {1441+ EXPECT_TRUE(opts_test->IsInnerOptionEnabled(SkInnerOptionType::SIMT_OP_SUPPORT));
1469- return "Ascend950";
1470-}
1471-const char *FakeSocName_Ascend950Variant() {
1472- return "Ascend950PG";
1473-}
1474- 
1475-void ExpectAscend950OptionsEnabled(const char *(*socNameStub)()) {
1476- MOCKER(aclrtGetSocName).stubs().will(invoke(socNameStub));
1477- InitSkRuntimeConfig();
1478- 
1479- SuperKernelOptionsManager opts;
1480- opts.RegisterDefaultOptions();
1481- auto *mixSplitOpt = opts.GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);
1482- auto *simtCheckOpt = opts.GetOption(SkInnerOptionType::ENABLE_SIMT_OP_CHECK);
1483- auto *setDynUbufSizeOpt = opts.GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);
1484- ASSERT_NE(mixSplitOpt, nullptr);
1485- ASSERT_NE(simtCheckOpt, nullptr);
1486- ASSERT_NE(setDynUbufSizeOpt, nullptr);
1487- EXPECT_EQ(mixSplitOpt->GetIntValue(), 1);
1488- EXPECT_EQ(simtCheckOpt->GetIntValue(), 1);
1489- EXPECT_EQ(setDynUbufSizeOpt->GetIntValue(), 1);
1490- 
1491- nlohmann::ordered_json json = opts.ToJson();
1492- ASSERT_TRUE(json.contains("inner_options"));
1493- EXPECT_EQ(json["inner_options"]["enable_mix_kernel_split"]["value"], 1);
1494- EXPECT_EQ(json["inner_options"]["enable_simt_op_check"]["value"], 1);
1495- EXPECT_EQ(json["inner_options"]["enable_set_dyn_ubuf_size"]["value"], 1);
1496-}
1497- 
1498-void ExitIsolatedOptionsTest() {
1499- GlobalMockObject::verify();
1500- fflush(nullptr);
1501- _exit(::testing::Test::HasFailure() ? 1 : 0);
1502-}
1503-} // namespace
1504- 
1505-TEST_F(SuperKernelOptionsManagerTest, ApplySoCSpecificOptions_Ascend950EnablesDav3510InnerOptions) {
1506- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
1507- ASSERT_EXIT(
1508- {
1509- ExpectAscend950OptionsEnabled(FakeSocName_Ascend950ForOptions);
1510- ExitIsolatedOptionsTest();
1511- },
1512- ::testing::ExitedWithCode(0), "");
1513-}
1514- 
1515-TEST_F(SuperKernelOptionsManagerTest, ApplySoCSpecificOptions_Ascend950SuffixVariantStillEnables) {
1516- // 防回归：未来如果 GetSocName 返回带后缀的 "Ascend950XXX"，仍应命中
1517- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
1518- ASSERT_EXIT(
1519- {
1520- ExpectAscend950OptionsEnabled(FakeSocName_Ascend950Variant);
1521- ExitIsolatedOptionsTest();
1522- },
1523- ::testing::ExitedWithCode(0), "");
1524-}
1525- 
1526-TEST_F(SuperKernelOptionsManagerTest, SetInnerOptionValue) {
1527- opts_test->RegisterDefaultOptions();
1528- auto *opt = opts_test->GetOption(SkInnerOptionType::ENABLE_MIX_KERNEL_SPLIT);
1529- ASSERT_NE(opt, nullptr);
1530- opt->SetValue(1);
1531- EXPECT_EQ(opt->GetIntValue(), 1);
1532 1442 
1533 nlohmann::ordered_json json = opts_test->ToJson();1443 nlohmann::ordered_json json = opts_test->ToJson();
1534- EXPECT_EQ(json["inner_options"]["enable_mix_kernel_split"]["value"], 1);1444+ ASSERT_TRUE(json.contains("inner_options"));
1445+ EXPECT_TRUE(json["inner_options"]["mix_kernel_split"]["value"]);
1446+ EXPECT_TRUE(json["inner_options"]["simt_op_support"]["value"]);
1535}1447}
1536 1448 
1537// ==================== SetOptOptionValue: DEBUG_PER_OP_MAX_CORE_NUM 测试 ====================1449// ==================== SetOptOptionValue: DEBUG_PER_OP_MAX_CORE_NUM 测试 ====================
Msuper_kernel/tests/aot/ut/test_sk_task_builder.cpp+23-21
@@ -1,6 +1,6 @@
1/**1/**
2 * Copyright (c) 2025 Huawei Technologies Co., Ltd.2 * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3- * This program is free software, you can redistribute it and/or modify it under terms and conditions of3+ * 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").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.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,6 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
@@ -22,6 +22,15 @@
22#include "sk_node.h"22#include "sk_node.h"
23#include "stub/ut_common_stubs.h"23#include "stub/ut_common_stubs.h"
24 24 
25+namespace {
26+ 
27+void SetInnerOption(SuperKernelOptionsManager &options, SkInnerOptionType optionType, uint32_t value) {
28+ options.RegisterDefaultInnerOptions();
29+ options.innerOptionMap[optionType]->SetValue(value);
30+}
31+ 
32+} // namespace
33+ 
25class SkTaskBuilderTest : public testing::Test {34class SkTaskBuilderTest : public testing::Test {
26 protected:35 protected:
27 void SetUp() override {36 void SetUp() override {
@@ -769,6 +778,7 @@ TEST_F(SkTaskBuilderTest, SyncOptimizationAndDispatchSyncBranches) {
769 778 
770TEST_F(SkTaskBuilderTest, Build_WithCustomNotifyWaitReset_Success) {779TEST_F(SkTaskBuilderTest, Build_WithCustomNotifyWaitReset_Success) {
771 opts->AddOption(std::make_unique<NumberOptOption>("split_mode", aclskOptionType::SPLIT_MODE, 1, 1, 4));780 opts->AddOption(std::make_unique<NumberOptOption>("split_mode", aclskOptionType::SPLIT_MODE, 1, 1, 4));
781+ SetInnerOption(*opts, SkInnerOptionType::MIX_KERNEL_SPLIT, 1);
772 782 
773 auto *k0 = CreateKernelNodeEx(7001, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::MIX_AIC_1_1);783 auto *k0 = CreateKernelNodeEx(7001, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::MIX_AIC_1_1);
774 auto *k1 = CreateKernelNodeEx(7002, 1, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::MIX_AIC_1_2);784 auto *k1 = CreateKernelNodeEx(7002, 1, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::MIX_AIC_1_2);
@@ -788,14 +798,12 @@ TEST_F(SkTaskBuilderTest, Build_WithCustomNotifyWaitReset_Success) {
788 EXPECT_NE(launchInfo.devArgs.Get(), nullptr);798 EXPECT_NE(launchInfo.devArgs.Get(), nullptr);
789}799}
790 800 
791-TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_RecordsMinAvailableUbufSize) {801+TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_RecordsMaxDcacheSize) {
792 opts->RegisterDefaultOptions();802 opts->RegisterDefaultOptions();
793 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);803 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);
794 ASSERT_NE(splitOpt, nullptr);804 ASSERT_NE(splitOpt, nullptr);
795 splitOpt->SetValue(1);805 splitOpt->SetValue(1);
796- auto *setDynUbufSizeOpt = opts->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);806+ SetInnerOption(*opts, SkInnerOptionType::SIMT_OP_SUPPORT, 1);
797- ASSERT_NE(setDynUbufSizeOpt, nullptr);
798- setDynUbufSizeOpt->SetValue(1);
799 807 
800 auto *k0 = CreateKernelNodeEx(7051, 0, INVALID_TASK_ID, 7052, SkKernelType::AIV_ONLY);808 auto *k0 = CreateKernelNodeEx(7051, 0, INVALID_TASK_ID, 7052, SkKernelType::AIV_ONLY);
801 auto *k1 = CreateKernelNodeEx(7052, 0, 7051, 7053, SkKernelType::AIV_ONLY);809 auto *k1 = CreateKernelNodeEx(7052, 0, 7051, 7053, SkKernelType::AIV_ONLY);
@@ -822,19 +830,17 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_RecordsMinAvailableUbufSize) {
822 SkLaunchInfo &launchInfo = buildResult.launchInfo;830 SkLaunchInfo &launchInfo = buildResult.launchInfo;
823 831 
824 EXPECT_NE(launchInfo.entryInfo.skEntryFunc, nullptr);832 EXPECT_NE(launchInfo.entryInfo.skEntryFunc, nullptr);
825- EXPECT_TRUE(launchInfo.hasMinAvailableUbufSize);833+ EXPECT_TRUE(launchInfo.useSimtEntry);
826- EXPECT_EQ(launchInfo.minAvailableUbufSize, SK_TOTAL_UB_SIZE - 24576U - 8192U);834+ EXPECT_EQ(launchInfo.skMaxDcacheSize, SK_TOTAL_UB_SIZE - 24576U - 8192U);
827 EXPECT_STREQ(SkUtGetLastBinaryGetFunctionName(), "sk_entry_mix11_simt");835 EXPECT_STREQ(SkUtGetLastBinaryGetFunctionName(), "sk_entry_mix11_simt");
828}836}
829 837 
830-TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_DynUbufOptionDisabledSkipsRecord) {838+TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_SimtOpSupportDisabledSkipsRecord) {
831 opts->RegisterDefaultOptions();839 opts->RegisterDefaultOptions();
832 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);840 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);
833 ASSERT_NE(splitOpt, nullptr);841 ASSERT_NE(splitOpt, nullptr);
834 splitOpt->SetValue(1);842 splitOpt->SetValue(1);
835- auto *setDynUbufSizeOpt = opts->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);843+ SetInnerOption(*opts, SkInnerOptionType::SIMT_OP_SUPPORT, 0);
836- ASSERT_NE(setDynUbufSizeOpt, nullptr);
837- EXPECT_EQ(setDynUbufSizeOpt->GetIntValue(), 0);
838 844 
839 auto *k0 = CreateKernelNodeEx(7061, 0, INVALID_TASK_ID, 7062, SkKernelType::AIV_ONLY);845 auto *k0 = CreateKernelNodeEx(7061, 0, INVALID_TASK_ID, 7062, SkKernelType::AIV_ONLY);
840 auto *k1 = CreateKernelNodeEx(7062, 0, 7061, INVALID_TASK_ID, SkKernelType::AIV_ONLY);846 auto *k1 = CreateKernelNodeEx(7062, 0, 7061, INVALID_TASK_ID, SkKernelType::AIV_ONLY);
@@ -855,8 +861,8 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTasks_DynUbufOptionDisabledSkipsRecord)
855 SkLaunchInfo &launchInfo = buildResult.launchInfo;861 SkLaunchInfo &launchInfo = buildResult.launchInfo;
856 862 
857 EXPECT_NE(launchInfo.entryInfo.skEntryFunc, nullptr);863 EXPECT_NE(launchInfo.entryInfo.skEntryFunc, nullptr);
858- EXPECT_FALSE(launchInfo.hasMinAvailableUbufSize);864+ EXPECT_FALSE(launchInfo.useSimtEntry);
859- EXPECT_EQ(launchInfo.minAvailableUbufSize, 0U);865+ EXPECT_EQ(launchInfo.skMaxDcacheSize, 0U);
860 EXPECT_STREQ(SkUtGetLastBinaryGetFunctionName(), "sk_entry_aiv");866 EXPECT_STREQ(SkUtGetLastBinaryGetFunctionName(), "sk_entry_aiv");
861}867}
862 868 
@@ -865,9 +871,7 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTaskMissingAllocUbufSize_ReturnsEmpty) {
865 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);871 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);
866 ASSERT_NE(splitOpt, nullptr);872 ASSERT_NE(splitOpt, nullptr);
867 splitOpt->SetValue(1);873 splitOpt->SetValue(1);
868- auto *setDynUbufSizeOpt = opts->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);874+ SetInnerOption(*opts, SkInnerOptionType::SIMT_OP_SUPPORT, 1);
869- ASSERT_NE(setDynUbufSizeOpt, nullptr);
870- setDynUbufSizeOpt->SetValue(1);
871 875 
872 auto *k0 = CreateKernelNodeEx(7071, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::AIV_ONLY);876 auto *k0 = CreateKernelNodeEx(7071, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::AIV_ONLY);
873 k0->nodeInfos.kernelInfos.isSimtOp = true;877 k0->nodeInfos.kernelInfos.isSimtOp = true;
@@ -878,7 +882,7 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTaskMissingAllocUbufSize_ReturnsEmpty) {
878 SkBuildResult buildResult = builder->Build("Unknown", tasks, {}, 0);882 SkBuildResult buildResult = builder->Build("Unknown", tasks, {}, 0);
879 883 
880 EXPECT_EQ(buildResult.launchInfo.entryInfo.skEntryFunc, nullptr);884 EXPECT_EQ(buildResult.launchInfo.entryInfo.skEntryFunc, nullptr);
881- EXPECT_FALSE(buildResult.launchInfo.hasMinAvailableUbufSize);885+ EXPECT_FALSE(buildResult.launchInfo.useSimtEntry);
882}886}
883 887 
884TEST_F(SkTaskBuilderTest, Build_WithSimtTaskUbufSizeOverflow_ReturnsEmpty) {888TEST_F(SkTaskBuilderTest, Build_WithSimtTaskUbufSizeOverflow_ReturnsEmpty) {
@@ -886,9 +890,7 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTaskUbufSizeOverflow_ReturnsEmpty) {
886 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);890 auto *splitOpt = opts->GetOption(aclskOptionType::SPLIT_MODE);
887 ASSERT_NE(splitOpt, nullptr);891 ASSERT_NE(splitOpt, nullptr);
888 splitOpt->SetValue(1);892 splitOpt->SetValue(1);
889- auto *setDynUbufSizeOpt = opts->GetOption(SkInnerOptionType::ENABLE_SET_DYN_UBUF_SIZE);893+ SetInnerOption(*opts, SkInnerOptionType::SIMT_OP_SUPPORT, 1);
890- ASSERT_NE(setDynUbufSizeOpt, nullptr);
891- setDynUbufSizeOpt->SetValue(1);
892 894 
893 auto *k0 = CreateKernelNodeEx(7072, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::AIV_ONLY);895 auto *k0 = CreateKernelNodeEx(7072, 0, INVALID_TASK_ID, INVALID_TASK_ID, SkKernelType::AIV_ONLY);
894 k0->nodeInfos.kernelInfos.isSimtOp = true;896 k0->nodeInfos.kernelInfos.isSimtOp = true;
@@ -901,7 +903,7 @@ TEST_F(SkTaskBuilderTest, Build_WithSimtTaskUbufSizeOverflow_ReturnsEmpty) {
901 SkBuildResult buildResult = builder->Build("Unknown", tasks, {}, 0);903 SkBuildResult buildResult = builder->Build("Unknown", tasks, {}, 0);
902 904 
903 EXPECT_EQ(buildResult.launchInfo.entryInfo.skEntryFunc, nullptr);905 EXPECT_EQ(buildResult.launchInfo.entryInfo.skEntryFunc, nullptr);
904- EXPECT_FALSE(buildResult.launchInfo.hasMinAvailableUbufSize);906+ EXPECT_FALSE(buildResult.launchInfo.useSimtEntry);
905}907}
906 908 
907TEST_F(SkTaskBuilderTest, Build_WithResetTask_Success) {909TEST_F(SkTaskBuilderTest, Build_WithResetTask_Success) {