#include <iostream>
#include <vector>
#include <getopt.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/wait.h>
#include <dlfcn.h>
#include <cstdio>
#include <string>
#include <iomanip>
#include <string.h>
#include <list>
#include <algorithm>
#include <stdarg.h>
#include <fstream>
#include <sstream>
#include "acl/acl.h"
#include "aclnn/aclnn_base.h"
#include "acl/acl_base.h"
#include "acl/acl_rt.h"
#include "sec_common.h"
#include "utils.h"
#include "../fuzzlib/secodeFuzz.h"
#include "aclnnop/aclnn_apply_adam.h"
using namespace std;
static const char* GetDtypeName(aclDataType dt) {
switch (dt) {
case ACL_FLOAT: return "FLOAT";
case ACL_FLOAT16: return "FLOAT16";
case ACL_INT8: return "INT8";
case ACL_INT32: return "INT32";
case ACL_UINT8: return "UINT8";
case ACL_INT16: return "INT16";
case ACL_UINT16: return "UINT16";
case ACL_UINT32: return "UINT32";
case ACL_INT64: return "INT64";
case ACL_UINT64: return "UINT64";
case ACL_DOUBLE: return "DOUBLE";
case ACL_BOOL: return "BOOL";
case ACL_BF16: return "BFLOAT16";
case ACL_COMPLEX64: return "COMPLEX64";
case ACL_COMPLEX128: return "COMPLEX128";
default: return "UNKNOWN";
}
}
static std::string ShapeToStr(const std::vector<int64_t>& s) {
std::string r = "[";
for (size_t k = 0; k < s.size(); k++) {
if (k) r += ",";
r += std::to_string(s[k]);
}
return r + "]";
}
static std::string IntArrayToStr(const std::vector<int64_t>& s) {
std::string r = "[";
for (size_t k = 0; k < s.size(); k++) {
if (k) r += ",";
r += std::to_string(s[k]);
}
return r + "]";
}
static std::string FloatArrayToStr(const std::vector<float>& s) {
std::string r = "[";
for (size_t k = 0; k < s.size(); k++) {
if (k) r += ",";
r += std::to_string(s[k]);
}
return r + "]";
}
struct ScenarioResult {
int scenarioId;
int retCode;
std::string desc;
std::string violation;
std::string category;
std::string errorType;
std::string aclErrMsg;
};
static std::vector<ScenarioResult> g_allResults;
static int g_stdoutFd = -1;
void RedirectStdoutToScenarioFile(int scenarioId) {
const std::string baseDir = "./opfuzz/scenario_logs";
mkdir(baseDir.c_str(), 0755);
std::string logFile = baseDir + "/scenario_" + std::to_string(scenarioId) + ".log";
fflush(stdout);
g_stdoutFd = dup(fileno(stdout));
freopen(logFile.c_str(), "w", stdout);
setvbuf(stdout, NULL, _IONBF, 0);
}
void RestoreStdout() {
if (g_stdoutFd < 0) return;
fflush(stdout);
dup2(g_stdoutFd, fileno(stdout));
close(g_stdoutFd);
g_stdoutFd = -1;
clearerr(stdout);
}
void GenerateFinalSummary() {
const std::string baseDir = "./opfuzz/scenario_logs";
std::string summaryFile = baseDir + "/summary.txt";
std::ofstream sf(summaryFile);
int paramErr = 0, innerErr = 0, runtimeErr = 0, otherErr = 0, unexpectedOk = 0, ezPass = 0;
for (const auto& r : g_allResults) {
if (r.errorType == "UNEXPECTED_SUCCESS") unexpectedOk++;
else if (r.errorType == "PARAM_ERROR") paramErr++;
else if (r.errorType == "INNER_ERROR") innerErr++;
else if (r.errorType == "RUNTIME_ERROR") runtimeErr++;
else otherErr++;
if (r.aclErrMsg.find("should") != std::string::npos ||
r.aclErrMsg.find("must") != std::string::npos ||
r.aclErrMsg.find("expected") != std::string::npos ||
r.aclErrMsg.find("supported") != std::string::npos) {
ezPass++;
}
}
int total = (int)g_allResults.size();
int detected = paramErr + innerErr + runtimeErr + otherErr;
int rate = (total > 0) ? detected * 100 / total : 0;
int ezRate = (total > 0) ? ezPass * 100 / total : 0;
sf << "==============================================" << std::endl;
sf << " ERROR SCENARIO TEST SUMMARY: aclnnApplyAdam" << std::endl;
sf << "==============================================" << std::endl;
sf << " Total Scenarios: " << total << std::endl;
sf << " Error Detected: " << detected << " / " << total << " (" << rate << "%)" << std::endl;
sf << " PARAM_ERROR: " << paramErr << std::endl;
sf << " INNER_ERROR: " << innerErr << std::endl;
sf << " RUNTIME_ERROR: " << runtimeErr << std::endl;
sf << " OTHER_ERROR: " << otherErr << std::endl;
sf << " Unexpected Success: " << unexpectedOk << std::endl;
sf << " EZ Compliance: " << ezPass << " / " << total << " (" << ezRate << "% have corrective hints)" << std::endl;
sf << "==============================================" << std::endl;
sf << std::endl;
sf << std::string(120, '-') << std::endl;
sf << " Id | RetCode | Type | EZ | desc" << std::endl;
sf << std::string(120, '-') << std::endl;
for (const auto& r : g_allResults) {
bool ez = (r.aclErrMsg.find("should") != std::string::npos ||
r.aclErrMsg.find("must") != std::string::npos ||
r.aclErrMsg.find("expected") != std::string::npos);
sf << " " << std::setw(2) << r.scenarioId
<< " | " << std::setw(9) << r.retCode
<< " | " << std::setw(13) << r.errorType
<< " | " << (ez ? "OK " : "NO ")
<< " | " << r.desc << std::endl;
}
sf << std::string(120, '-') << std::endl;
sf << std::endl;
for (const auto& r : g_allResults) {
std::string logPath = baseDir + "/scenario_" + std::to_string(r.scenarioId) + ".log";
sf << std::endl << "===== Scenario " << r.scenarioId << " (" << r.errorType << ") ====" << std::endl;
std::ifstream lf(logPath);
if (lf.is_open()) {
std::string line;
while (std::getline(lf, line)) sf << line << std::endl;
lf.close();
} else {
sf << " (log file not found)" << std::endl;
}
}
sf.close();
printf("\n====== FINAL SUMMARY ======\n");
{
std::string catCmd = "cat " + summaryFile + " 2>/dev/null";
system(catCmd.c_str());
}
printf("====== END SUMMARY ======\n\n");
WriteDTLog("aclnnApplyAdam", "FINAL: total=%d detected=%d param=%d inner=%d runtime=%d unexpected=%d rate=%d%%\n",
total, detected, paramErr, innerErr, runtimeErr, unexpectedOk, rate);
}
int aclnnApplyAdam_Normal(int fuzz_num)
{
auto ret = Init(deviceId, &context, &stream);
CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
WriteDTLog("aclnnApplyAdam", "aclnnApplyAdam error scenario test start\n");
aclrtSetOpExecuteTimeOut(1091);
DT_Set_TimeOut_Second(3000);
DT_FUZZ_START(0, fuzz_num, "aclnnApplyAdam", 0)
{
int i = 0;
void* varRefDeviceAddr = nullptr;
aclTensor* varRef = nullptr;
void* mDeviceAddr = nullptr;
aclTensor* m = nullptr;
void* vDeviceAddr = nullptr;
aclTensor* v = nullptr;
void* beta1PowerDeviceAddr = nullptr;
aclTensor* beta1Power = nullptr;
void* beta2PowerDeviceAddr = nullptr;
aclTensor* beta2Power = nullptr;
void* lrDeviceAddr = nullptr;
aclTensor* lr = nullptr;
void* beta1DeviceAddr = nullptr;
aclTensor* beta1 = nullptr;
void* beta2DeviceAddr = nullptr;
aclTensor* beta2 = nullptr;
void* epsilonDeviceAddr = nullptr;
aclTensor* epsilon = nullptr;
void* gradDeviceAddr = nullptr;
aclTensor* grad = nullptr;
bool useLocking = false;
bool useNesterov = false;
uint64_t workspaceSize = 0;
aclOpExecutor* executor;
void* workspaceAddr = nullptr;
int scenario = 0;
int caseRet = -1;
std::string scenarioDesc, violationDetail, errorCategory, savedErrMsg;
int expectedErrorCode = 0;
std::string expectedErrorName, errorTypeStr, errorTargetStr, verifyRequirement;
LOG_PRINT("aclnnApplyAdam error test %d\n", fuzzi);
RedirectStdoutToScenarioFile(fuzzi);
try
{
scenario = *(int *)DTSetGetNumberRange(&g_Element[i++], 0, 0, 58, "i");
std::vector<int64_t> varRefShape = {2};
std::vector<int64_t> mShape = {2};
std::vector<int64_t> vShape = {2};
std::vector<int64_t> beta1PowerShape = {2};
std::vector<int64_t> beta2PowerShape = {2};
std::vector<int64_t> lrShape = {2};
std::vector<int64_t> beta1Shape = {2};
std::vector<int64_t> beta2Shape = {2};
std::vector<int64_t> epsilonShape = {2};
std::vector<int64_t> gradShape = {2};
aclDataType varRefDtype = ACL_FLOAT16;
aclDataType mDtype = ACL_FLOAT;
aclDataType vDtype = ACL_FLOAT;
aclDataType beta1PowerDtype = ACL_FLOAT;
aclDataType beta2PowerDtype = ACL_FLOAT;
aclDataType lrDtype = ACL_FLOAT;
aclDataType beta1Dtype = ACL_FLOAT;
aclDataType beta2Dtype = ACL_FLOAT;
aclDataType epsilonDtype = ACL_FLOAT;
aclDataType gradDtype = ACL_FLOAT;
aclFormat tensorFormat = ACL_FORMAT_ND;
bool nullVarRef = false, nullM = false, nullV = false, nullBeta1Power = false, nullBeta2Power = false, nullLr = false, nullBeta1 = false, nullBeta2 = false, nullEpsilon = false, nullGrad = false;
if (scenario == 0) {
scenarioDesc = "base config sanity check: no violation injected, expect success";
violationDetail = "base config sanity check: no violation injected, expect success";
errorCategory = "BASE";
expectedErrorCode = 0;
expectedErrorName = "ACL_SUCCESS";
errorTypeStr = "BASE_CHECK";
errorTargetStr = "";
verifyRequirement = "基线自检：base配置应执行成功(ret==0)；若失败则基线污染，所有异常场景报错不可信，需重构造base";
LOG_PRINT("[BASE_CHECK] base config sanity check: no violation injected, expect success\n");
}
else if (scenario == 1) {
scenarioDesc = "varRef dtype=ACL_INT8 not in supported list [FLOAT16,BF16,FLOAT]";
violationDetail = "varRef=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "varRef";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
varRefDtype = ACL_INT8;
LOG_PRINT("[A1_varRef_ACL_INT8] varRef dtype=ACL_INT8 not in supported list [FLOAT16,BF16,FLOAT]\n");
}
else if (scenario == 2) {
scenarioDesc = "varRef dtype=ACL_INT32 not in supported list [FLOAT16,BF16,FLOAT]";
violationDetail = "varRef=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "varRef";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
varRefDtype = ACL_INT32;
LOG_PRINT("[A1_varRef_ACL_INT32] varRef dtype=ACL_INT32 not in supported list [FLOAT16,BF16,FLOAT]\n");
}
else if (scenario == 3) {
scenarioDesc = "varRef dim=9D exceeds max=8D";
violationDetail = "varRef dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "varRef";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
varRefShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_varRef_dim_above_8] varRef dim=9D exceeds max=8D\n");
}
else if (scenario == 4) {
scenarioDesc = "varRef format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "varRef format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "varRef";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_varRef_NCHW] varRef format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 5) {
scenarioDesc = "varRef tensor is nullptr (output pointer is null)";
violationDetail = "varRef tensor is nullptr (output pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_OUTPUT";
errorTargetStr = "varRef";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullVarRef = true;
LOG_PRINT("[D3_varRef_nullptr] varRef tensor is nullptr (output pointer is null)\n");
}
else if (scenario == 6) {
scenarioDesc = "m dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "m=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "m";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
mDtype = ACL_INT8;
LOG_PRINT("[A1_m_ACL_INT8] m dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 7) {
scenarioDesc = "m dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "m=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "m";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
mDtype = ACL_INT32;
LOG_PRINT("[A1_m_ACL_INT32] m dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 8) {
scenarioDesc = "m dim=9D exceeds max=8D";
violationDetail = "m dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "m";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
mShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_m_dim_above_8] m dim=9D exceeds max=8D\n");
}
else if (scenario == 9) {
scenarioDesc = "m format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "m format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "m";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_m_NCHW] m format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 10) {
scenarioDesc = "m tensor is nullptr (input pointer is null)";
violationDetail = "m tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "m";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullM = true;
LOG_PRINT("[D3_m_nullptr] m tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 11) {
scenarioDesc = "v dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "v=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "v";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
vDtype = ACL_INT8;
LOG_PRINT("[A1_v_ACL_INT8] v dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 12) {
scenarioDesc = "v dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "v=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "v";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
vDtype = ACL_INT32;
LOG_PRINT("[A1_v_ACL_INT32] v dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 13) {
scenarioDesc = "v dim=9D exceeds max=8D";
violationDetail = "v dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "v";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
vShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_v_dim_above_8] v dim=9D exceeds max=8D\n");
}
else if (scenario == 14) {
scenarioDesc = "v format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "v format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "v";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_v_NCHW] v format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 15) {
scenarioDesc = "v tensor is nullptr (input pointer is null)";
violationDetail = "v tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "v";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullV = true;
LOG_PRINT("[D3_v_nullptr] v tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 16) {
scenarioDesc = "beta1Power dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "beta1Power=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
beta1PowerDtype = ACL_INT8;
LOG_PRINT("[A1_beta1Power_ACL_INT8] beta1Power dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 17) {
scenarioDesc = "beta1Power dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "beta1Power=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
beta1PowerDtype = ACL_INT32;
LOG_PRINT("[A1_beta1Power_ACL_INT32] beta1Power dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 18) {
scenarioDesc = "beta1Power must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "beta1Power=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
beta1PowerDtype = ACL_FLOAT16;
LOG_PRINT("[A3_beta1Power_ACL_FLOAT16] beta1Power must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 19) {
scenarioDesc = "beta1Power dim=9D exceeds max=8D";
violationDetail = "beta1Power dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
beta1PowerShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_beta1Power_dim_above_8] beta1Power dim=9D exceeds max=8D\n");
}
else if (scenario == 20) {
scenarioDesc = "beta1Power format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "beta1Power format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_beta1Power_NCHW] beta1Power format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 21) {
scenarioDesc = "beta1Power tensor is nullptr (input pointer is null)";
violationDetail = "beta1Power tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "beta1Power";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullBeta1Power = true;
LOG_PRINT("[D3_beta1Power_nullptr] beta1Power tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 22) {
scenarioDesc = "beta2Power dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "beta2Power=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
beta2PowerDtype = ACL_INT8;
LOG_PRINT("[A1_beta2Power_ACL_INT8] beta2Power dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 23) {
scenarioDesc = "beta2Power dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "beta2Power=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
beta2PowerDtype = ACL_INT32;
LOG_PRINT("[A1_beta2Power_ACL_INT32] beta2Power dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 24) {
scenarioDesc = "beta2Power must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "beta2Power=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
beta2PowerDtype = ACL_FLOAT16;
LOG_PRINT("[A3_beta2Power_ACL_FLOAT16] beta2Power must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 25) {
scenarioDesc = "beta2Power dim=9D exceeds max=8D";
violationDetail = "beta2Power dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
beta2PowerShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_beta2Power_dim_above_8] beta2Power dim=9D exceeds max=8D\n");
}
else if (scenario == 26) {
scenarioDesc = "beta2Power format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "beta2Power format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_beta2Power_NCHW] beta2Power format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 27) {
scenarioDesc = "beta2Power tensor is nullptr (input pointer is null)";
violationDetail = "beta2Power tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "beta2Power";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullBeta2Power = true;
LOG_PRINT("[D3_beta2Power_nullptr] beta2Power tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 28) {
scenarioDesc = "lr dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "lr=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
lrDtype = ACL_INT8;
LOG_PRINT("[A1_lr_ACL_INT8] lr dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 29) {
scenarioDesc = "lr dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "lr=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
lrDtype = ACL_INT32;
LOG_PRINT("[A1_lr_ACL_INT32] lr dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 30) {
scenarioDesc = "lr must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "lr=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
lrDtype = ACL_FLOAT16;
LOG_PRINT("[A3_lr_ACL_FLOAT16] lr must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 31) {
scenarioDesc = "lr dim=9D exceeds max=8D";
violationDetail = "lr dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
lrShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_lr_dim_above_8] lr dim=9D exceeds max=8D\n");
}
else if (scenario == 32) {
scenarioDesc = "lr format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "lr format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_lr_NCHW] lr format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 33) {
scenarioDesc = "lr tensor is nullptr (input pointer is null)";
violationDetail = "lr tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "lr";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullLr = true;
LOG_PRINT("[D3_lr_nullptr] lr tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 34) {
scenarioDesc = "beta1 dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "beta1=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
beta1Dtype = ACL_INT8;
LOG_PRINT("[A1_beta1_ACL_INT8] beta1 dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 35) {
scenarioDesc = "beta1 dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "beta1=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
beta1Dtype = ACL_INT32;
LOG_PRINT("[A1_beta1_ACL_INT32] beta1 dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 36) {
scenarioDesc = "beta1 must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "beta1=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
beta1Dtype = ACL_FLOAT16;
LOG_PRINT("[A3_beta1_ACL_FLOAT16] beta1 must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 37) {
scenarioDesc = "beta1 dim=9D exceeds max=8D";
violationDetail = "beta1 dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
beta1Shape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_beta1_dim_above_8] beta1 dim=9D exceeds max=8D\n");
}
else if (scenario == 38) {
scenarioDesc = "beta1 format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "beta1 format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_beta1_NCHW] beta1 format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 39) {
scenarioDesc = "beta1 tensor is nullptr (input pointer is null)";
violationDetail = "beta1 tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "beta1";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullBeta1 = true;
LOG_PRINT("[D3_beta1_nullptr] beta1 tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 40) {
scenarioDesc = "beta2 dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "beta2=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
beta2Dtype = ACL_INT8;
LOG_PRINT("[A1_beta2_ACL_INT8] beta2 dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 41) {
scenarioDesc = "beta2 dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "beta2=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
beta2Dtype = ACL_INT32;
LOG_PRINT("[A1_beta2_ACL_INT32] beta2 dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 42) {
scenarioDesc = "beta2 must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "beta2=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
beta2Dtype = ACL_FLOAT16;
LOG_PRINT("[A3_beta2_ACL_FLOAT16] beta2 must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 43) {
scenarioDesc = "beta2 dim=9D exceeds max=8D";
violationDetail = "beta2 dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
beta2Shape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_beta2_dim_above_8] beta2 dim=9D exceeds max=8D\n");
}
else if (scenario == 44) {
scenarioDesc = "beta2 format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "beta2 format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_beta2_NCHW] beta2 format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 45) {
scenarioDesc = "beta2 tensor is nullptr (input pointer is null)";
violationDetail = "beta2 tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "beta2";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullBeta2 = true;
LOG_PRINT("[D3_beta2_nullptr] beta2 tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 46) {
scenarioDesc = "epsilon dtype=ACL_INT8 not in supported list [FLOAT]";
violationDetail = "epsilon=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
epsilonDtype = ACL_INT8;
LOG_PRINT("[A1_epsilon_ACL_INT8] epsilon dtype=ACL_INT8 not in supported list [FLOAT]\n");
}
else if (scenario == 47) {
scenarioDesc = "epsilon dtype=ACL_INT32 not in supported list [FLOAT]";
violationDetail = "epsilon=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
epsilonDtype = ACL_INT32;
LOG_PRINT("[A1_epsilon_ACL_INT32] epsilon dtype=ACL_INT32 not in supported list [FLOAT]\n");
}
else if (scenario == 48) {
scenarioDesc = "epsilon must be ACL_FLOAT, set to ACL_FLOAT16";
violationDetail = "epsilon=ACL_FLOAT16";
errorCategory = "A3";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001或161002，错误信息应提示ACL_FLOAT16不支持";
epsilonDtype = ACL_FLOAT16;
LOG_PRINT("[A3_epsilon_ACL_FLOAT16] epsilon must be ACL_FLOAT, set to ACL_FLOAT16\n");
}
else if (scenario == 49) {
scenarioDesc = "epsilon dim=9D exceeds max=8D";
violationDetail = "epsilon dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
epsilonShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_epsilon_dim_above_8] epsilon dim=9D exceeds max=8D\n");
}
else if (scenario == 50) {
scenarioDesc = "epsilon format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "epsilon format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_epsilon_NCHW] epsilon format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 51) {
scenarioDesc = "epsilon tensor is nullptr (input pointer is null)";
violationDetail = "epsilon tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "epsilon";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullEpsilon = true;
LOG_PRINT("[D3_epsilon_nullptr] epsilon tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 52) {
scenarioDesc = "grad dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "grad=ACL_INT8";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "grad";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT8不支持或invalid dtype相关提示";
gradDtype = ACL_INT8;
LOG_PRINT("[A1_grad_ACL_INT8] grad dtype=ACL_INT8 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 53) {
scenarioDesc = "grad dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]";
violationDetail = "grad=ACL_INT32";
errorCategory = "A1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_UNSUPPORTED";
errorTargetStr = "grad";
verifyRequirement = "返回码应为161001或161002，错误信息应包含ACL_INT32不支持或invalid dtype相关提示";
gradDtype = ACL_INT32;
LOG_PRINT("[A1_grad_ACL_INT32] grad dtype=ACL_INT32 not in supported list [FLOAT,FLOAT16,BF16]\n");
}
else if (scenario == 54) {
scenarioDesc = "grad dim=9D exceeds max=8D";
violationDetail = "grad dim=9D exceeds max=8D";
errorCategory = "B1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DIM_ILLEGAL";
errorTargetStr = "grad";
verifyRequirement = "返回码应为161001或161002，错误信息应提示维度数超限";
gradShape = {1, 1, 1, 1, 1, 1, 1, 1, 1};
LOG_PRINT("[B1_grad_dim_above_8] grad dim=9D exceeds max=8D\n");
}
else if (scenario == 55) {
scenarioDesc = "grad format=ACL_FORMAT_NCHW (only ND supported)";
violationDetail = "grad format=ACL_FORMAT_NCHW (only ND supported)";
errorCategory = "C1";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "FORMAT_UNSUPPORTED";
errorTargetStr = "grad";
verifyRequirement = "返回码应为161001或161002，错误信息应提示format不支持";
tensorFormat = ACL_FORMAT_NCHW;
LOG_PRINT("[C1_grad_NCHW] grad format=ACL_FORMAT_NCHW (only ND supported)\n");
}
else if (scenario == 56) {
scenarioDesc = "grad tensor is nullptr (input pointer is null)";
violationDetail = "grad tensor is nullptr (input pointer is null)";
errorCategory = "D3";
expectedErrorCode = 161001;
expectedErrorName = "ACLNN_ERR_PARAM_NULLPTR";
errorTypeStr = "NULLPTR_INPUT";
errorTargetStr = "grad";
verifyRequirement = "返回码应为161001，错误信息应包含null或nullptr相关提示";
nullGrad = true;
LOG_PRINT("[D3_grad_nullptr] grad tensor is nullptr (input pointer is null)\n");
}
else if (scenario == 57) {
scenarioDesc = "m=ACL_FLOAT but v=ACL_INT8 (pair requires same)";
violationDetail = "v=ACL_INT8";
errorCategory = "A2";
expectedErrorCode = 161002;
expectedErrorName = "ACLNN_ERR_PARAM_INVALID";
errorTypeStr = "DTYPE_MISMATCH";
errorTargetStr = "v+m";
verifyRequirement = "返回码应为161001或161002，错误信息应提示dtype不匹配";
vDtype = ACL_INT8;
LOG_PRINT("[A2_v_vs_m_dtype_mismatch] m=ACL_FLOAT but v=ACL_INT8 (pair requires same)\n");
}
else if (scenario == 58) {
scenarioDesc = "v.shape=[5] mismatch with m.shape=[2]";
violationDetail = "v.shape=[5] mismatch with m.shape=[2]";
errorCategory = "B2";
expectedErrorCode = 561002;
expectedErrorName = "ACLNN_ERR_INNER_SHAPE_MISMATCH";
errorTypeStr = "SHAPE_MISMATCH";
errorTargetStr = "v+m";
verifyRequirement = "返回码可能为561001或561002，错误信息应提示shape不匹配";
vShape = {5};
LOG_PRINT("[B2_v_vs_m_mismatch] v.shape=[5] mismatch with m.shape=[2]\n");
}
else {
scenarioDesc = "OUT_OF_RANGE";
violationDetail = "scenario index exceeds total";
errorCategory = "SKIP";
LOG_PRINT("Scenario %d out of range (0-58), skipping\n", scenario);
}
if (!nullVarRef) {
long long varRef_sz = GetShapeSize(varRefShape);
if (varRef_sz > 0 && varRef_sz <= 1073741824) {
if (varRefDtype == ACL_FLOAT) {
std::vector<float> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_FLOAT16) {
std::vector<int16_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_INT8) {
std::vector<int8_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_INT32) {
std::vector<int32_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_UINT8) {
std::vector<uint8_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_INT16) {
std::vector<int16_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_UINT16) {
std::vector<uint16_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_UINT32) {
std::vector<uint32_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_INT64) {
std::vector<int64_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_UINT64) {
std::vector<uint64_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_DOUBLE) {
std::vector<double> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_BOOL) {
std::vector<int8_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_BF16) {
std::vector<int16_t> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_COMPLEX64) {
std::vector<float> varRef_host((varRef_sz * 2), 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (varRefDtype == ACL_COMPLEX128) {
std::vector<double> varRef_host((varRef_sz * 2), 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> varRef_host(varRef_sz, 1);
ret = CreateAclTensor(varRef_host, varRefShape, &varRefDeviceAddr, varRefDtype, &varRef);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
varRef = nullptr;
}
if (!nullM) {
long long m_sz = GetShapeSize(mShape);
if (m_sz > 0 && m_sz <= 1073741824) {
if (mDtype == ACL_FLOAT) {
std::vector<float> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_FLOAT16) {
std::vector<int16_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_INT8) {
std::vector<int8_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_INT32) {
std::vector<int32_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_UINT8) {
std::vector<uint8_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_INT16) {
std::vector<int16_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_UINT16) {
std::vector<uint16_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_UINT32) {
std::vector<uint32_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_INT64) {
std::vector<int64_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_UINT64) {
std::vector<uint64_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_DOUBLE) {
std::vector<double> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_BOOL) {
std::vector<int8_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_BF16) {
std::vector<int16_t> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_COMPLEX64) {
std::vector<float> m_host((m_sz * 2), 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (mDtype == ACL_COMPLEX128) {
std::vector<double> m_host((m_sz * 2), 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> m_host(m_sz, 1);
ret = CreateAclTensor(m_host, mShape, &mDeviceAddr, mDtype, &m);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
m = nullptr;
}
if (!nullV) {
long long v_sz = GetShapeSize(vShape);
if (v_sz > 0 && v_sz <= 1073741824) {
if (vDtype == ACL_FLOAT) {
std::vector<float> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_FLOAT16) {
std::vector<int16_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_INT8) {
std::vector<int8_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_INT32) {
std::vector<int32_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_UINT8) {
std::vector<uint8_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_INT16) {
std::vector<int16_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_UINT16) {
std::vector<uint16_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_UINT32) {
std::vector<uint32_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_INT64) {
std::vector<int64_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_UINT64) {
std::vector<uint64_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_DOUBLE) {
std::vector<double> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_BOOL) {
std::vector<int8_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_BF16) {
std::vector<int16_t> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_COMPLEX64) {
std::vector<float> v_host((v_sz * 2), 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (vDtype == ACL_COMPLEX128) {
std::vector<double> v_host((v_sz * 2), 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> v_host(v_sz, 1);
ret = CreateAclTensor(v_host, vShape, &vDeviceAddr, vDtype, &v);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
v = nullptr;
}
if (!nullBeta1Power) {
long long beta1Power_sz = GetShapeSize(beta1PowerShape);
if (beta1Power_sz > 0 && beta1Power_sz <= 1073741824) {
if (beta1PowerDtype == ACL_FLOAT) {
std::vector<float> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_FLOAT16) {
std::vector<int16_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_INT8) {
std::vector<int8_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_INT32) {
std::vector<int32_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_UINT8) {
std::vector<uint8_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_INT16) {
std::vector<int16_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_UINT16) {
std::vector<uint16_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_UINT32) {
std::vector<uint32_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_INT64) {
std::vector<int64_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_UINT64) {
std::vector<uint64_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_DOUBLE) {
std::vector<double> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_BOOL) {
std::vector<int8_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_BF16) {
std::vector<int16_t> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_COMPLEX64) {
std::vector<float> beta1Power_host((beta1Power_sz * 2), 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1PowerDtype == ACL_COMPLEX128) {
std::vector<double> beta1Power_host((beta1Power_sz * 2), 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> beta1Power_host(beta1Power_sz, 1);
ret = CreateAclTensor(beta1Power_host, beta1PowerShape, &beta1PowerDeviceAddr, beta1PowerDtype, &beta1Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
beta1Power = nullptr;
}
if (!nullBeta2Power) {
long long beta2Power_sz = GetShapeSize(beta2PowerShape);
if (beta2Power_sz > 0 && beta2Power_sz <= 1073741824) {
if (beta2PowerDtype == ACL_FLOAT) {
std::vector<float> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_FLOAT16) {
std::vector<int16_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_INT8) {
std::vector<int8_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_INT32) {
std::vector<int32_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_UINT8) {
std::vector<uint8_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_INT16) {
std::vector<int16_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_UINT16) {
std::vector<uint16_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_UINT32) {
std::vector<uint32_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_INT64) {
std::vector<int64_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_UINT64) {
std::vector<uint64_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_DOUBLE) {
std::vector<double> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_BOOL) {
std::vector<int8_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_BF16) {
std::vector<int16_t> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_COMPLEX64) {
std::vector<float> beta2Power_host((beta2Power_sz * 2), 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2PowerDtype == ACL_COMPLEX128) {
std::vector<double> beta2Power_host((beta2Power_sz * 2), 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> beta2Power_host(beta2Power_sz, 1);
ret = CreateAclTensor(beta2Power_host, beta2PowerShape, &beta2PowerDeviceAddr, beta2PowerDtype, &beta2Power);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
beta2Power = nullptr;
}
if (!nullLr) {
long long lr_sz = GetShapeSize(lrShape);
if (lr_sz > 0 && lr_sz <= 1073741824) {
if (lrDtype == ACL_FLOAT) {
std::vector<float> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_FLOAT16) {
std::vector<int16_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_INT8) {
std::vector<int8_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_INT32) {
std::vector<int32_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_UINT8) {
std::vector<uint8_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_INT16) {
std::vector<int16_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_UINT16) {
std::vector<uint16_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_UINT32) {
std::vector<uint32_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_INT64) {
std::vector<int64_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_UINT64) {
std::vector<uint64_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_DOUBLE) {
std::vector<double> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_BOOL) {
std::vector<int8_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_BF16) {
std::vector<int16_t> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_COMPLEX64) {
std::vector<float> lr_host((lr_sz * 2), 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (lrDtype == ACL_COMPLEX128) {
std::vector<double> lr_host((lr_sz * 2), 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> lr_host(lr_sz, 1);
ret = CreateAclTensor(lr_host, lrShape, &lrDeviceAddr, lrDtype, &lr);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
lr = nullptr;
}
if (!nullBeta1) {
long long beta1_sz = GetShapeSize(beta1Shape);
if (beta1_sz > 0 && beta1_sz <= 1073741824) {
if (beta1Dtype == ACL_FLOAT) {
std::vector<float> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_FLOAT16) {
std::vector<int16_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_INT8) {
std::vector<int8_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_INT32) {
std::vector<int32_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_UINT8) {
std::vector<uint8_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_INT16) {
std::vector<int16_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_UINT16) {
std::vector<uint16_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_UINT32) {
std::vector<uint32_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_INT64) {
std::vector<int64_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_UINT64) {
std::vector<uint64_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_DOUBLE) {
std::vector<double> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_BOOL) {
std::vector<int8_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_BF16) {
std::vector<int16_t> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_COMPLEX64) {
std::vector<float> beta1_host((beta1_sz * 2), 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta1Dtype == ACL_COMPLEX128) {
std::vector<double> beta1_host((beta1_sz * 2), 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> beta1_host(beta1_sz, 1);
ret = CreateAclTensor(beta1_host, beta1Shape, &beta1DeviceAddr, beta1Dtype, &beta1);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
beta1 = nullptr;
}
if (!nullBeta2) {
long long beta2_sz = GetShapeSize(beta2Shape);
if (beta2_sz > 0 && beta2_sz <= 1073741824) {
if (beta2Dtype == ACL_FLOAT) {
std::vector<float> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_FLOAT16) {
std::vector<int16_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_INT8) {
std::vector<int8_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_INT32) {
std::vector<int32_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_UINT8) {
std::vector<uint8_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_INT16) {
std::vector<int16_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_UINT16) {
std::vector<uint16_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_UINT32) {
std::vector<uint32_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_INT64) {
std::vector<int64_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_UINT64) {
std::vector<uint64_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_DOUBLE) {
std::vector<double> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_BOOL) {
std::vector<int8_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_BF16) {
std::vector<int16_t> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_COMPLEX64) {
std::vector<float> beta2_host((beta2_sz * 2), 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (beta2Dtype == ACL_COMPLEX128) {
std::vector<double> beta2_host((beta2_sz * 2), 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> beta2_host(beta2_sz, 1);
ret = CreateAclTensor(beta2_host, beta2Shape, &beta2DeviceAddr, beta2Dtype, &beta2);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
beta2 = nullptr;
}
if (!nullEpsilon) {
long long epsilon_sz = GetShapeSize(epsilonShape);
if (epsilon_sz > 0 && epsilon_sz <= 1073741824) {
if (epsilonDtype == ACL_FLOAT) {
std::vector<float> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_FLOAT16) {
std::vector<int16_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_INT8) {
std::vector<int8_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_INT32) {
std::vector<int32_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_UINT8) {
std::vector<uint8_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_INT16) {
std::vector<int16_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_UINT16) {
std::vector<uint16_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_UINT32) {
std::vector<uint32_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_INT64) {
std::vector<int64_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_UINT64) {
std::vector<uint64_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_DOUBLE) {
std::vector<double> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_BOOL) {
std::vector<int8_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_BF16) {
std::vector<int16_t> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_COMPLEX64) {
std::vector<float> epsilon_host((epsilon_sz * 2), 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (epsilonDtype == ACL_COMPLEX128) {
std::vector<double> epsilon_host((epsilon_sz * 2), 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> epsilon_host(epsilon_sz, 1);
ret = CreateAclTensor(epsilon_host, epsilonShape, &epsilonDeviceAddr, epsilonDtype, &epsilon);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
epsilon = nullptr;
}
if (!nullGrad) {
long long grad_sz = GetShapeSize(gradShape);
if (grad_sz > 0 && grad_sz <= 1073741824) {
if (gradDtype == ACL_FLOAT) {
std::vector<float> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_FLOAT16) {
std::vector<int16_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_INT8) {
std::vector<int8_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_INT32) {
std::vector<int32_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_UINT8) {
std::vector<uint8_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_INT16) {
std::vector<int16_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_UINT16) {
std::vector<uint16_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_UINT32) {
std::vector<uint32_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_INT64) {
std::vector<int64_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_UINT64) {
std::vector<uint64_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_DOUBLE) {
std::vector<double> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_BOOL) {
std::vector<int8_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_BF16) {
std::vector<int16_t> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_COMPLEX64) {
std::vector<float> grad_host((grad_sz * 2), 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else if (gradDtype == ACL_COMPLEX128) {
std::vector<double> grad_host((grad_sz * 2), 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
} else {
std::vector<float> grad_host(grad_sz, 1);
ret = CreateAclTensor(grad_host, gradShape, &gradDeviceAddr, gradDtype, &grad);
CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
}
}
} else {
grad = nullptr;
}
printf("[FUZZ_LOG] plog_file: aclnnApplyAdam_error_plog_case_%d.log\n", scenario);
printf("[FUZZ_PARAM] varRef=%s, varRefShape=%s, m=%s, mShape=%s, v=%s, vShape=%s, beta1Power=%s, beta1PowerShape=%s, beta2Power=%s, beta2PowerShape=%s, lr=%s, lrShape=%s, beta1=%s, beta1Shape=%s, beta2=%s, beta2Shape=%s, epsilon=%s, epsilonShape=%s, grad=%s, gradShape=%s, useLocking=%d, useNesterov=%d, format=ND\n", GetDtypeName(varRefDtype), ShapeToStr(varRefShape).c_str(), GetDtypeName(mDtype), ShapeToStr(mShape).c_str(), GetDtypeName(vDtype), ShapeToStr(vShape).c_str(), GetDtypeName(beta1PowerDtype), ShapeToStr(beta1PowerShape).c_str(), GetDtypeName(beta2PowerDtype), ShapeToStr(beta2PowerShape).c_str(), GetDtypeName(lrDtype), ShapeToStr(lrShape).c_str(), GetDtypeName(beta1Dtype), ShapeToStr(beta1Shape).c_str(), GetDtypeName(beta2Dtype), ShapeToStr(beta2Shape).c_str(), GetDtypeName(epsilonDtype), ShapeToStr(epsilonShape).c_str(), GetDtypeName(gradDtype), ShapeToStr(gradShape).c_str(), (int)useLocking, (int)useNesterov);
printf("[FUZZ_ERROR_POINT] case_%d: errorType=%s, errorTarget=%s, description=%s\n", scenario, errorTypeStr.c_str(), errorTargetStr.c_str(), scenarioDesc.c_str());
ret = aclnnApplyAdamGetWorkspaceSize(varRef, m, v, beta1Power, beta2Power, lr, beta1, beta2, epsilon, grad, useLocking, useNesterov, &workspaceSize, &executor);
caseRet = (int)ret;
LOG_PRINT("aclnnApplyAdamGetWorkspaceSize ret=%d, scenario=%d\n", ret, scenario);
const char* rawErrMsg = aclGetRecentErrMsg();
savedErrMsg = (rawErrMsg && rawErrMsg[0] != '\0') ? std::string(rawErrMsg) : "";
LOG_PRINT("aclGetRecentErrMsg: %s\n", savedErrMsg.c_str());
printf("[FUZZ_VERIFY] case_%d: expected_code=%d, actual_code=%d, expected_name=%s, match=%s\n",
scenario, expectedErrorCode, caseRet, expectedErrorName.c_str(),
(caseRet == expectedErrorCode || (expectedErrorCode == 161001 && caseRet == 161002) || (expectedErrorCode == 161002 && caseRet == 161001)) ? "YES" : "NO");
printf("[FUZZ_VERIFY] verify_requirement: %s\n", verifyRequirement.c_str());
if (ret == 0) {
if (workspaceSize > 8589934592ULL) {
LOG_PRINT("workspaceSize %llu exceeds 8G cap, skip phase-2 execution\n", (unsigned long long)workspaceSize);
} else {
if (workspaceSize > 0) {
ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
if (ret != ACL_SUCCESS) { caseRet = (int)ret; LOG_PRINT("aclrtMalloc failed. ERROR: %d\n", ret); goto ERROR; }
}
ret = aclnnApplyAdam(workspaceAddr, workspaceSize, executor, stream);
if (ret != ACL_SUCCESS) { caseRet = (int)ret; LOG_PRINT("aclnnApplyAdam execute failed : %d\n", ret); goto ERROR; }
caseRet = (int)ret;
LOG_PRINT("aclnnApplyAdam execute success : %d\n", ret);
ret = aclrtSynchronizeStream(stream);
if (ret != ACL_SUCCESS) { caseRet = (int)ret; LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); goto ERROR; }
}
}
}
catch (std::exception& e)
{
printf("catch exception %s\n", e.what());
}
ERROR:
ret = aclrtSynchronizeStream(stream);
printf("end \n");
CheckAndLog(ret);
fflush(stdout);
RestoreStdout();
{
std::string fromPath = "./opfuzz/scenario_logs/scenario_" + std::to_string(fuzzi) + ".log";
std::string toPath = "./opfuzz/scenario_logs/scenario_" + std::to_string(scenario) + ".log";
rename(fromPath.c_str(), toPath.c_str());
}
std::string aclErrMsg = savedErrMsg.empty() ? "(no aclnn error msg)" : savedErrMsg;
std::string errType;
if (caseRet == -1) errType = "SETUP_ERROR";
else if (expectedErrorCode == 0) errType = (caseRet == 0) ? "BASE_CHECK_OK" : "BASE_INVALID";
else if (caseRet == 0) errType = "UNEXPECTED_SUCCESS";
else if (caseRet == 161001 || caseRet == 161002) errType = "PARAM_ERROR";
else if (caseRet > 561001 && caseRet < 561119) errType = "INNER_ERROR";
else if (caseRet > 507000 && caseRet < 507901) errType = "RUNTIME_ERROR";
else errType = "OTHER_ERROR";
bool hasHint = (aclErrMsg.find("should") != std::string::npos ||
aclErrMsg.find("must") != std::string::npos ||
aclErrMsg.find("expected") != std::string::npos ||
aclErrMsg.find("supported") != std::string::npos ||
aclErrMsg.find("range") != std::string::npos ||
aclErrMsg.find("invalid") != std::string::npos ||
aclErrMsg.find("mismatch") != std::string::npos);
std::string ezVerdict = hasHint ? "PASS" : "FAIL";
printf("== Scenario %3d | ret=%-8d | %-16s | EZ:%-4s | %s ==\n", scenario, caseRet, errType.c_str(), ezVerdict.c_str(), scenarioDesc.c_str());
printf(" aclnn error msg: %s\n", aclErrMsg.c_str());
ScenarioResult sr;
sr.scenarioId = scenario;
sr.retCode = caseRet;
sr.desc = scenarioDesc;
sr.violation = violationDetail;
sr.category = errorCategory;
sr.errorType = errType;
sr.aclErrMsg = aclErrMsg;
g_allResults.push_back(sr);
pid_t pid = getpid();
std::string cmd = "grep -rinE 'ai(vec|core) error' /root/ascend/log/debug/plog/ ";
printf("system return value %d\n", CheckResult(pid));
if (varRef != nullptr) { aclDestroyTensor(varRef); varRef = nullptr; }
if (m != nullptr) { aclDestroyTensor(m); m = nullptr; }
if (v != nullptr) { aclDestroyTensor(v); v = nullptr; }
if (beta1Power != nullptr) { aclDestroyTensor(beta1Power); beta1Power = nullptr; }
if (beta2Power != nullptr) { aclDestroyTensor(beta2Power); beta2Power = nullptr; }
if (lr != nullptr) { aclDestroyTensor(lr); lr = nullptr; }
if (beta1 != nullptr) { aclDestroyTensor(beta1); beta1 = nullptr; }
if (beta2 != nullptr) { aclDestroyTensor(beta2); beta2 = nullptr; }
if (epsilon != nullptr) { aclDestroyTensor(epsilon); epsilon = nullptr; }
if (grad != nullptr) { aclDestroyTensor(grad); grad = nullptr; }
if (varRefDeviceAddr != nullptr) { aclrtFree(varRefDeviceAddr); varRefDeviceAddr = nullptr; }
if (mDeviceAddr != nullptr) { aclrtFree(mDeviceAddr); mDeviceAddr = nullptr; }
if (vDeviceAddr != nullptr) { aclrtFree(vDeviceAddr); vDeviceAddr = nullptr; }
if (beta1PowerDeviceAddr != nullptr) { aclrtFree(beta1PowerDeviceAddr); beta1PowerDeviceAddr = nullptr; }
if (beta2PowerDeviceAddr != nullptr) { aclrtFree(beta2PowerDeviceAddr); beta2PowerDeviceAddr = nullptr; }
if (lrDeviceAddr != nullptr) { aclrtFree(lrDeviceAddr); lrDeviceAddr = nullptr; }
if (beta1DeviceAddr != nullptr) { aclrtFree(beta1DeviceAddr); beta1DeviceAddr = nullptr; }
if (beta2DeviceAddr != nullptr) { aclrtFree(beta2DeviceAddr); beta2DeviceAddr = nullptr; }
if (epsilonDeviceAddr != nullptr) { aclrtFree(epsilonDeviceAddr); epsilonDeviceAddr = nullptr; }
if (gradDeviceAddr != nullptr) { aclrtFree(gradDeviceAddr); gradDeviceAddr = nullptr; }
if (workspaceSize > 0) { aclrtFree(workspaceAddr); }
}
DT_FUZZ_END()
GenerateFinalSummary();
WriteDTLog("aclnnApplyAdam", "aclnnApplyAdam op fuzz total number:%u, para error number %u, execute error number %u \n",
fuzz_num, aclnn_INVALID_Para, aclnn_Inner_Error + Runtime_Error);
WriteDTLog("aclnnApplyAdam", "aclnnApplyAdam op fuzz end\n");
aclrtDestroyStream(stream);
aclrtDestroyContext(context);
aclrtResetDevice(deviceId);
aclFinalize();
return 0;
}
extern "C" int aclnnApplyAdam_error_fuzz(int argc, char *argv[]);
int aclnnApplyAdam_error_fuzz(int argc, char *argv[])
{
int fuzz_num = MAXFUZZNUMBER;
if (argc < 2) {
cout << "[ERROR] input arg num must be bigger than 1 " << endl;
return -1;
} else if (argc > 2 && argv[2] != nullptr) {
fuzz_num = atoi(argv[2]);
}
if (argc == 4) { deviceId = atoi(argv[3]); }
printf("fuzz_num %d \n", fuzz_num);
printf("aclnnApplyAdam_Normal :%d \n", aclnnApplyAdam_Normal(fuzz_num));
return 0;
}