LCOV - code coverage report
Current view: top level - utils/include/utils - kernel_check_cube_util.h (source / functions) Coverage Total Hit
Test: coverage.info_filtered Lines: 100.0 % 25 25
Test Date: 2026-07-27 14:41:20 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3              :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4              :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5              :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6              :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7              :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8              :  * See LICENSE in the root of the software repository for the full text of the License.
       9              :  */
      10              : 
      11              : /*!
      12              :  * \file kernel_check_cube_util.h
      13              :  * \brief
      14              :  */
      15              : 
      16              : #ifndef ASCENDC_CHECK_CUBE_UTIL_H
      17              : #define ASCENDC_CHECK_CUBE_UTIL_H
      18              : #if ASCENDC_CPU_DEBUG
      19              : #include <string>
      20              : #include "kernel_utils.h"
      21              : namespace AscendC {
      22              : namespace check {
      23              : struct MmadApiParams {
      24              :     MmadApiParams() {}
      25           12 :     MmadApiParams(
      26              :         uint64_t dstAddrIn, uint64_t src0AddrIn, uint64_t src1AddrIn, uint32_t dstDtypeBytesIn,
      27              :         uint32_t src0DtypeBytesIn, uint32_t src1DtypeBytesIn, uint64_t dstSizeIn, uint64_t src0SizeIn,
      28              :         uint64_t src1SizeIn, uint8_t dstPosIn, uint8_t src0PosIn, uint8_t src1PosIn, uint16_t mIn, uint16_t nIn,
      29              :         uint16_t kIn, bool isBiasIn, int32_t fmOffsetIn, bool enSsparseIn, bool enWinogradAIn, bool enWinogradBIn)
      30           12 :         : dstAddr(dstAddrIn),
      31           12 :           src0Addr(src0AddrIn),
      32           12 :           src1Addr(src1AddrIn),
      33           12 :           dstDtypeBytes(dstDtypeBytesIn),
      34           12 :           src0DtypeBytes(src0DtypeBytesIn),
      35           12 :           src1DtypeBytes(src1DtypeBytesIn),
      36           12 :           dstSize(dstSizeIn),
      37           12 :           src0Size(src0SizeIn),
      38           12 :           src1Size(src1SizeIn),
      39           12 :           dstLogicPos(dstPosIn),
      40           12 :           src0LogicPos(src0PosIn),
      41           12 :           src1LogicPos(src1PosIn),
      42           12 :           m(mIn),
      43           12 :           n(nIn),
      44           12 :           k(kIn),
      45           12 :           isBias(isBiasIn),
      46           12 :           fmOffset(fmOffsetIn),
      47           12 :           enSsparse(enSsparseIn),
      48           12 :           enWinogradA(enWinogradAIn),
      49           12 :           enWinogradB(enWinogradBIn)
      50              :     {
      51           12 :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
      52           12 :         src0Pos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0PosIn)));
      53           12 :         src1Pos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1PosIn)));
      54           12 :     }
      55              : 
      56              :     MmadApiParams(
      57              :         uint64_t dstAddrIn, uint64_t src0AddrIn, uint64_t src1AddrIn, uint64_t src2AddrIn, uint32_t dstDtypeBytesIn,
      58              :         uint32_t src0DtypeBytesIn, uint32_t src1DtypeBytesIn, uint32_t src2DtypeBytesIn, uint64_t dstSizeIn,
      59              :         uint64_t src0SizeIn, uint64_t src1SizeIn, uint64_t src2SizeIn, uint8_t dstPosIn, uint8_t src0PosIn,
      60              :         uint8_t src1PosIn, uint8_t src2PosIn, uint16_t mIn, uint16_t nIn, uint16_t kIn, bool isBiasIn,
      61              :         int32_t fmOffsetIn, bool enSsparseIn, bool enWinogradAIn, bool enWinogradBIn)
      62              :         : dstAddr(dstAddrIn),
      63              :           src0Addr(src0AddrIn),
      64              :           src1Addr(src1AddrIn),
      65              :           src2Addr(src2AddrIn),
      66              :           dstDtypeBytes(dstDtypeBytesIn),
      67              :           src0DtypeBytes(src0DtypeBytesIn),
      68              :           src1DtypeBytes(src1DtypeBytesIn),
      69              :           src2DtypeBytes(src2DtypeBytesIn),
      70              :           dstSize(dstSizeIn),
      71              :           src0Size(src0SizeIn),
      72              :           src1Size(src1SizeIn),
      73              :           src2Size(src2SizeIn),
      74              :           dstLogicPos(dstPosIn),
      75              :           src0LogicPos(src0PosIn),
      76              :           src1LogicPos(src1PosIn),
      77              :           src2LogicPos(src2PosIn),
      78              :           m(mIn),
      79              :           n(nIn),
      80              :           k(kIn),
      81              :           isBias(isBiasIn),
      82              :           fmOffset(fmOffsetIn),
      83              :           enSsparse(enSsparseIn),
      84              :           enWinogradA(enWinogradAIn),
      85              :           enWinogradB(enWinogradBIn)
      86              :     {
      87              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
      88              :         src0Pos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src0PosIn)));
      89              :         src1Pos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src1PosIn)));
      90              :         src2Pos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(src2PosIn)));
      91              :     }
      92              : 
      93              :     uint64_t dstAddr = 0;
      94              :     uint64_t src0Addr = 0;
      95              :     uint64_t src1Addr = 0;
      96              :     uint64_t src2Addr = 0;
      97              :     uint32_t dstDtypeBytes = 0;
      98              :     uint32_t src0DtypeBytes = 0;
      99              :     uint32_t src1DtypeBytes = 0;
     100              :     uint32_t src2DtypeBytes = 0;
     101              :     uint64_t dstSize = 0;
     102              :     uint64_t src0Size = 0;
     103              :     uint64_t src1Size = 0;
     104              :     uint64_t src2Size = 0;
     105              :     uint8_t dstLogicPos = 0;
     106              :     uint8_t src0LogicPos = 0;
     107              :     uint8_t src1LogicPos = 0;
     108              :     uint8_t src2LogicPos = 0;
     109              :     uint8_t dstPos = 0;
     110              :     uint8_t src0Pos = 0;
     111              :     uint8_t src1Pos = 0;
     112              :     uint8_t src2Pos = 0;
     113              :     uint16_t m = 0;
     114              :     uint16_t n = 0;
     115              :     uint16_t k = 0;
     116              :     // Indicates whether to accumulate the initial matrix, 0: matrix multiplication, 1: matrix multiplication and
     117              :     // addition
     118              :     bool isBias = false;
     119              :     // Left matrix offset
     120              :     int32_t fmOffset = 0;
     121              :     // Enable the structured sparse feature, default value is false
     122              :     bool enSsparse = false;
     123              :     // Indicates whether matrix a is generated by winograd_feature_map_transform, default value is false;
     124              :     bool enWinogradA = false;
     125              :     // Indicates whether matrix b is generated by winograd_feature_map_transform, default value is false;
     126              :     bool enWinogradB = false;
     127              : };
     128              : 
     129              : struct CubeInitConstValueApiParams {
     130              :     CubeInitConstValueApiParams() {}
     131              :     CubeInitConstValueApiParams(
     132              :         uint64_t dstAddrIn, uint8_t repeatIn, uint16_t blkNumIn, uint16_t dstGapIn, uint32_t dstDtypeBytesIn,
     133              :         uint64_t dstSizeIn, uint8_t dstPosIn)
     134              :     {
     135              :         dstAddr = dstAddrIn;
     136              :         repeatTimes = repeatIn;
     137              :         blockNum = blkNumIn;
     138              :         dstGap = dstGapIn;
     139              :         dstDtypeBytes = dstDtypeBytesIn;
     140              :         dstSize = dstSizeIn;
     141              :         dstLogicPos = dstPosIn;
     142              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     143              :     }
     144              : 
     145              :     uint64_t dstAddr = 0;
     146              :     uint16_t repeatTimes = 0;
     147              :     uint16_t blockNum = 0;
     148              :     uint16_t dstGap = 0;
     149              :     uint32_t dstDtypeBytes = 0;
     150              :     uint64_t dstSize = 0;
     151              :     uint8_t dstLogicPos = 0;
     152              :     uint8_t dstPos = 0;
     153              : };
     154              : 
     155              : struct LoadData2dApiParams {
     156              :     LoadData2dApiParams() {}
     157              :     LoadData2dApiParams(
     158              :         uint64_t dstAddrIn, uint64_t srcAddrIn, uint16_t startIndexIn, uint8_t repeatTimesIn, uint16_t srcStrideIn,
     159              :         uint8_t sidIn, uint16_t dstGapIn, bool ifTransposeIn, uint8_t addrModeIn, uint32_t dstDtypeBytesIn,
     160              :         uint32_t srcDtypeBytesIn, uint64_t dstSizeIn, uint64_t srcSizeIn, uint8_t dstPosIn, uint8_t srcPosIn)
     161              :     {
     162              :         dstAddr = dstAddrIn;
     163              :         srcAddr = srcAddrIn;
     164              :         startIndex = startIndexIn;
     165              :         repeatTimes = repeatTimesIn;
     166              :         srcStride = srcStrideIn;
     167              :         sid = sidIn;
     168              :         dstGap = dstGapIn;
     169              :         ifTranspose = ifTransposeIn;
     170              :         addrMode = addrModeIn;
     171              :         dstDtypeBytes = dstDtypeBytesIn;
     172              :         srcDtypeBytes = srcDtypeBytesIn;
     173              :         dstSize = dstSizeIn;
     174              :         srcSize = srcSizeIn;
     175              :         dstLogicPos = dstPosIn;
     176              :         srcLogicPos = srcPosIn;
     177              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     178              :         srcPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcPosIn)));
     179              :     }
     180              :     uint64_t dstAddr = 0;
     181              :     uint64_t srcAddr = 0;
     182              :     uint16_t startIndex = 0;
     183              :     uint8_t repeatTimes = 0;
     184              :     uint16_t srcStride = 0;
     185              :     uint8_t sid = 0;
     186              :     uint16_t dstGap = 0;
     187              :     bool ifTranspose = false;
     188              :     uint8_t addrMode = 0;
     189              :     uint32_t dstDtypeBytes = 0;
     190              :     uint32_t srcDtypeBytes = 0;
     191              :     uint64_t dstSize = 0;
     192              :     uint64_t srcSize = 0;
     193              :     uint8_t dstLogicPos = 0;
     194              :     uint8_t srcLogicPos = 0;
     195              :     uint8_t dstPos = 0;
     196              :     uint8_t srcPos = 0;
     197              : };
     198              : 
     199              : struct LoadData2dv2ApiParams {
     200              :     LoadData2dv2ApiParams() {}
     201              :     LoadData2dv2ApiParams(
     202              :         uint64_t dstAddrIn, uint64_t srcAddrIn, uint32_t mStartPositionIn, uint32_t kStartPositionIn, uint16_t mStepIn,
     203              :         uint16_t kStepIn, int32_t srcStrideIn, uint16_t dstStrideIn, bool ifTransposeIn, uint8_t sidIn,
     204              :         uint32_t dstDtypeBytesIn, uint32_t srcDtypeBytesIn, uint64_t dstSizeIn, uint64_t srcSizeIn, uint8_t dstPosIn,
     205              :         uint8_t srcPosIn)
     206              :     {
     207              :         dstAddr = dstAddrIn;
     208              :         srcAddr = srcAddrIn;
     209              :         mStartPosition = mStartPositionIn;
     210              :         kStartPosition = kStartPositionIn;
     211              :         mStep = mStepIn;
     212              :         kStep = kStepIn;
     213              :         srcStride = srcStrideIn;
     214              :         dstStride = dstStrideIn;
     215              :         ifTranspose = ifTransposeIn;
     216              :         sid = sidIn;
     217              :         dstDtypeBytes = dstDtypeBytesIn;
     218              :         srcDtypeBytes = srcDtypeBytesIn;
     219              :         dstSize = dstSizeIn;
     220              :         srcSize = srcSizeIn;
     221              :         dstLogicPos = dstPosIn;
     222              :         srcLogicPos = srcPosIn;
     223              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     224              :         srcPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcPosIn)));
     225              :     }
     226              :     uint64_t dstAddr = 0;
     227              :     uint64_t srcAddr = 0;
     228              :     uint32_t mStartPosition = 0;
     229              :     uint32_t kStartPosition = 0;
     230              :     uint16_t mStep = 0;
     231              :     uint16_t kStep = 0;
     232              :     int32_t srcStride = 0;
     233              :     uint16_t dstStride = 0;
     234              :     bool ifTranspose = false;
     235              :     uint8_t sid = 0;
     236              :     uint32_t dstDtypeBytes = 0;
     237              :     uint32_t srcDtypeBytes = 0;
     238              :     uint64_t dstSize = 0;
     239              :     uint64_t srcSize = 0;
     240              :     uint8_t dstLogicPos = 0;
     241              :     uint8_t srcLogicPos = 0;
     242              :     uint8_t dstPos = 0;
     243              :     uint8_t srcPos = 0;
     244              : };
     245              : 
     246              : struct LoadData3dv1ApiParams {
     247              :     LoadData3dv1ApiParams() {}
     248              :     LoadData3dv1ApiParams(
     249              :         uint64_t dstAddrIn, uint64_t srcAddrIn, const uint8_t padListIn[4], uint16_t l1HIn, uint16_t l1WIn,
     250              :         uint16_t c1IndexIn, uint8_t fetchFilterWIn, uint8_t fetchFilterHIn, uint16_t leftTopWIn, uint16_t leftTopHIn,
     251              :         uint8_t strideWIn, uint8_t strideHIn, uint8_t filterWIn, uint8_t filterHIn, uint8_t dilationFilterWIn,
     252              :         uint8_t dilationFilterHIn, uint8_t jumpStrideIn, uint8_t repeatModeIn, uint8_t repeatTimeIn, uint8_t cSizeIn,
     253              :         uint32_t dstDtypeBytesIn, uint32_t srcDtypeBytesIn, uint64_t dstSizeIn, uint64_t srcSizeIn, uint8_t dstPosIn,
     254              :         uint8_t srcPosIn)
     255              :     {
     256              :         dstAddr = dstAddrIn;
     257              :         srcAddr = srcAddrIn;
     258              :         for (size_t i = 0; i < PAD_SIZE; ++i) {
     259              :             padList[i] = padListIn[i];
     260              :         }
     261              :         l1H = l1HIn;
     262              :         l1W = l1WIn;
     263              :         c1Index = c1IndexIn;
     264              :         fetchFilterW = fetchFilterWIn;
     265              :         fetchFilterH = fetchFilterHIn;
     266              :         leftTopW = leftTopWIn;
     267              :         leftTopH = leftTopHIn;
     268              :         strideW = strideWIn;
     269              :         strideH = strideHIn;
     270              :         filterW = filterWIn;
     271              :         filterH = filterHIn;
     272              :         dilationFilterW = dilationFilterWIn;
     273              :         dilationFilterH = dilationFilterHIn;
     274              :         jumpStride = jumpStrideIn;
     275              :         repeatMode = repeatModeIn;
     276              :         repeatTime = repeatTimeIn;
     277              :         cSize = cSizeIn;
     278              :         dstDtypeBytes = dstDtypeBytesIn;
     279              :         srcDtypeBytes = srcDtypeBytesIn;
     280              :         dstSize = dstSizeIn;
     281              :         srcSize = srcSizeIn;
     282              :         dstLogicPos = dstPosIn;
     283              :         srcLogicPos = srcPosIn;
     284              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     285              :         srcPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcPosIn)));
     286              :     }
     287              :     uint64_t dstAddr = 0;
     288              :     uint64_t srcAddr = 0;
     289              :     uint8_t padList[4];
     290              :     uint8_t strideW = 0;
     291              :     uint8_t strideH = 0;
     292              :     uint8_t filterW = 0;
     293              :     uint8_t filterH = 0;
     294              :     uint8_t dilationFilterW = 0;
     295              :     uint8_t dilationFilterH = 0;
     296              :     uint8_t jumpStride = 0;
     297              :     uint8_t repeatMode = 0;
     298              :     uint8_t repeatTime = 0;
     299              :     uint8_t cSize = 0;
     300              :     uint8_t fetchFilterW = 0;
     301              :     uint8_t fetchFilterH = 0;
     302              :     uint16_t l1H = 0;
     303              :     uint16_t l1W = 0;
     304              :     uint16_t c1Index = 0;
     305              :     int16_t leftTopW = 0;
     306              :     int16_t leftTopH = 0;
     307              :     uint32_t dstDtypeBytes = 0;
     308              :     uint32_t srcDtypeBytes = 0;
     309              :     uint64_t dstSize = 0;
     310              :     uint64_t srcSize = 0;
     311              :     uint8_t dstLogicPos = 0;
     312              :     uint8_t srcLogicPos = 0;
     313              :     uint8_t dstPos = 0;
     314              :     uint8_t srcPos = 0;
     315              : };
     316              : 
     317              : struct LoadData3dv2ApiParams {
     318              :     LoadData3dv2ApiParams() {}
     319              :     LoadData3dv2ApiParams(
     320              :         uint64_t dstAddrIn, uint64_t srcAddrIn, const uint8_t padListIn[4], uint16_t l1HIn, uint16_t l1WIn,
     321              :         uint16_t channelSizeIn, uint16_t kExtensionIn, uint16_t mExtensionIn, uint16_t kStartPtIn, uint16_t mStartPtIn,
     322              :         uint8_t strideWIn, uint8_t strideHIn, uint8_t filterWIn, uint8_t filterHIn, uint8_t dilationFilterWIn,
     323              :         uint8_t dilationFilterHIn, bool enTransposeIn, bool enSmallKIn, uint32_t dstDtypeBytesIn,
     324              :         uint32_t srcDtypeBytesIn, uint64_t dstSizeIn, uint64_t srcSizeIn, uint8_t dstPosIn, uint8_t srcPosIn)
     325              :     {
     326              :         dstAddr = dstAddrIn;
     327              :         srcAddr = srcAddrIn;
     328              :         for (size_t i = 0; i < PAD_SIZE; ++i) {
     329              :             padList[i] = padListIn[i];
     330              :         }
     331              :         l1H = l1HIn;
     332              :         l1W = l1WIn;
     333              :         channelSize = channelSizeIn;
     334              :         kExtension = kExtensionIn;
     335              :         mExtension = mExtensionIn;
     336              :         kStartPt = kStartPtIn;
     337              :         mStartPt = mStartPtIn;
     338              :         strideW = strideWIn;
     339              :         strideH = strideHIn;
     340              :         filterW = filterWIn;
     341              :         filterH = filterHIn;
     342              :         dilationFilterW = dilationFilterWIn;
     343              :         dilationFilterH = dilationFilterHIn;
     344              :         enTranspose = enTransposeIn;
     345              :         enSmallK = enSmallKIn;
     346              :         filterSizeW = false;
     347              :         filterSizeH = false;
     348              :         fMatrixCtrl = false;
     349              :         dstDtypeBytes = dstDtypeBytesIn;
     350              :         srcDtypeBytes = srcDtypeBytesIn;
     351              :         dstSize = dstSizeIn;
     352              :         srcSize = srcSizeIn;
     353              :         dstLogicPos = dstPosIn;
     354              :         srcLogicPos = srcPosIn;
     355              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     356              :         srcPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcPosIn)));
     357              :     }
     358              :     uint64_t dstAddr = 0;
     359              :     uint64_t srcAddr = 0;
     360              :     uint8_t padList[4];
     361              :     uint16_t l1H = 0;
     362              :     uint16_t l1W = 0;
     363              :     uint16_t channelSize = 0;
     364              :     uint16_t kExtension = 0;
     365              :     uint16_t mExtension = 0;
     366              :     uint16_t kStartPt = 0;
     367              :     uint16_t mStartPt = 0;
     368              :     uint8_t strideW = 0;
     369              :     uint8_t strideH = 0;
     370              :     uint8_t filterW = 0;
     371              :     uint8_t filterH = 0;
     372              :     uint8_t dilationFilterW = 0;
     373              :     uint8_t dilationFilterH = 0;
     374              :     bool enTranspose = false;
     375              :     bool enSmallK = false;
     376              :     bool filterSizeW = false;
     377              :     bool filterSizeH = false;
     378              :     bool fMatrixCtrl = false;
     379              :     uint32_t dstDtypeBytes = 0;
     380              :     uint32_t srcDtypeBytes = 0;
     381              :     uint64_t dstSize = 0;
     382              :     uint64_t srcSize = 0;
     383              :     uint8_t dstLogicPos = 0;
     384              :     uint8_t srcLogicPos = 0;
     385              :     uint8_t dstPos = 0;
     386              :     uint8_t srcPos = 0;
     387              : };
     388              : 
     389              : struct LoadData3dv2ProApiParams {
     390              :     LoadData3dv2ProApiParams() {}
     391              :     LoadData3dv2ProApiParams(
     392              :         uint64_t dstAddrIn, uint64_t srcAddrIn, uint16_t channelSizeIn, uint16_t kExtensionIn, uint16_t mExtensionIn,
     393              :         uint16_t kStartPtIn, uint16_t mStartPtIn, uint8_t strideWIn, uint8_t strideHIn, uint8_t filterWIn,
     394              :         uint8_t filterHIn, uint8_t dilationFilterWIn, uint8_t dilationFilterHIn, bool enTransposeIn, bool enSmallKIn,
     395              :         uint32_t dstDtypeBytesIn, uint32_t srcDtypeBytesIn, uint64_t dstSizeIn, uint64_t srcSizeIn, uint8_t dstPosIn,
     396              :         uint8_t srcPosIn)
     397              :     {
     398              :         dstAddr = dstAddrIn;
     399              :         srcAddr = srcAddrIn;
     400              :         channelSize = channelSizeIn;
     401              :         kExtension = kExtensionIn;
     402              :         mExtension = mExtensionIn;
     403              :         kStartPt = kStartPtIn;
     404              :         mStartPt = mStartPtIn;
     405              :         strideW = strideWIn;
     406              :         strideH = strideHIn;
     407              :         filterW = filterWIn;
     408              :         filterH = filterHIn;
     409              :         dilationFilterW = dilationFilterWIn;
     410              :         dilationFilterH = dilationFilterHIn;
     411              :         enTranspose = enTransposeIn;
     412              :         enSmallK = enSmallKIn;
     413              :         filterSizeW = false;
     414              :         filterSizeH = false;
     415              :         fMatrixCtrl = false;
     416              :         dstDtypeBytes = dstDtypeBytesIn;
     417              :         srcDtypeBytes = srcDtypeBytesIn;
     418              :         dstSize = dstSizeIn;
     419              :         srcSize = srcSizeIn;
     420              :         dstLogicPos = dstPosIn;
     421              :         srcLogicPos = srcPosIn;
     422              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     423              :         srcPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(srcPosIn)));
     424              :     }
     425              :     uint64_t dstAddr = 0;
     426              :     uint64_t srcAddr = 0;
     427              :     uint16_t channelSize = 0;
     428              :     uint16_t kExtension = 0;
     429              :     uint16_t mExtension = 0;
     430              :     uint16_t kStartPt = 0;
     431              :     uint16_t mStartPt = 0;
     432              :     uint8_t strideW = 0;
     433              :     uint8_t strideH = 0;
     434              :     uint8_t filterW = 0;
     435              :     uint8_t filterH = 0;
     436              :     uint8_t dilationFilterW = 0;
     437              :     uint8_t dilationFilterH = 0;
     438              :     bool enTranspose = false;
     439              :     bool enSmallK = false;
     440              :     bool filterSizeW = false;
     441              :     bool filterSizeH = false;
     442              :     bool fMatrixCtrl = false;
     443              :     uint32_t dstDtypeBytes = 0;
     444              :     uint32_t srcDtypeBytes = 0;
     445              :     uint64_t dstSize = 0;
     446              :     uint64_t srcSize = 0;
     447              :     uint8_t dstLogicPos = 0;
     448              :     uint8_t srcLogicPos = 0;
     449              :     uint8_t dstPos = 0;
     450              :     uint8_t srcPos = 0;
     451              : };
     452              : 
     453              : struct LoadImageToLocalApiParams {
     454              :     __aicore__ LoadImageToLocalApiParams()
     455              :     {
     456              :         dstAddr = 0;
     457              :         horizSize = 0;
     458              :         vertSize = 0;
     459              :         horizStartPos = 0;
     460              :         vertStartPos = 0;
     461              :         srcHorizSize = 0;
     462              :         topPadSize = 0;
     463              :         botPadSize = 0;
     464              :         leftPadSize = 0;
     465              :         rightPadSize = 0;
     466              :         dstDtypeBytes = 0;
     467              :         dstSize = 0;
     468              :         dstLogicPos = 0;
     469              :         dstPos = 0;
     470              :     }
     471              : 
     472              :     __aicore__ LoadImageToLocalApiParams(
     473              :         uint64_t dstAddrIn, uint16_t horizSizeIn, uint16_t vertSizeIn, uint16_t horizStartPosIn,
     474              :         uint16_t vertStartPosIn, uint16_t srcHorizSizeIn, uint8_t topPadSizeIn, uint8_t botPadSizeIn,
     475              :         uint16_t leftPadSizeIn, uint16_t rightPadSizeIn, uint32_t dstDtypeBytesIn, uint64_t dstSizeIn, uint8_t dstPosIn)
     476              :     {
     477              :         dstAddr = dstAddrIn;
     478              :         horizSize = horizSizeIn;
     479              :         vertSize = vertSizeIn;
     480              :         horizStartPos = horizStartPosIn;
     481              :         vertStartPos = vertStartPosIn;
     482              :         srcHorizSize = srcHorizSizeIn;
     483              :         topPadSize = topPadSizeIn;
     484              :         botPadSize = botPadSizeIn;
     485              :         leftPadSize = leftPadSizeIn;
     486              :         rightPadSize = rightPadSizeIn;
     487              :         dstDtypeBytes = dstDtypeBytesIn;
     488              :         dstSize = dstSizeIn;
     489              :         dstLogicPos = dstPosIn;
     490              :         dstPos = static_cast<uint8_t>(GetPhyType(static_cast<TPosition>(dstPosIn)));
     491              :     }
     492              : 
     493              :     uint64_t dstAddr = 0;
     494              :     uint16_t horizSize = 0;
     495              :     uint16_t vertSize = 0;
     496              :     uint16_t horizStartPos = 0;
     497              :     uint16_t vertStartPos = 0;
     498              :     uint16_t srcHorizSize = 0;
     499              :     uint8_t topPadSize = 0;
     500              :     uint8_t botPadSize = 0;
     501              :     uint16_t leftPadSize = 0;
     502              :     uint16_t rightPadSize = 0;
     503              :     uint32_t dstDtypeBytes = 0;
     504              :     uint64_t dstSize = 0;
     505              :     uint8_t dstLogicPos = 0;
     506              :     uint8_t dstPos = 0;
     507              : };
     508              : 
     509              : bool CheckFuncMmadImpl(MmadApiParams& chkParams, const char* intriName);
     510              : 
     511              : bool CheckFuncInitConstValueImpl(CubeInitConstValueApiParams& chkParams, const char* intriName);
     512              : 
     513              : bool CheckFuncLoadData2dImpl(LoadData2dApiParams& chkParams, const char* intriName);
     514              : 
     515              : bool CheckFuncLoadData2dv2Impl(LoadData2dv2ApiParams& chkParams, const char* intriName);
     516              : 
     517              : bool CheckFuncLoadData3dv1Impl(LoadData3dv1ApiParams& chkParams, const char* intriName);
     518              : 
     519              : bool CheckFuncLoadData3dv2Impl(LoadData3dv2ApiParams& chkParams, const char* intriName);
     520              : 
     521              : bool CheckFuncLoadData3dv2ProImpl(LoadData3dv2ProApiParams& chkParams, const char* intriName);
     522              : 
     523              : bool CheckFuncLoadImageToLocalImpl(LoadImageToLocalApiParams& chkParams, const char* intriName);
     524              : 
     525              : } // namespace check
     526              : } // namespace AscendC
     527              : #endif
     528              : #endif
        

Generated by: LCOV version 2.0-1