/**
 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*!
 * \file kernel_check.h
 * \brief
 */
#ifndef ASCENDC_MODULE_CHECK_H
#define ASCENDC_MODULE_CHECK_H

#if __CCE_KT_TEST__
#include "tikcpp_check_util.h"
namespace AscendC {
template <typename T>
bool CheckFuncCopy(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const uint64_t mask,
    const uint8_t repeatTimes, const CopyRepeatParams& repeatParams, const char* intriName)
{
    check::CopyApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstStride),
        static_cast<uint16_t>(repeatParams.srcStride),
        static_cast<uint16_t>(repeatParams.dstRepeatSize),
        static_cast<uint16_t>(repeatParams.srcRepeatSize),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFuncCopyImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFuncCopy(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const uint64_t mask[2],
    const uint8_t repeatTimes, const CopyRepeatParams& repeatParams, const char* intriName)
{
    check::CopyApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstStride),
        static_cast<uint16_t>(repeatParams.srcStride),
        static_cast<uint16_t>(repeatParams.dstRepeatSize),
        static_cast<uint16_t>(repeatParams.srcRepeatSize),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFuncCopyImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFuncDataCopy(const LocalTensor<T> &dstLocal, const LocalTensor<T> &srcLocal,
    const DataCopyParams &repeatParams, const char *intriName)
{
    check::DataCopyApiParams chkParams{
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        repeatParams.blockCount,
        repeatParams.blockLen,
        repeatParams.srcStride,
        repeatParams.dstStride};
    return CheckFuncDataCopyImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopy(const LocalTensor<T> &dstLocal, const GlobalTensor<T> &srcGlobal,
    const DataCopyParams &repeatParams, const char *intriName)
{
    check::DataCopyApiParams chkParams{
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcGlobal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(Hardware::GM),
        repeatParams.blockCount,
        repeatParams.blockLen,
        repeatParams.srcStride,
        repeatParams.dstStride};
    return CheckFuncDataCopyImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopyPad(const LocalTensor<T> &dstLocal, const GlobalTensor<T> &srcGlobal,
    const DataCopyParams &dataCopyParams, const DataCopyPadParams &padParams, const char *intriName)
{
    check::DataCopyPadApiParams chkParams{
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcGlobal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(Hardware::GM),
        dataCopyParams.blockCount,
        dataCopyParams.blockLen,
        dataCopyParams.srcStride,
        dataCopyParams.dstStride,
        padParams.isPad,
        padParams.leftPadding,
        padParams.rightPadding,
        padParams.paddingValue};
    return CheckFuncDataCopyPadImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopyPad(const LocalTensor<T> &dstLocal, const GlobalTensor<T> &srcGlobal,
    const DataCopyExtParams &dataCopyParams, const DataCopyPadExtParams<T> &padParams, const char *intriName)
{
    check::DataCopyPadApiParams chkParams{
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcGlobal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(Hardware::GM),
        dataCopyParams.blockCount,
        dataCopyParams.blockLen,
        dataCopyParams.srcStride,
        dataCopyParams.dstStride,
        padParams.isPad,
        padParams.leftPadding,
        padParams.rightPadding,
        GetScalarBitcodeValue(padParams.paddingValue)};
    return CheckFuncDataCopyPadImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopy(const GlobalTensor<T> &dstGlobal, const LocalTensor<T> &srcLocal,
    const DataCopyParams &repeatParams, const char *intriName)
{
    check::DataCopyApiParams chkParams{
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstGlobal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint8_t>(Hardware::GM),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        repeatParams.blockCount,
        repeatParams.blockLen,
        repeatParams.srcStride,
        repeatParams.dstStride};
    return CheckFuncDataCopyImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopySlice(const LocalTensor<T>& dstLocal, const GlobalTensor<T>& srcGlobal,
    const SliceInfo dstSliceInfo[], const SliceInfo srcSliceInfo[], const uint32_t dimValue, const char* intriName)
{
    bool isGM2UB = true;
    uint32_t srcShapeInfo[K_MAX_SHAPE_DIM];
    uint32_t dstShapeInfo[K_MAX_SHAPE_DIM];
    bool useShapeValue = !(srcSliceInfo[0].shapeValue == 0);
    for (int i = 0; i < dimValue; i++) {
        srcShapeInfo[i] = useShapeValue ? srcSliceInfo[i].shapeValue : srcGlobal.GetShapeInfo().shape[i];
        dstShapeInfo[i] = useShapeValue ? dstSliceInfo[i].shapeValue : dstLocal.GetShapeInfo().shape[i];
    }

    check::DataCopySliceApiParams chkParams{ static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcGlobal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        dimValue,
        dstShapeInfo,
        srcShapeInfo,
        dstSliceInfo,
        srcSliceInfo,
        isGM2UB };
    return CheckFuncDataCopySliceImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncDataCopySlice(const GlobalTensor<T>& dstGlobal, const LocalTensor<T>& srcLocal,
    const SliceInfo dstSliceInfo[], const SliceInfo srcSliceInfo[], const uint32_t dimValue, const char* intriName)
{
    bool isGM2UB = false;
    uint32_t srcShapeInfo[K_MAX_SHAPE_DIM];
    uint32_t dstShapeInfo[K_MAX_SHAPE_DIM];
    bool useShapeValue = !(srcSliceInfo[0].shapeValue == 0);
    for (int i = 0; i < dimValue; i++) {
        srcShapeInfo[i] = useShapeValue ? srcSliceInfo[i].shapeValue : srcLocal.GetShapeInfo().shape[i];
        dstShapeInfo[i] = useShapeValue ? dstSliceInfo[i].shapeValue : dstGlobal.GetShapeInfo().shape[i];
    }

    check::DataCopySliceApiParams chkParams{ static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstGlobal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        dimValue,
        dstShapeInfo,
        srcShapeInfo,
        dstSliceInfo,
        srcSliceInfo,
        isGM2UB };
    return CheckFuncDataCopySliceImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncVecBinary(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const uint64_t mask[2], const uint8_t repeatTimes,
    const BinaryRepeatParams& repeatParams, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.src1BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint16_t>(repeatParams.src1RepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))) };
    return CheckFuncVecBinaryImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFuncVecBinary(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const uint64_t mask, const uint8_t repeatTimes,
    const BinaryRepeatParams& repeatParams, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.src1BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint16_t>(repeatParams.src1RepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))) };
    return CheckFuncVecBinaryImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFuncVecBinary(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const int32_t& calCount, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFuncVecBinaryImpl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFuncVecBinaryCmp(const LocalTensor<U>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const uint64_t mask[2], const uint8_t repeatTimes,
    const BinaryRepeatParams& repeatParams, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.src1BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint16_t>(repeatParams.src1RepStride),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(U)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))) };
    return CheckFuncVecBinaryCmpImplForMaskArray(chkParams, mask, intriName);
}

template <typename T, typename U>
bool CheckFuncVecBinaryCmp(const LocalTensor<U>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const uint64_t mask, const uint8_t repeatTimes,
    const BinaryRepeatParams& repeatParams, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.src1BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint16_t>(repeatParams.src1RepStride),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(U)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))) };
    return CheckFuncVecBinaryCmpImpl(chkParams, mask, intriName);
}

template <typename T, typename U>
bool CheckFuncVecBinaryCmp(const LocalTensor<U>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<T>& src1Local, const int32_t& calCount, const char* intriName)
{
    check::VecBinaryApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(U)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFuncVecBinaryCmpImpl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFuncVecBinaryScalarCmp(const LocalTensor<U>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const uint64_t mask, const uint8_t repeatTimes, const UnaryRepeatParams& repeatParams, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.srcBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.srcRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(U)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFuncVecBinaryScalarCmpImpl(chkParams, mask, intriName);
}

template <typename T, typename U>
bool CheckFuncVecBinaryScalarCmp(const LocalTensor<U>& dstLocal, const LocalTensor<T>& src0Local,
    T src1Scalar, const int32_t& calCount, const char* intriName)
{
    check::VecBinaryScalarApiParams chkParams {
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(U)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFuncVecBinaryScalarCmpImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunVecBinaryScalar(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const uint64_t mask[2], const uint8_t repeatTimes, const UnaryRepeatParams& repeatParams, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.srcBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.srcRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecBinaryScalar(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const uint64_t mask[2], const uint8_t repeatTimes, const BinaryRepeatParams& repeatParams, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecBinaryScalar(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const uint64_t mask, const uint8_t repeatTimes, const UnaryRepeatParams& repeatParams, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.srcBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.srcRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecBinaryScalar(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const uint64_t mask, const uint8_t repeatTimes, const BinaryRepeatParams& repeatParams, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.src0BlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.src0RepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecBinaryScalar(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const T& scalarValue,
    const int32_t& calCount, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFunVecBinaryScalarImpl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFunVecBinaryScalarDiffType(const LocalTensor<T>& dstLocal, const LocalTensor<U>& srcLocal,
    const U& scalarValue, const uint64_t mask[2], const uint8_t repeatTimes, const UnaryRepeatParams& repeatParams,
    const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.srcBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.srcRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImplForMaskArray(chkParams, mask, intriName);
}

template <typename T, typename U>
bool CheckFunVecBinaryScalarDiffType(const LocalTensor<T>& dstLocal, const LocalTensor<U>& srcLocal,
    const U& scalarValue, const uint64_t mask, const uint8_t repeatTimes, const UnaryRepeatParams& repeatParams,
    const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.srcBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint16_t>(repeatParams.srcRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunVecBinaryScalarImpl(chkParams, mask, intriName);
}

template <typename T, typename U>
bool CheckFunVecBinaryScalarDiffType(const LocalTensor<T>& dstLocal, const LocalTensor<U>& srcLocal,
    const U& scalarValue, const int32_t& calCount, const char* intriName)
{
    (void)(scalarValue);
    check::VecBinaryScalarApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFunVecBinaryScalarImpl(chkParams, intriName);
}

template <typename dst_T, typename bias_T>
void CheckMmadBiasDtype()
{
    // v220 mmad bias support: (1) dst_T: fp32, bias: fp32 (2) dst_T: fp32, bias_T:fp16 (3) dst_T: s32, bias_T: s32
    bool res = std::is_same<dst_T, int32_t>::value && std::is_same<bias_T, int32_t>::value;
    res = res || (std::is_same<dst_T, float>::value && std::is_same<bias_T, float>::value);
    res = res || (std::is_same<dst_T, float>::value && std::is_same<bias_T, half>::value);
    ASSERT(res && "check mmad bias data type failed");
}

template <typename dst_T, typename src0_T, typename src1_T, typename bias_T>
bool CheckMmadParams(const LocalTensor<dst_T>& dstLocal, const LocalTensor<src0_T>& fmLocal,
    const LocalTensor<src1_T>& filterLocal, const LocalTensor<bias_T>& biasLocal, const MmadParams& mmadParams,
    const char* intriName)
{
    CheckMmadBiasDtype<dst_T, bias_T>();

    check::MmadApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(fmLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(filterLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(biasLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(dst_T)),
        static_cast<uint32_t>(sizeof(src0_T)),
        static_cast<uint32_t>(sizeof(src1_T)),
        static_cast<uint32_t>(sizeof(bias_T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(dst_T)),
        static_cast<uint64_t>(fmLocal.GetSize() * sizeof(src0_T)),
        static_cast<uint64_t>(filterLocal.GetSize() * sizeof(src1_T)),
        static_cast<uint64_t>(biasLocal.GetSize() * sizeof(bias_T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(fmLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(filterLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(biasLocal.GetPosition()))),
        mmadParams.m,
        mmadParams.n,
        mmadParams.k,
        mmadParams.isBias,
        mmadParams.fmOffset,
        mmadParams.enSsparse,
        mmadParams.enWinogradA,
        mmadParams.enWinogradB };
    return CheckFuncMmadImpl(chkParams, intriName);
}
template <typename dst_T, typename src0_T, typename src1_T>
bool CheckMmadParams(const LocalTensor<dst_T>& dstLocal, const LocalTensor<src0_T>& fmLocal,
    const LocalTensor<src1_T>& filterLocal, const MmadParams& mmadParams, const char* intriName)
{
    check::MmadApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(fmLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(filterLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(dst_T)),
        static_cast<uint32_t>(sizeof(src0_T)),
        static_cast<uint32_t>(sizeof(src1_T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(dst_T)),
        static_cast<uint64_t>(fmLocal.GetSize() * sizeof(src0_T)),
        static_cast<uint64_t>(filterLocal.GetSize() * sizeof(src1_T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(fmLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(filterLocal.GetPosition()))),
        mmadParams.m,
        mmadParams.n,
        mmadParams.k,
        mmadParams.isBias,
        mmadParams.fmOffset,
        mmadParams.enSsparse,
        mmadParams.enWinogradA,
        mmadParams.enWinogradB };
    return CheckFuncMmadImpl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFuncBroadCastToMM(const LocalTensor<T>& dstLocal, const LocalTensor<U>& srcLocal, const int32_t blockCount,
    const uint8_t blockLen, const uint8_t srcGap, const uint8_t dstGap, const char* intriName)
{
    check::VecBroadCastToMMApiParams chkParams { static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint32_t>(blockCount),
        static_cast<uint8_t>(blockLen),
        static_cast<uint8_t>(srcGap),
        static_cast<uint8_t>(dstGap) };
    return CheckFuncBroadCastToMMImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunVecReduceOther(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const int32_t repeatTimes,
    const int32_t maskCount, const int32_t dstRepStride, const int32_t srcBlkStride, const int32_t srcRepStride,
    const char* intriName)
{
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint16_t>(dstRepStride),
        static_cast<uint16_t>(srcBlkStride),
        static_cast<uint16_t>(srcRepStride),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunReduceOtherImpl(chkParams, maskCount, intriName);
}

template <typename T>
bool CheckFunVecReduceOther(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const int32_t repeatTimes,
    const uint64_t mask[2], const int32_t dstRepStride, const int32_t srcBlkStride, const int32_t srcRepStride,
    const char* intriName)
{
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint16_t>(dstRepStride),
        static_cast<uint16_t>(srcBlkStride),
        static_cast<uint16_t>(srcRepStride),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunReduceOtherImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    const int32_t repeatTimes, const int32_t mask, bool calIndex, const int32_t srcRepStride, const char* intriName)
{
    // max or min level0
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        calIndex,
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))),
        static_cast<uint16_t>(srcRepStride) };
    return CheckFunReduceImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    const int32_t repeatTimes, const uint64_t mask[2], bool calIndex, const int32_t srcRepStride, const char* intriName)
{
    // max or min level0
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        calIndex,
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))),
        static_cast<uint16_t>(srcRepStride) };
    return CheckFunReduceImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    const int32_t repeatTimes, const int32_t mask, const int32_t srcRepStride, const char* intriName)
{
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))),
        static_cast<uint16_t>(srcRepStride) };
    return CheckFunReduceImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    const int32_t repeatTimes, const uint64_t mask[2], const int32_t srcRepStride, const char* intriName)
{
    // sum level0
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))),
        static_cast<uint16_t>(srcRepStride) };
    return CheckFunReduceImplForMaskArray(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    int32_t repeatTimes, const int32_t count, bool calIndex, const char* intriName)
{
    // max or min level2
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint32_t>(count),
        calIndex,
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))) };
    return CheckFunReduceImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunVecReduce(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const LocalTensor<T>& workLocal,
    const int32_t count, int32_t repeatTimes, const char* intriName)
{
    // sum level 2
    check::VecReduceApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(workLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        repeatTimes,
        static_cast<uint32_t>(count),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(workLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(workLocal.GetPosition()))) };
    return CheckFunReduceImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunDup(const LocalTensor<T>& dstLocal, const uint64_t mask, const uint8_t repeatTimes,
    const uint16_t dstBlockStride, const uint8_t dstRepeatStride, const char* intriName)
{
    check::VecDupApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(dstBlockStride),
        static_cast<uint16_t>(dstRepeatStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))) };
    return CheckFunDupImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFunDup(const LocalTensor<T>& dstLocal, const uint64_t mask[2], const uint8_t repeatTimes,
    const uint16_t dstBlockStride, const uint8_t dstRepeatStride, const char* intriName)
{
    check::VecDupApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(dstBlockStride),
        static_cast<uint16_t>(dstRepeatStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))) };
    return CheckFunDupImplForMaskArray(chkParams, mask, intriName);
}

template <typename T> bool CheckFunDup(const LocalTensor<T>& dstLocal, const int32_t& calCount, const char* intriName)
{
    check::VecDupApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint32_t>(sizeof(T)), static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint32_t>(calCount) };
    return CheckFunDupImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunBcB(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local, const uint8_t repeatTimes,
    const BrcbRepeatParams& repeatParams, const char* intriName)
{
    check::VecBroadCastApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))) };
    return CheckFunBcBImpl(chkParams, sizeof(T), intriName);
}

template <typename T, typename U>
bool CheckFunGather(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local, const LocalTensor<U>& offsetLocal,
    const uint8_t repeatTimes, const GatherRepeatParams& repeatParams, const char* intriName)
{
    check::VecGatherApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(offsetLocal.GetPhyAddr())),
        repeatTimes,
        static_cast<uint16_t>(repeatParams.dstBlkStride),
        static_cast<uint16_t>(repeatParams.dstRepStride),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(offsetLocal.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(offsetLocal.GetPosition()))) };
    return CheckFunGatherImpl(chkParams, sizeof(T), intriName);
}

template <typename T>
bool CheckFunTranspose(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local, const char* intriName)
{
    const uint16_t defualtStride = 16;
    check::VecTransposeApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        1,
        defualtStride,
        defualtStride,
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))) };
    return CheckFunTransposeImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunTransDataTo5HD(const LocalTensor<T> (&dstLocal)[16], const LocalTensor<T> (&src0Local)[16],
    const TransDataTo5HDParams& nchwconvParams, const char* intriName)
{
    const uint32_t dataNum = 16;
    for (size_t i = 0; i < dataNum; i++) {
        check::VecTransposeApiParams chkParams { static_cast<uint64_t>(
            reinterpret_cast<uintptr_t>(dstLocal[i].GetPhyAddr())),
            static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local[i].GetPhyAddr())),
            nchwconvParams.repeatTimes,
            nchwconvParams.dstRepStride,
            nchwconvParams.srcRepStride,
            static_cast<uint32_t>(sizeof(T)),
            static_cast<uint32_t>(sizeof(T)),
            static_cast<uint64_t>(dstLocal[i].GetSize() * sizeof(T)),
            static_cast<uint64_t>(src0Local[i].GetSize() * sizeof(T)),
            static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal[i].GetPosition()))),
            static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local[i].GetPosition()))) };
        if (!CheckFunTransposeImpl(chkParams, intriName)) {
            return false;
        }
    }
    return true;
}

template <typename T>
bool CheckFunProposal(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal, const int32_t repeatTimes,
    const char* intriName)
{
    check::VecProposalApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint8_t>(repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFunProposalImpl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFunProposal(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local, const LocalTensor<U>& src1Local,
    const int32_t repeatTimes, const char* intriName)
{
    check::VecProposalApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Local.GetPhyAddr())),
        static_cast<uint8_t>(repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Local.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Local.GetPosition()))) };
    return CheckFunProposalImpl(chkParams, intriName);
}

template <typename T>
bool CheckFunProposal(const LocalTensor<T>& dstLocal, const MrgSortSrcList<T>& srcLocal, const MrgSort4Info& params,
    const char* intriName)
{
    check::VecProposalApiParams chkParams1 { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.src1.GetPhyAddr())),
        static_cast<uint8_t>(params.repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.src1.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.src1.GetPosition()))),
        params.validBit,
        params.elementLengths,
        0 };
    check::VecProposalApiParams chkParams2 { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.src2.GetPhyAddr())),
        static_cast<uint8_t>(params.repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.src2.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.src2.GetPosition()))),
        params.validBit,
        params.elementLengths,
        1 };
    check::VecProposalApiParams chkParams3 { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.src3.GetPhyAddr())),
        static_cast<uint8_t>(params.repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.src3.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.src3.GetPosition()))),
        params.validBit,
        params.elementLengths,
        2 };
    check::VecProposalApiParams chkParams4 { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.src4.GetPhyAddr())),
        static_cast<uint8_t>(params.repeatTimes),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.src4.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.src4.GetPosition()))),
        params.validBit,
        params.elementLengths,
        3 };
    bool res = CheckFunProposalImpl(chkParams1, intriName);
    res = res && CheckFunProposalImpl(chkParams2, intriName);
    res = res && CheckFunProposalImpl(chkParams3, intriName);
    res = res && CheckFunProposalImpl(chkParams4, intriName);
    return res;
}

template <typename T>
bool CheckFuncLoadData2d(const LocalTensor<T>& dstLocal, const GlobalTensor<T>& srcLocal,
    const LoadData2DParams& loadDataParams, const char* intriName)
{
    uint64_t dstLocalLen;
    if constexpr (IsSameType<T, int4b_t>::value) {
        dstLocalLen = dstLocal.GetSize() / INT4_TWO;
    } else {
        dstLocalLen = dstLocal.GetSize() * sizeof(T);
    }
    check::LoadData2dApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint16_t>(loadDataParams.startIndex),
        static_cast<uint8_t>(loadDataParams.repeatTimes),
        static_cast<uint16_t>(loadDataParams.srcStride),
        static_cast<uint8_t>(loadDataParams.sid),
        static_cast<uint16_t>(loadDataParams.dstGap),
        static_cast<bool>(loadDataParams.ifTranspose),
        static_cast<uint8_t>(loadDataParams.addrMode),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocalLen),
        static_cast<uint64_t>(1024 * 1024),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(0))) };
    return CheckFuncLoadData2dImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncLoadData2d(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal,
    const LoadData2DParams& loadDataParams, const char* intriName)
{
    uint64_t dstLocalLen = 0;
    uint64_t srcLocalLen = 0;
    if constexpr (IsSameType<T, int4b_t>::value) {
        dstLocalLen = dstLocal.GetSize() / INT4_TWO;
        srcLocalLen = srcLocal.GetSize() / INT4_TWO;
    } else {
        dstLocalLen = dstLocal.GetSize() * sizeof(T);
        srcLocalLen = srcLocal.GetSize() * sizeof(T);
    }
    check::LoadData2dApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint16_t>(loadDataParams.startIndex),
        static_cast<uint8_t>(loadDataParams.repeatTimes),
        static_cast<uint16_t>(loadDataParams.srcStride),
        static_cast<uint8_t>(loadDataParams.sid),
        static_cast<uint16_t>(loadDataParams.dstGap),
        static_cast<bool>(loadDataParams.ifTranspose),
        static_cast<uint8_t>(loadDataParams.addrMode),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocalLen),
        static_cast<uint64_t>(srcLocalLen),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return CheckFuncLoadData2dImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncLoadData3dv1(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal,
    const LoadData3DParamsV1<T>& loadDataParams, const char* intriName)
{
    check::LoadData3dv1ApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        loadDataParams.padList,
        static_cast<uint16_t>(loadDataParams.l1H),
        static_cast<uint16_t>(loadDataParams.l1W),
        static_cast<uint16_t>(loadDataParams.c1Index),
        static_cast<uint8_t>(loadDataParams.fetchFilterW),
        static_cast<uint8_t>(loadDataParams.fetchFilterH),
        static_cast<uint16_t>(loadDataParams.leftTopW),
        static_cast<uint16_t>(loadDataParams.leftTopH),
        static_cast<uint8_t>(loadDataParams.strideW),
        static_cast<uint8_t>(loadDataParams.strideH),
        static_cast<uint8_t>(loadDataParams.filterW),
        static_cast<uint8_t>(loadDataParams.filterH),
        static_cast<uint8_t>(loadDataParams.dilationFilterW),
        static_cast<uint8_t>(loadDataParams.dilationFilterH),
        static_cast<uint8_t>(loadDataParams.jumpStride),
        static_cast<uint8_t>(loadDataParams.repeatMode),
        static_cast<uint8_t>(loadDataParams.repeatTime),
        static_cast<uint8_t>(loadDataParams.cSize),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return check::CheckFuncLoadData3dv1Impl(chkParams, intriName);
}

template <typename T>
bool CheckFuncLoadData3dv2(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal,
    const LoadData3DParamsV2<T>& loadDataParams, const char* intriName)
{
    check::LoadData3dv2ApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        loadDataParams.padList,
        static_cast<uint16_t>(loadDataParams.l1H),
        static_cast<uint16_t>(loadDataParams.l1W),
        static_cast<uint16_t>(loadDataParams.channelSize),
        static_cast<uint16_t>(loadDataParams.kExtension),
        static_cast<uint16_t>(loadDataParams.mExtension),
        static_cast<uint16_t>(loadDataParams.kStartPt),
        static_cast<uint16_t>(loadDataParams.mStartPt),
        static_cast<uint8_t>(loadDataParams.strideW),
        static_cast<uint8_t>(loadDataParams.strideH),
        static_cast<uint8_t>(loadDataParams.filterW),
        static_cast<uint8_t>(loadDataParams.filterH),
        static_cast<uint8_t>(loadDataParams.dilationFilterW),
        static_cast<uint8_t>(loadDataParams.dilationFilterH),
        static_cast<bool>(loadDataParams.enTranspose),
        static_cast<bool>(loadDataParams.enSmallK),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(srcLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return check::CheckFuncLoadData3dv2Impl(chkParams, intriName);
}

template <typename T>
bool CheckFuncLoadData3dv2Pro(const LocalTensor<T>& dstLocal, const LocalTensor<T>& srcLocal,
    const LoadData3DParamsV2Pro& loadDataParams, const char* intriName)
{
    check::LoadData3dv2ProApiParams chkParams{ static_cast<uint64_t>(
        reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(srcLocal.GetPhyAddr())),
        static_cast<uint16_t>(loadDataParams.channelSize),
        static_cast<uint16_t>(loadDataParams.extConfig),
        static_cast<uint16_t>(loadDataParams.extConfig >> LOAD_M_EXTENSION),
        static_cast<uint16_t>(loadDataParams.extConfig >> LOAD_K_START_POSITION),
        static_cast<uint16_t>(loadDataParams.extConfig >> LOAD_M_START_POSITION),
        static_cast<uint8_t>(loadDataParams.filterConfig),
        static_cast<uint8_t>(loadDataParams.filterConfig >> LOAD_STRIDE_H),
        static_cast<uint8_t>(loadDataParams.filterConfig >> LOAD_FILTER_W),
        static_cast<uint8_t>(loadDataParams.filterConfig >> LOAD_FILTER_H),
        static_cast<uint8_t>(loadDataParams.filterConfig >> LOAD_DILATION_FILTER_W),
        static_cast<uint8_t>(loadDataParams.filterConfig >> LOAD_DILATION_FILTER_H),
        static_cast<bool>(loadDataParams.enTranspose),
        static_cast<bool>(loadDataParams.enSmallK),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetLength()),
        static_cast<uint64_t>(srcLocal.GetLength()),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcLocal.GetPosition()))) };
    return check::CheckFuncLoadData3dv2ProImpl(chkParams, intriName);
}

template <typename T>
bool CheckFuncLoadImageToL1(const LocalTensor<T>& dstLocal,
    const LoadImageToL1Params& loadDataParams, const char* intriName)
{
    check::LoadImageToL1ApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint16_t>(loadDataParams.horSize),
        static_cast<uint16_t>(loadDataParams.verSize),
        static_cast<uint16_t>(loadDataParams.horStartP),
        static_cast<uint16_t>(loadDataParams.verStartP),
        static_cast<uint16_t>(loadDataParams.sHorRes),
        static_cast<uint8_t>(loadDataParams.topPadSize),
        static_cast<uint8_t>(loadDataParams.botPadSize),
        static_cast<uint16_t>(loadDataParams.lPadSize),
        static_cast<uint16_t>(loadDataParams.rPadSize),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))) };
    return CheckFuncLoadImageToL1Impl(chkParams, intriName);
}

template <typename T, typename U>
bool CheckFuncVecGatherMask(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local,
    const LocalTensor<U>& src1Pattern, const bool reduceMode, uint32_t mask, const GatherMaskParams& reducev2Params,
    uint64_t& rsvdCnt, const char* intriName)
{
    check::VecGatherMaskApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src1Pattern.GetPhyAddr())),
        reduceMode,
        reducev2Params.src0BlockStride,
        reducev2Params.repeatTimes,
        reducev2Params.src0RepeatStride,
        reducev2Params.src1RepeatStride,
        rsvdCnt,
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(U)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src1Pattern.GetSize() * sizeof(U)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1Pattern.GetPosition()))) };
    return CheckFuncVecGatherMaskImpl(chkParams, mask, intriName);
}

template <typename T>
bool CheckFuncVecGatherMask(const LocalTensor<T>& dstLocal, const LocalTensor<T>& src0Local, const uint8_t src1Pattern,
    const bool reduceMode, uint32_t mask, const GatherMaskParams& reducev2Params, uint64_t& rsvdCnt,
    const char* intriName)
{
    check::VecGatherMaskApiParams chkParams { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(dstLocal.GetPhyAddr())),
        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src0Local.GetPhyAddr())),
        src1Pattern,
        reduceMode,
        reducev2Params.src0BlockStride,
        reducev2Params.repeatTimes,
        reducev2Params.src0RepeatStride,
        reducev2Params.src1RepeatStride,
        rsvdCnt,
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint32_t>(sizeof(T)),
        static_cast<uint64_t>(dstLocal.GetSize() * sizeof(T)),
        static_cast<uint64_t>(src0Local.GetSize() * sizeof(T)),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstLocal.GetPosition()))),
        static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0Local.GetPosition()))) };
    return CheckFuncVecGatherMaskImpl(chkParams, mask, intriName);
}
} // namespace AscendC
#endif
#endif