#include "acl/acl.h"
#include "acl/acl_base.h"
#include "acl/acl_rt.h"
#include "aclnn/aclnn_base.h"
#include "sec_common.h"
#include "utils.h"
#include <algorithm>
#include <cstdio>
#include <ctime>
#include <dirent.h>
#include <dlfcn.h>
#include <getopt.h>
#include <iomanip>
#include <iostream>
#include <list>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <vector>

#include "../fuzzlib/secodeFuzz.h"
#include "aclnnop/aclnn_addr.h"

using namespace std;


static const char* GetNonContigSceneName(int scene) {
    switch(scene) {
        case 0: return "CONTINUOUS";
        case 1: return "BROADCAST";
        case 2: return "SLICE";
        case 3: return "ASSTRIDED";
        case 4: return "STORAGE_PADDED";
        case 5: return "TRANSPOSE";
        default: return "UNKNOWN";
    }
}

int aclnnAddr_non_contig(int fuzz_num) {
    auto ret = Init(deviceId, &context, &stream);
    // check根据自己的需要处理
    CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Init acl failed. ERROR: %d\n", ret); return ret);
    WriteDTLog("aclnnAddr", "aclnnAddr op fuzz alpha \n");
    printf("log path %s\n", seedPath);

    // 合法dtype类型:0-FLOAT 1-FLOAT16 11-DOUBLE 27-BF16(仅910B)
    int aiDtypeAll[] = {0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 16, 17, 27, 29, 30, 33};
    int aiDtypeAllNum = sizeof(aiDtypeAll) / sizeof(aiDtypeAll[0]);
    int aiDtypeNormal[] = {0, 1, 2, 3, 4, 6, 9, 11, 12, 27};
    int aiDtypeNum = sizeof(aiDtypeNormal) / sizeof(aiDtypeNormal[0]);

    aclrtSetOpExecuteTimeOut(1091);
    DT_Set_TimeOut_Second(3000);
        int success_count = 0;
    int faild_count = 0;
DT_FUZZ_START(0, fuzz_num, seedPath, 0) {
        int i = 0;
        void *selfDeviceAddr = nullptr;
        void *vec1DeviceAddr = nullptr;
        void *vec2DeviceAddr = nullptr;
        void *outDeviceAddr = nullptr;
        aclTensor *self = nullptr;
        aclTensor *vec1 = nullptr;
        aclTensor *vec2 = nullptr;
        aclTensor *out = nullptr;
        aclScalar* beta = nullptr;
        aclScalar* alpha = nullptr;
        uint64_t workspaceSize = 0;
        aclOpExecutor *executor;
        void *workspaceAddr = nullptr;

        LOG_PRINT("aclnnAddr_non_contig %d\n", fuzzi);
            printf("[FUZZ_LOG] plog_file: aclnnAddr_non_contig_plog_case_%d\n", fuzzi);
        try {

            // === Tensor Size distribution control ===

            int sizeBucket = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 0, 3, "i");

            long long totalSizeMin = 0, totalSizeMax = 0;

            switch (sizeBucket) {

                case 0: totalSizeMin = 1;          totalSizeMax = 1000;          break;

                case 1: totalSizeMin = 1001;       totalSizeMax = 1073741824LL;  break;

                case 2: totalSizeMin = 1073741825LL; totalSizeMax = 2147483648LL; break;

                case 3: totalSizeMin = 2147483649LL; totalSizeMax = 4294967296LL; break;

            }

            // 1.
            // 创建调用DT获取变异数据，shape除非特别说明支持0，否则最小从1开始
            // w次级别压测dtype先从正常范围中取
            int shape11 = *(int *)DTSetGetNumberRange(&g_Element[i++], 3, 1, MAX_SHAPE_SIZE, "i");
            int shape12 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, MAX_SHAPE_SIZE, "i");
            int shape21 = *(int *)DTSetGetNumberRange(&g_Element[i++], 3, 1, MAX_SHAPE_SIZE, "i");
            int shape31 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, MAX_SHAPE_SIZE, "i");
            int shape41 = *(int *)DTSetGetNumberRange(&g_Element[i++], 3, 1, MAX_SHAPE_SIZE, "i");
            int shape42 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, MAX_SHAPE_SIZE, "i");
            auto selfDtype = (aclDataType) * (int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, aiDtypeNormal, aiDtypeNum);
            auto vec1Dtype = (aclDataType) * (int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, aiDtypeNormal, aiDtypeNum);
            auto vec2Dtype = (aclDataType) * (int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, aiDtypeNormal, aiDtypeNum);
            auto outDtype = (aclDataType) * (int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, aiDtypeNormal, aiDtypeNum);

            auto betaDtype = (aclDataType) * (int *)DT_SetGetNumberEnumV3(i++, aclDataType::ACL_FLOAT, aiDtypeNormal, aiDtypeNum);
            auto alphaDtype = betaDtype;

            // alphaOptional为bool类型，则self/vec1/vec2的最大类型只能是bool
            if (alphaDtype == aclDataType::ACL_BOOL){
                selfDtype = alphaDtype;
                vec1Dtype = alphaDtype;
                vec2Dtype = alphaDtype;
            }

            // 创建aclScalar
            // 0, 1, 2, 3, 4, 6, 9, 11, 12, 27
            if (betaDtype == aclDataType::ACL_FLOAT) {
                float betaValue = *(float *)DTSetGetNumberRangeFloat(&g_Element[i++], 1.17, -100.001, MAX_SHAPE_SIZE,"i");
                float alphaValue = *(float *)DTSetGetNumberRangeFloat(&g_Element[i++], 1.31, -100.001, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %f, betaValue %f.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_FLOAT16) {
                // char test[3] = {1.17, 1.31, 9.97};
                // char *betaValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // char *alphaValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // char *endValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // printf("alphaValue %f, endValue %f, betaValue %f.\n", *alphaValue, *endValue, *betaValue);
                // if (fabs(*betaValue) < 1e-4){
                //     *betaValue = 1;
                // }
                // if ((*betaValue > 0 && *alphaValue > *endValue) || (*betaValue < 0 && *alphaValue < *endValue)){
                //     float tmp = *alphaValue;
                //     *alphaValue = *endValue;
                //     *endValue = tmp;
                // }
                // if(fabs((*endValue-*alphaValue) / *betaValue) + 1 != shape11){
                //     shape11 = fabs((*endValue - *alphaValue) / *betaValue) + 1;
                // }
                // printf("alphaValue %f, endValue %f, betaValue %f.\n", *alphaValue, *endValue, *betaValue);
                // beta = aclCreateScalar((void *)betaValue, betaDtype);
                // CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                // alpha = aclCreateScalar((void *)alphaValue, alphaDtype);
                // CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                // end = aclCreateScalar((void *)endValue, endDtype);
                // CHECK_RET(end != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_INT8) {
                int8_t betaValue = *(int8_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                int8_t alphaValue = *(int8_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %d, betaValue %d.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_INT32) {
                int32_t betaValue = *(int32_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                int32_t alphaValue = *(int32_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %d, betaValue %d.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
            } else if (betaDtype == aclDataType::ACL_UINT8) {
                uint8_t betaValue = *(uint8_t *)DTSetGetNumberRange(&g_Element[i++], 1, 1, MAX_SHAPE_SIZE,"i");
                uint8_t alphaValue = *(uint8_t *)DTSetGetNumberRange(&g_Element[i++], 1, 0, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %d, betaValue %d.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_INT16) {
                int16_t betaValue = *(int16_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                int16_t alphaValue = *(int16_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %d, betaValue %d.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_INT64) {
                int64_t betaValue = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                int64_t alphaValue = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %lld, betaValue %lld.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_DOUBLE) {
                double betaValue = *(double *)DTSetGetNumberRangeDouble(&g_Element[i++], 1.17, -100.001, MAX_SHAPE_SIZE,"i");
                double alphaValue = *(double *)DTSetGetNumberRangeDouble(&g_Element[i++], 1.31, -100.001, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %f, betaValue %f.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_BOOL) {
                int8_t betaValue = *(int8_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                int8_t alphaValue = *(int8_t *)DTSetGetNumberRange(&g_Element[i++], 1, -100, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %d, betaValue %d.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            } else if (betaDtype == aclDataType::ACL_BF16) {
                // char test[3] = {1.17, 1.31, 9.97};
                // char *betaValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // char *alphaValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // char *endValue = DTSetGetFLoat16(&g_Element[i++], test, "i");
                // printf("alphaValue %f, endValue %f, betaValue %f.\n", *alphaValue, *endValue, *betaValue);
                // if (fabs(*betaValue) < 1e-6){
                //     *betaValue = 1;
                // }
                // if ((*betaValue > 0 && *alphaValue > *endValue) || (*betaValue < 0 && *alphaValue < *endValue)){
                //     float tmp = *alphaValue;
                //     *alphaValue = *endValue;
                //     *endValue = tmp;
                // }
                // if(fabs((*endValue-*alphaValue) / *betaValue) + 1 != shape11){
                //     shape11 = fabs((*endValue - *alphaValue) / *betaValue) + 1;
                // }
                // float a = 3.555;
                // int16_t b = (int16_t)a;
                // printf("a %f, b %d.\n", a, b);
                // printf("alphaValue %f, endValue %f, betaValue %f.\n", alphaValue, endValue, betaValue);
                // beta = aclCreateScalar((void *)betaValue, betaDtype);
                // CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                // alpha = aclCreateScalar((void *)&alphaValue, alphaDtype);
                // CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                // end = aclCreateScalar((void *)endValue, endDtype);
                // CHECK_RET(end != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            }else {
                printf("betaDtype dtype=%d not support\n", betaDtype);
                double betaValue = *(double *)DTSetGetNumberRangeDouble(&g_Element[i++], 1.17, -100.001, MAX_SHAPE_SIZE,"i");
                double alphaValue = *(double *)DTSetGetNumberRangeDouble(&g_Element[i++], 1.31, -100.001, MAX_SHAPE_SIZE,"i");
                printf("alphaValue %lf, betaValue %lf.\n", alphaValue, betaValue);
                beta = aclCreateScalar(&betaValue, betaDtype);
                CHECK_RET(beta != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
                alpha = aclCreateScalar(&alphaValue, alphaDtype);
                CHECK_RET(alpha != nullptr, LOG_PRINT("Create Scalar failed. ERROR: 161001\n"); goto ERROR);
            }

            LOG_PRINT("Cnt:%d, param: selfDtype %d, alphaDtype %d, betaDtype %d\n", fuzzi, selfDtype, alphaDtype, betaDtype);

            // 2. 构造tensor信息
            // 创建self aclTensor
            std::vector<int64_t> selfShape = {shape11, shape12};
            printf("selfShape:{%d,%d}\n", shape11, shape12);
            long long shape_size1 = GetShapeSize(selfShape);
            if (shape_size1 > SHAPE_SIZE_CTL) {
                goto ERROR;
            }
            printf("self shape size %lld\n", shape_size1);

            NonContigParams ncSelf;
            ncSelf.scene = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 2, 5, "i");
            if (ncSelf.scene < 2) ncSelf.scene = 2;
            ncSelf.viewShape = selfShape;
            ncSelf.sliceStep = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 2, 5, "i");
            ncSelf.sliceAxis = 0;
            ncSelf.offset = 0;
            ncSelf.pos1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 1, 4, "i");
            ncSelf.pos2 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 4, "i");
            ncSelf.strides.resize(selfShape.size());
            for (size_t j = 0; j < selfShape.size(); j++) {
                ncSelf.strides[j] = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 1, 20, "i");
            }
            CalcNonContiguousParams(ncSelf);
            long long selfStorageSize = GetShapeSize(ncSelf.storageShape);
            printf("[NON_CONTIG] ncSelf scene=%s(%d), originalShape=[", GetNonContigSceneName(ncSelf.scene), ncSelf.scene);
            for (int _i = 0; _i < (int)selfShape.size(); _i++) printf("%lld%s", (long long)selfShape[_i], _i < (int)selfShape.size() - 1 ? "," : "");
            printf("], viewShape=[");
            for (int _i = 0; _i < (int)ncSelf.viewShape.size(); _i++) printf("%lld%s", (long long)ncSelf.viewShape[_i], _i < (int)ncSelf.viewShape.size() - 1 ? "," : "");
            printf("], viewStrides=[");
            for (int _i = 0; _i < (int)ncSelf.strides.size(); _i++) printf("%lld%s", (long long)ncSelf.strides[_i], _i < (int)ncSelf.strides.size() - 1 ? "," : "");
            printf("], storageShape=[");
            for (int _i = 0; _i < (int)ncSelf.storageShape.size(); _i++) printf("%lld%s", (long long)ncSelf.storageShape[_i], _i < (int)ncSelf.storageShape.size() - 1 ? "," : "");
            printf("], offset=%lld\n", (long long)ncSelf.offset);
            if (selfDtype == aclDataType::ACL_FLOAT) {
                std::vector<float> selfHostData(selfStorageSize, 0);

                // === Tensor Size distribution check ===

                long long totalSize = shape_size1 + selfStorageSize;

                if (false) { goto ERROR; }

                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (selfDtype == aclDataType::ACL_FLOAT16) {
                std::vector<int16_t> selfHostData(selfStorageSize, 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (selfDtype == aclDataType::ACL_INT32) {
                std::vector<int32_t> selfHostData(selfStorageSize, 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (selfDtype == aclDataType::ACL_INT64) {
                std::vector<int64_t> selfHostData(selfStorageSize, 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (selfDtype == aclDataType::ACL_DOUBLE) {
                std::vector<double> selfHostData(selfStorageSize, 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (selfDtype == aclDataType::ACL_BF16) {
                std::vector<int16_t> selfHostData(selfStorageSize, 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, selfDtype, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
             } else {
                std::vector<float> selfHostData(GetShapeSize(ncSelf.storageShape), 0);
                ret = CreateAclTensorByScene(selfHostData, ncSelf, &selfDeviceAddr, ACL_FLOAT, ACL_FORMAT_ND, &self);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } 

            // 创建vec1 aclTensor
            std::vector<int64_t> vec1Shape = {shape11};
            printf("vec1Shape:{%d}\n", shape21);
            long long shape_size2 = GetShapeSize(vec1Shape);
            if (shape_size2 > SHAPE_SIZE_CTL) {
                goto ERROR;
            }
            printf("vec1 shape size %lld\n", shape_size2);

            NonContigParams ncVec1;
            ncVec1.scene = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 2, 5, "i");
            if (ncVec1.scene < 2) ncVec1.scene = 2;
            ncVec1.viewShape = vec1Shape;
            ncVec1.sliceStep = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 2, 5, "i");
            ncVec1.sliceAxis = 0;
            ncVec1.offset = 0;
            ncVec1.pos1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 1, 4, "i");
            ncVec1.pos2 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 4, "i");
            ncVec1.strides.resize(vec1Shape.size());
            for (size_t j = 0; j < vec1Shape.size(); j++) {
                ncVec1.strides[j] = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 1, 20, "i");
            }
            CalcNonContiguousParams(ncVec1);
            long long vec1StorageSize = GetShapeSize(ncVec1.storageShape);
            printf("[NON_CONTIG] ncVec1 scene=%s(%d), originalShape=[", GetNonContigSceneName(ncVec1.scene), ncVec1.scene);
            for (int _i = 0; _i < (int)vec1Shape.size(); _i++) printf("%lld%s", (long long)vec1Shape[_i], _i < (int)vec1Shape.size() - 1 ? "," : "");
            printf("], viewShape=[");
            for (int _i = 0; _i < (int)ncVec1.viewShape.size(); _i++) printf("%lld%s", (long long)ncVec1.viewShape[_i], _i < (int)ncVec1.viewShape.size() - 1 ? "," : "");
            printf("], viewStrides=[");
            for (int _i = 0; _i < (int)ncVec1.strides.size(); _i++) printf("%lld%s", (long long)ncVec1.strides[_i], _i < (int)ncVec1.strides.size() - 1 ? "," : "");
            printf("], storageShape=[");
            for (int _i = 0; _i < (int)ncVec1.storageShape.size(); _i++) printf("%lld%s", (long long)ncVec1.storageShape[_i], _i < (int)ncVec1.storageShape.size() - 1 ? "," : "");
            printf("], offset=%lld\n", (long long)ncVec1.offset);
            if (vec1Dtype == aclDataType::ACL_FLOAT) {
                std::vector<float> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec1Dtype == aclDataType::ACL_FLOAT16) {
                std::vector<int16_t> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec1Dtype == aclDataType::ACL_INT32) {
                std::vector<int32_t> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec1Dtype == aclDataType::ACL_INT64) {
                std::vector<int64_t> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec1Dtype == aclDataType::ACL_DOUBLE) {
                std::vector<double> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec1Dtype == aclDataType::ACL_BF16) {
                std::vector<int16_t> vec1HostData(vec1StorageSize, 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, vec1Dtype, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
             } else {
                std::vector<float> vec1HostData(GetShapeSize(ncVec1.storageShape), 0);
                ret = CreateAclTensorByScene(vec1HostData, ncVec1, &vec1DeviceAddr, ACL_FLOAT, ACL_FORMAT_ND, &vec1);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } 

            // 创建vec2 aclTensor
            std::vector<int64_t> vec2Shape = {shape12};
            printf("vec2Shape:{%d}\n", shape31);
            long long shape_size3 = GetShapeSize(vec2Shape);
            if (shape_size3 > SHAPE_SIZE_CTL) {
                goto ERROR;
            }
            printf("vec2 shape size %lld\n", shape_size3);

            NonContigParams ncVec2;
            ncVec2.scene = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 2, 5, "i");
            if (ncVec2.scene < 2) ncVec2.scene = 2;
            ncVec2.viewShape = vec2Shape;
            ncVec2.sliceStep = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 2, 5, "i");
            ncVec2.sliceAxis = 0;
            ncVec2.offset = 0;
            ncVec2.pos1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 1, 4, "i");
            ncVec2.pos2 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 4, "i");
            ncVec2.strides.resize(vec2Shape.size());
            for (size_t j = 0; j < vec2Shape.size(); j++) {
                ncVec2.strides[j] = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 1, 20, "i");
            }
            CalcNonContiguousParams(ncVec2);
            long long vec2StorageSize = GetShapeSize(ncVec2.storageShape);
            printf("[NON_CONTIG] ncVec2 scene=%s(%d), originalShape=[", GetNonContigSceneName(ncVec2.scene), ncVec2.scene);
            for (int _i = 0; _i < (int)vec2Shape.size(); _i++) printf("%lld%s", (long long)vec2Shape[_i], _i < (int)vec2Shape.size() - 1 ? "," : "");
            printf("], viewShape=[");
            for (int _i = 0; _i < (int)ncVec2.viewShape.size(); _i++) printf("%lld%s", (long long)ncVec2.viewShape[_i], _i < (int)ncVec2.viewShape.size() - 1 ? "," : "");
            printf("], viewStrides=[");
            for (int _i = 0; _i < (int)ncVec2.strides.size(); _i++) printf("%lld%s", (long long)ncVec2.strides[_i], _i < (int)ncVec2.strides.size() - 1 ? "," : "");
            printf("], storageShape=[");
            for (int _i = 0; _i < (int)ncVec2.storageShape.size(); _i++) printf("%lld%s", (long long)ncVec2.storageShape[_i], _i < (int)ncVec2.storageShape.size() - 1 ? "," : "");
            printf("], offset=%lld\n", (long long)ncVec2.offset);
            if (vec2Dtype == aclDataType::ACL_FLOAT) {
                std::vector<float> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec2Dtype == aclDataType::ACL_FLOAT16) {
                std::vector<int16_t> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec2Dtype == aclDataType::ACL_INT32) {
                std::vector<int32_t> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec2Dtype == aclDataType::ACL_INT64) {
                std::vector<int64_t> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec2Dtype == aclDataType::ACL_DOUBLE) {
                std::vector<double> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (vec2Dtype == aclDataType::ACL_BF16) {
                std::vector<int16_t> vec2HostData(vec2StorageSize, 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, vec2Dtype, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
             } else {
                std::vector<float> vec2HostData(GetShapeSize(ncVec2.storageShape), 0);
                ret = CreateAclTensorByScene(vec2HostData, ncVec2, &vec2DeviceAddr, ACL_FLOAT, ACL_FORMAT_ND, &vec2);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } 

            // 创建out aclTensor
            std::vector<int64_t> outShape = {shape11, shape12};
            printf("outShape:{%d,%d}\n", shape41, shape42);
            long long shape_size4 = GetShapeSize(outShape);
            if (shape_size4 > SHAPE_SIZE_CTL) {
                goto ERROR;
            }
            printf("out shape size %lld\n", shape_size4);

            NonContigParams ncOut;
            ncOut.scene = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 2, 5, "i");
            if (ncOut.scene < 2) ncOut.scene = 2;
            ncOut.viewShape = outShape;
            ncOut.sliceStep = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 2, 5, "i");
            ncOut.sliceAxis = 0;
            ncOut.offset = 0;
            ncOut.pos1 = *(int *)DTSetGetNumberRange(&g_Element[i++], 1, 1, 4, "i");
            ncOut.pos2 = *(int *)DTSetGetNumberRange(&g_Element[i++], 2, 1, 4, "i");
            ncOut.strides.resize(outShape.size());
            for (size_t j = 0; j < outShape.size(); j++) {
                ncOut.strides[j] = *(int64_t *)DTSetGetNumberRangeS64(&g_Element[i++], 2, 1, 20, "i");
            }
            CalcNonContiguousParams(ncOut);
            long long outStorageSize = GetShapeSize(ncOut.storageShape);
            printf("[NON_CONTIG] ncOut scene=%s(%d), originalShape=[", GetNonContigSceneName(ncOut.scene), ncOut.scene);
            for (int _i = 0; _i < (int)outShape.size(); _i++) printf("%lld%s", (long long)outShape[_i], _i < (int)outShape.size() - 1 ? "," : "");
            printf("], viewShape=[");
            for (int _i = 0; _i < (int)ncOut.viewShape.size(); _i++) printf("%lld%s", (long long)ncOut.viewShape[_i], _i < (int)ncOut.viewShape.size() - 1 ? "," : "");
            printf("], viewStrides=[");
            for (int _i = 0; _i < (int)ncOut.strides.size(); _i++) printf("%lld%s", (long long)ncOut.strides[_i], _i < (int)ncOut.strides.size() - 1 ? "," : "");
            printf("], storageShape=[");
            for (int _i = 0; _i < (int)ncOut.storageShape.size(); _i++) printf("%lld%s", (long long)ncOut.storageShape[_i], _i < (int)ncOut.storageShape.size() - 1 ? "," : "");
            printf("], offset=%lld\n", (long long)ncOut.offset);
            if (outDtype == aclDataType::ACL_FLOAT) {
                std::vector<float> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (outDtype == aclDataType::ACL_FLOAT16) {
                std::vector<int16_t> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (outDtype == aclDataType::ACL_INT32) {
                std::vector<int32_t> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (outDtype == aclDataType::ACL_INT64) {
                std::vector<int64_t> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (outDtype == aclDataType::ACL_DOUBLE) {
                std::vector<double> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
            } else if (outDtype == aclDataType::ACL_BF16) {
                std::vector<int16_t> outHostData(outStorageSize, 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, outDtype, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("Create Tensor failed. ERROR: %d\n", ret); goto ERROR);
             } else {
                std::vector<float> outHostData(GetShapeSize(ncOut.storageShape), 0);
                ret = CreateAclTensorByScene(outHostData, ncOut, &outDeviceAddr, ACL_FLOAT, ACL_FORMAT_ND, &out);
                CHECK_RET(ret == ACL_SUCCESS, goto ERROR);
            } 

            // 3. 调用第一段接口
            ret = aclnnAddrGetWorkspaceSize(self, vec1, vec2, beta, alpha, out, &workspaceSize, &executor);
            CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddrGetWorkspaceSize failed. ERROR: %d\n", ret); goto ERROR);

            if (workspaceSize > 0) {
                ret = aclrtMalloc(&workspaceAddr, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
                CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("allocate workspace failed. ERROR: %d\n", ret); goto ERROR);
            }

            // 4.调用第二段接口
            ret = aclnnAddr(workspaceAddr, workspaceSize, executor, stream);
            CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclnnAddr failed. ERROR: %d\n", ret); goto ERROR);

            // 5.（固定写法）同步等待任务执行结束
            {
                aclError syncRet = aclrtSynchronizeStream(stream);
                (void)syncRet;
            }
            CHECK_RET(ret == ACL_SUCCESS, LOG_PRINT("aclrtSynchronizeStream failed. ERROR: %d\n", ret); goto ERROR);

            LOG_PRINT("aclnn execute success : %d\n", ret);
        } catch (std::exception &e) {
            printf("catch exception %s\n", e.what());
        }
    ERROR:
        {
            aclError syncRet = aclrtSynchronizeStream(stream);
            (void)syncRet;
        }
        printf("end \n");
        CheckAndLog(ret);
        if (ret == 0) { success_count++; } else { faild_count++; }
        printf("[FUZZ_RESULT] case_%d: %s, ret=%d\n", fuzzi, ret == 0 ? "success" : "faild", ret);
        pid_t pid = getpid();
        std::string cmd = "grep -rin 'aicore error' /root/ascend/log/debug/plog/ ";
        printf("system return value %d\n", CheckResult(pid));
        if (alpha != nullptr) { aclDestroyScalar(alpha); alpha = nullptr; }
        if (beta != nullptr) { aclDestroyScalar(beta); beta = nullptr; }
        if (self != nullptr) { aclDestroyTensor(self); self = nullptr; }
        if (vec1 != nullptr) { aclDestroyTensor(vec1); vec1 = nullptr; }
        if (vec2 != nullptr) { aclDestroyTensor(vec2); vec2 = nullptr; }
        if (out != nullptr) { aclDestroyTensor(out); out = nullptr; }
        if (selfDeviceAddr != nullptr) { aclrtFree(selfDeviceAddr); selfDeviceAddr = nullptr; }
        if (vec1DeviceAddr != nullptr) { aclrtFree(vec1DeviceAddr); vec1DeviceAddr = nullptr; }
        if (vec2DeviceAddr != nullptr) { aclrtFree(vec2DeviceAddr); vec2DeviceAddr = nullptr; }
        if (outDeviceAddr != nullptr) { aclrtFree(outDeviceAddr); outDeviceAddr = nullptr; }
        if (workspaceSize > 0) {
            if (workspaceAddr != nullptr) { aclrtFree(workspaceAddr); workspaceAddr = nullptr; }
        }
    }
    DT_FUZZ_END()
    printf("=== aclnnAddr_non_contig SUMMARY: total=%d, success=%d, faild=%d ===\n", fuzz_num, success_count, faild_count);
    WriteDTLog("aclnnAddr", "aclnnAddr non_contig 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("aclnnAddr", "aclnnAddr non_contig op fuzz end \n");
    aclrtDestroyStream(stream);
    aclrtDestroyContext(context);
    aclrtResetDevice(deviceId);
    aclFinalize();
    return 0;
}
extern "C" int aclnnAddr_non_contig_fuzz(int argc, char *argv[]);
int aclnnAddr_non_contig_fuzz(int argc, char *argv[]) {
    int fuzz_num = MAXFUZZNUMBER;
    strcpy(seedPath, strcat(logPath, __func__));

    if (argc < 1) {
        cout << "[ERROR] input arg num must be bigger than 1 \n" << endl;
        cout << "The second arg stand for testcase num  \n" << endl;
        return -1;
    } else if (argc > 1) {
        fuzz_num = atoi(argv[2]);
    }
    if (argc == 4) {
        deviceId = atoi(argv[3]);
    }
    printf("deviceId %d \n", deviceId);
    printf("fuzz_num %d \n", fuzz_num);

    printf("aclnnAddr_non_contig :%d \n", aclnnAddr_non_contig(fuzz_num));

    return 0;
}