Merged
kirin 5161: add macro fixpipe api #7339
zengjuanAdd on 13 days ago
kirin 5161: add macro fixpipe api #7339
Merged
Merged fromzengjuan/asc-devkit_516masterintocann/asc-devkitmaster
Total: 8 files changed+1219-0
| @@ -205,6 +205,38 @@ struct ConvPaddingBitModeConfig0 { | |||
| 205 | __aicore__ inline uint16_t GetPaddingAddr() const { return paddingAddr; }; | 205 | __aicore__ inline uint16_t GetPaddingAddr() const { return paddingAddr; }; |
| 206 | }; | 206 | }; |
| 207 | 207 | ||
| 208 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 209 | +struct FixPipeConfigBitModeConfig0 { | ||
| 210 | + uint64_t preReluAddr : 8; | ||
| 211 | + uint64_t preQuantAddr : 8; | ||
| 212 | + uint64_t reserved0 : 8; | ||
| 213 | + uint64_t postQuantAddr : 8; | ||
| 214 | + uint64_t antiquantAddr : 8; | ||
| 215 | + uint64_t shiftValue : 6; | ||
| 216 | + uint64_t reserved1 : 18; | ||
| 217 | + | ||
| 218 | + __aicore__ inline void Init(const FixPipeConfigParams& params) | ||
| 219 | + { | ||
| 220 | + preReluAddr = params.preReluAddr; | ||
| 221 | + preQuantAddr = params.preQuantAddr; | ||
| 222 | + postQuantAddr = params.postQuantAddr; | ||
| 223 | + antiquantAddr = params.antiquantAddr; | ||
| 224 | + shiftValue = params.shiftValue; | ||
| 225 | + } | ||
| 226 | + | ||
| 227 | + __aicore__ inline void SetPreReluAddr(uint8_t preReluAddr_) { preReluAddr = preReluAddr_; }; | ||
| 228 | + __aicore__ inline void SetPreQuantAddr(uint8_t preQuantAddr_) { preQuantAddr = preQuantAddr_; }; | ||
| 229 | + __aicore__ inline void SetPostQuantAddr(uint8_t postQuantAddr_) { postQuantAddr = postQuantAddr_; }; | ||
| 230 | + __aicore__ inline void SetAntiquantAddr(uint8_t antiquantAddr_) { antiquantAddr = antiquantAddr_; }; | ||
| 231 | + __aicore__ inline void SetShiftValue(uint8_t shiftValue_) { shiftValue = shiftValue_; }; | ||
| 232 | + | ||
| 233 | + __aicore__ inline uint8_t GetPreReluAddr() const { return preReluAddr; }; | ||
| 234 | + __aicore__ inline uint8_t GetPreQuantAddr() const { return preQuantAddr; }; | ||
| 235 | + __aicore__ inline uint8_t GetPostQuantAddr() const { return postQuantAddr; }; | ||
| 236 | + __aicore__ inline uint8_t GetAntiquantAddr() const { return antiquantAddr; }; | ||
| 237 | + __aicore__ inline uint8_t GetShiftValue() const { return shiftValue; }; | ||
| 238 | +}; | ||
| 239 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 208 | struct FixPipeConfigBitModeConfig0 { | 240 | struct FixPipeConfigBitModeConfig0 { |
| 209 | uint64_t preReluAddr : 8; | 241 | uint64_t preReluAddr : 8; |
| 210 | uint64_t preQuantAddr : 8; | 242 | uint64_t preQuantAddr : 8; |
| @@ -239,6 +271,7 @@ struct FixPipeConfigBitModeConfig0 { | |||
| 239 | __aicore__ inline uint8_t GetShiftValue() const { return shiftValue; }; | 271 | __aicore__ inline uint8_t GetShiftValue() const { return shiftValue; }; |
| 240 | __aicore__ inline uint8_t GetRestorationCtrl() const { return restorationCtrl; }; | 272 | __aicore__ inline uint8_t GetRestorationCtrl() const { return restorationCtrl; }; |
| 241 | }; | 273 | }; |
| 274 | +#endif | ||
| 242 | 275 | ||
| 243 | struct FixPipeReluAlphaBitModeConfig0 { | 276 | struct FixPipeReluAlphaBitModeConfig0 { |
| 244 | uint64_t lut : 3; | 277 | uint64_t lut : 3; |
| @@ -703,6 +736,210 @@ struct PostProcBitModeConfig0 { | |||
| 703 | __aicore__ inline instr_id_t GetInstrId() const { return static_cast<instr_id_t>(instrId); }; | 736 | __aicore__ inline instr_id_t GetInstrId() const { return static_cast<instr_id_t>(instrId); }; |
| 704 | __aicore__ inline uint16_t GetN() const { return n; }; | 737 | __aicore__ inline uint16_t GetN() const { return n; }; |
| 705 | }; | 738 | }; |
| 739 | + | ||
| 740 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 741 | +struct FixpNzParaBitModeConfig0 { | ||
| 742 | + uint64_t loop4Size : 16; | ||
| 743 | + uint64_t loop2SrcStride : 16; | ||
| 744 | + uint64_t loop3SrcStride : 16; | ||
| 745 | + uint64_t loop4SrcStride : 16; | ||
| 746 | + | ||
| 747 | + __aicore__ inline void Init(const FixpNzParaParams& params) | ||
| 748 | + { | ||
| 749 | + ASSERT( | ||
| 750 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 751 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 752 | + loop4Size = params.loop4Size; | ||
| 753 | + loop2SrcStride = params.loop2SrcStride | params.loop1SrcStride; | ||
| 754 | + loop3SrcStride = params.loop3SrcStride; | ||
| 755 | + loop4SrcStride = params.loop4SrcStride; | ||
| 756 | + } | ||
| 757 | + | ||
| 758 | + __aicore__ inline void SetLoop4Size(uint16_t loop4Size_) { loop4Size = loop4Size_; }; | ||
| 759 | + __aicore__ inline void SetLoop2SrcStride(uint16_t loop2SrcStride_) { loop2SrcStride = loop2SrcStride_; }; | ||
| 760 | + __aicore__ inline void SetLoop3SrcStride(uint16_t loop3SrcStride_) { loop3SrcStride = loop3SrcStride_; }; | ||
| 761 | + __aicore__ inline void SetLoop4SrcStride(uint16_t loop4SrcStride_) { loop4SrcStride = loop4SrcStride_; }; | ||
| 762 | + | ||
| 763 | + __aicore__ inline uint16_t GetLoop4Size() const { return loop4Size; }; | ||
| 764 | + __aicore__ inline uint16_t GetLoop2SrcStride() const { return loop2SrcStride; }; | ||
| 765 | + __aicore__ inline uint16_t GetLoop3SrcStride() const { return loop3SrcStride; }; | ||
| 766 | + __aicore__ inline uint16_t GetLoop4SrcStride() const { return loop4SrcStride; }; | ||
| 767 | +}; | ||
| 768 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 769 | +struct FixpNzParaBitModeConfig0 { | ||
| 770 | + uint64_t loop4Size : 16; | ||
| 771 | + uint64_t loop4SrcStride : 16; | ||
| 772 | + uint64_t loop4DstStride : 32; | ||
| 773 | + | ||
| 774 | + __aicore__ inline void Init(const FixpNzParaParams& params) | ||
| 775 | + { | ||
| 776 | + loop4Size = params.loop4Size; | ||
| 777 | + loop4SrcStride = params.loop4SrcStride; | ||
| 778 | + loop4DstStride = params.loop4DstStride; | ||
| 779 | + } | ||
| 780 | + | ||
| 781 | + __aicore__ inline void SetLoop4Size(uint16_t loop4Size_) { loop4Size = loop4Size_; }; | ||
| 782 | + __aicore__ inline void SetLoop4SrcStride(uint16_t loop4SrcStride_) { loop4SrcStride = loop4SrcStride_; }; | ||
| 783 | + __aicore__ inline void SetLoop4DstStride(uint32_t loop4DstStride_) { loop4DstStride = loop4DstStride_; }; | ||
| 784 | + | ||
| 785 | + __aicore__ inline uint16_t GetLoop4Size() const { return loop4Size; }; | ||
| 786 | + __aicore__ inline uint16_t GetLoop4SrcStride() const { return loop4SrcStride; }; | ||
| 787 | + __aicore__ inline uint32_t GetLoop4DstStride() const { return loop4DstStride; }; | ||
| 788 | +}; | ||
| 789 | +#endif | ||
| 790 | + | ||
| 791 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 792 | +struct FixpLoopenhanceParaBitModeConfig0 { | ||
| 793 | + uint64_t loop3DstStride : 40; | ||
| 794 | + uint64_t loop1Size : 16; | ||
| 795 | + uint64_t padEn : 1; | ||
| 796 | + uint64_t splitEn : 1; | ||
| 797 | + uint64_t reserved0 : 6; | ||
| 798 | + | ||
| 799 | + __aicore__ inline void Init(const FixpLoopenhanceParaParams& params) | ||
| 800 | + { | ||
| 801 | + loop3DstStride = params.loop3DstStride; | ||
| 802 | + loop1Size = params.loop1Size; | ||
| 803 | + padEn = params.padEn ? 1 : 0; | ||
| 804 | + splitEn = params.splitEn ? 1 : 0; | ||
| 805 | + } | ||
| 806 | + | ||
| 807 | + __aicore__ inline void SetLoop3DstStride(uint64_t loop3DstStride_) { loop3DstStride = loop3DstStride_; }; | ||
| 808 | + __aicore__ inline void SetLoop1Size(uint16_t loop1Size_) { loop1Size = loop1Size_; }; | ||
| 809 | + __aicore__ inline void SetPadEn(bool padEn_) { padEn = padEn_ ? 1 : 0; }; | ||
| 810 | + __aicore__ inline void SetSplitEn(bool splitEn_) { splitEn = splitEn_ ? 1 : 0; }; | ||
| 811 | + | ||
| 812 | + __aicore__ inline uint64_t GetLoop3DstStride() const { return loop3DstStride; }; | ||
| 813 | + __aicore__ inline uint16_t GetLoop1Size() const { return loop1Size; }; | ||
| 814 | + __aicore__ inline bool GetPadEn() const { return padEn != 0; }; | ||
| 815 | + __aicore__ inline bool GetSplitEn() const { return splitEn != 0; }; | ||
| 816 | +}; | ||
| 817 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 818 | +struct FixpLoopenhanceParaBitModeConfig0 { | ||
| 819 | + uint64_t loop3DstStride : 32; | ||
| 820 | + uint64_t reserved0 : 8; | ||
| 821 | + uint64_t loop1Size : 16; | ||
| 822 | + uint64_t padEn : 1; | ||
| 823 | + uint64_t splitEn : 1; | ||
| 824 | + uint64_t reserved1 : 6; | ||
| 825 | + | ||
| 826 | + __aicore__ inline void Init(const FixpLoopenhanceParaParams& params) | ||
| 827 | + { | ||
| 828 | + loop3DstStride = params.loop3DstStride; | ||
| 829 | + loop1Size = params.loop1Size; | ||
| 830 | + padEn = params.padEn ? 1 : 0; | ||
| 831 | + splitEn = params.splitEn ? 1 : 0; | ||
| 832 | + } | ||
| 833 | + | ||
| 834 | + __aicore__ inline void SetLoop3DstStride(uint32_t loop3DstStride_) { loop3DstStride = loop3DstStride_; }; | ||
| 835 | + __aicore__ inline void SetLoop1Size(uint16_t loop1Size_) { loop1Size = loop1Size_; }; | ||
| 836 | + __aicore__ inline void SetPadEn(bool padEn_) { padEn = padEn_ ? 1 : 0; }; | ||
| 837 | + __aicore__ inline void SetSplitEn(bool splitEn_) { splitEn = splitEn_ ? 1 : 0; }; | ||
| 838 | + | ||
| 839 | + __aicore__ inline uint32_t GetLoop3DstStride() const { return loop3DstStride; }; | ||
| 840 | + __aicore__ inline uint16_t GetLoop1Size() const { return loop1Size; }; | ||
| 841 | + __aicore__ inline bool GetPadEn() const { return padEn != 0; }; | ||
| 842 | + __aicore__ inline bool GetSplitEn() const { return splitEn != 0; }; | ||
| 843 | +}; | ||
| 844 | +#endif | ||
| 845 | + | ||
| 846 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 847 | +struct FixpBitModeConfig0 { | ||
| 848 | + uint64_t loop2DstStride : 40; | ||
| 849 | + uint64_t loop3Size : 21; | ||
| 850 | + uint64_t transMode : 2; | ||
| 851 | + uint64_t reserved0 : 1; | ||
| 852 | + | ||
| 853 | + __aicore__ inline void Init(const FixpParams& params) | ||
| 854 | + { | ||
| 855 | + loop2DstStride = params.loop2DstStride; | ||
| 856 | + loop3Size = params.loop3Size; | ||
| 857 | + transMode = static_cast<uint8_t>(params.transMode); | ||
| 858 | + } | ||
| 859 | + | ||
| 860 | + __aicore__ inline void SetLoop2DstStride(uint64_t loop2DstStride_) { loop2DstStride = loop2DstStride_; }; | ||
| 861 | + __aicore__ inline void SetLoop3Size(uint32_t loop3Size_) { loop3Size = loop3Size_; }; | ||
| 862 | + __aicore__ inline void SetTransMode(uint8_t transMode_) { transMode = transMode_; }; | ||
| 863 | + | ||
| 864 | + __aicore__ inline uint64_t GetLoop2DstStride() const { return loop2DstStride; }; | ||
| 865 | + __aicore__ inline uint32_t GetLoop3Size() const { return loop3Size; }; | ||
| 866 | + __aicore__ inline uint8_t GetTransMode() const { return transMode; }; | ||
| 867 | +}; | ||
| 868 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 869 | +struct FixpBitModeConfig0 { | ||
| 870 | + uint64_t loop3Size : 16; | ||
| 871 | + uint64_t loop2Size : 16; | ||
| 872 | + uint64_t loop2DstStride : 32; | ||
| 873 | + | ||
| 874 | + __aicore__ inline void Init(const FixpParams& params) | ||
| 875 | + { | ||
| 876 | + loop3Size = params.loop3Size; | ||
| 877 | + loop2Size = params.loop2Size; | ||
| 878 | + loop2DstStride = params.loop2DstStride; | ||
| 879 | + } | ||
| 880 | + | ||
| 881 | + __aicore__ inline void SetLoop3Size(uint16_t loop3Size_) { loop3Size = loop3Size_; }; | ||
| 882 | + __aicore__ inline void SetLoop2Size(uint16_t loop2Size_) { loop2Size = loop2Size_; }; | ||
| 883 | + __aicore__ inline void SetLoop2DstStride(uint32_t loop2DstStride_) { loop2DstStride = loop2DstStride_; }; | ||
| 884 | + | ||
| 885 | + __aicore__ inline uint16_t GetLoop3Size() const { return loop3Size; }; | ||
| 886 | + __aicore__ inline uint16_t GetLoop2Size() const { return loop2Size; }; | ||
| 887 | + __aicore__ inline uint32_t GetLoop2DstStride() const { return loop2DstStride; }; | ||
| 888 | +}; | ||
| 889 | +#endif | ||
| 890 | + | ||
| 891 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 892 | +struct FixpBitModeConfig1 { | ||
| 893 | + uint64_t loop4DstStride : 40; | ||
| 894 | + uint64_t loop2Size : 16; | ||
| 895 | + uint64_t sid : 4; | ||
| 896 | + uint64_t reserved0 : 4; | ||
| 897 | + | ||
| 898 | + __aicore__ inline void Init(const FixpParams& params) | ||
| 899 | + { | ||
| 900 | + loop4DstStride = params.loop4DstStride; | ||
| 901 | + loop2Size = params.loop2Size; | ||
| 902 | + sid = params.sid; | ||
| 903 | + } | ||
| 904 | + | ||
| 905 | + __aicore__ inline void SetLoop4DstStride(uint64_t loop4DstStride_) { loop4DstStride = loop4DstStride_; }; | ||
| 906 | + __aicore__ inline void SetLoop2Size(uint16_t loop2Size_) { loop2Size = loop2Size_; }; | ||
| 907 | + __aicore__ inline void SetSid(uint8_t sid_) { sid = sid_; }; | ||
| 908 | + | ||
| 909 | + __aicore__ inline uint64_t GetLoop4DstStride() const { return loop4DstStride; }; | ||
| 910 | + __aicore__ inline uint16_t GetLoop2Size() const { return loop2Size; }; | ||
| 911 | + __aicore__ inline uint8_t GetSid() const { return sid; }; | ||
| 912 | +}; | ||
| 913 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 914 | +struct FixpBitModeConfig1 { | ||
| 915 | + uint64_t loop3SrcStride : 16; | ||
| 916 | + uint64_t loop2SrcStride : 16; | ||
| 917 | + uint64_t transMode : 2; | ||
| 918 | + uint64_t sid : 4; | ||
| 919 | + uint64_t reserved0 : 26; | ||
| 920 | + | ||
| 921 | + __aicore__ inline void Init(const FixpParams& params) | ||
| 922 | + { | ||
| 923 | + ASSERT( | ||
| 924 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 925 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 926 | + loop3SrcStride = params.loop3SrcStride; | ||
| 927 | + loop2SrcStride = params.loop2SrcStride | params.loop1SrcStride; | ||
| 928 | + transMode = static_cast<uint8_t>(params.transMode); | ||
| 929 | + sid = params.sid; | ||
| 930 | + } | ||
| 931 | + | ||
| 932 | + __aicore__ inline void SetLoop3SrcStride(uint16_t loop3SrcStride_) { loop3SrcStride = loop3SrcStride_; }; | ||
| 933 | + __aicore__ inline void SetLoop2SrcStride(uint16_t loop2SrcStride_) { loop2SrcStride = loop2SrcStride_; }; | ||
| 934 | + __aicore__ inline void SetTransMode(uint8_t transMode_) { transMode = transMode_; }; | ||
| 935 | + __aicore__ inline void SetSid(uint8_t sid_) { sid = sid_; }; | ||
| 936 | + | ||
| 937 | + __aicore__ inline uint16_t GetLoop3SrcStride() const { return loop3SrcStride; }; | ||
| 938 | + __aicore__ inline uint16_t GetLoop2SrcStride() const { return loop2SrcStride; }; | ||
| 939 | + __aicore__ inline uint8_t GetTransMode() const { return transMode; }; | ||
| 940 | + __aicore__ inline uint8_t GetSid() const { return sid; }; | ||
| 941 | +}; | ||
| 942 | +#endif | ||
| 706 | } // namespace AscendC | 943 | } // namespace AscendC |
| 707 | 944 | ||
| 708 | #endif // __NPU_ARCH__ | 945 | #endif // __NPU_ARCH__ |
| @@ -157,6 +157,25 @@ __aicore__ inline void SetConvPaddingCal(const ConvPaddingParams<T>& params) | |||
| 157 | 157 | ||
| 158 | __aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigBitModeParams& params) { set_m_fpc(params.GetConfig0()); } | 158 | __aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigBitModeParams& params) { set_m_fpc(params.GetConfig0()); } |
| 159 | 159 | ||
| 160 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 161 | +__aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigParams& params) | ||
| 162 | +{ | ||
| 163 | + constexpr uint8_t POS_RELU_PRE_ADDR = 0; | ||
| 164 | + constexpr uint8_t POS_QUANT_PRE_ADDR = 8; | ||
| 165 | + constexpr uint8_t POS_QUANT_POST_ADDR = 24; | ||
| 166 | + constexpr uint8_t POS_ANTIQ_PARA_ADDR = 32; | ||
| 167 | + constexpr uint8_t POS_FIXED_SHIFT_VAL = 40; | ||
| 168 | + | ||
| 169 | + uint64_t fpc = 0; | ||
| 170 | + fpc |= (uint64_t)(params.preReluAddr) << POS_RELU_PRE_ADDR; | ||
| 171 | + fpc |= (uint64_t)(params.preQuantAddr) << POS_QUANT_PRE_ADDR; | ||
| 172 | + fpc |= (uint64_t)(params.postQuantAddr) << POS_QUANT_POST_ADDR; | ||
| 173 | + fpc |= (uint64_t)(params.antiquantAddr) << POS_ANTIQ_PARA_ADDR; | ||
| 174 | + fpc |= (uint64_t)(params.shiftValue) << POS_FIXED_SHIFT_VAL; | ||
| 175 | + | ||
| 176 | + set_m_fpc(fpc); | ||
| 177 | +} | ||
| 178 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 160 | __aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigParams& params) | 179 | __aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigParams& params) |
| 161 | { | 180 | { |
| 162 | constexpr uint8_t POS_RELU_PRE_ADDR = 0; | 181 | constexpr uint8_t POS_RELU_PRE_ADDR = 0; |
| @@ -176,6 +195,7 @@ __aicore__ inline void SetFixPipeConfigCal(const FixPipeConfigParams& params) | |||
| 176 | 195 | ||
| 177 | set_m_fpc(fpc); | 196 | set_m_fpc(fpc); |
| 178 | } | 197 | } |
| 198 | +#endif | ||
| 179 | 199 | ||
| 180 | __aicore__ inline void SetFixPipeReluAlphaCal(const FixPipeReluAlphaBitModeParams& params) | 200 | __aicore__ inline void SetFixPipeReluAlphaCal(const FixPipeReluAlphaBitModeParams& params) |
| 181 | { | 201 | { |
| @@ -579,6 +599,218 @@ __aicore__ inline void PostProcCal(__cbuf__ DstT* dst, __cbuf__ SrcT* src, const | |||
| 579 | 599 | ||
| 580 | postproc((__cbuf__ void*)dst, src, config0); | 600 | postproc((__cbuf__ void*)dst, src, config0); |
| 581 | } | 601 | } |
| 602 | + | ||
| 603 | +__aicore__ inline void SetFixpNzParaCal(const FixpNzParaBitModeParams& params) | ||
| 604 | +{ | ||
| 605 | + set_fixp_nz_para(params.GetConfig0()); | ||
| 606 | +} | ||
| 607 | + | ||
| 608 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 609 | +__aicore__ inline void SetFixpNzParaCal(const FixpNzParaParams& params) | ||
| 610 | +{ | ||
| 611 | + ASSERT( | ||
| 612 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 613 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 614 | + constexpr uint8_t POS_LOOP4_SIZE = 0; | ||
| 615 | + constexpr uint8_t POS_LOOP2_SRC_STRIDE = 16; | ||
| 616 | + constexpr uint8_t POS_LOOP3_SRC_STRIDE = 32; | ||
| 617 | + constexpr uint8_t POS_LOOP4_SRC_STRIDE = 48; | ||
| 618 | + | ||
| 619 | + uint64_t config0 = 0; | ||
| 620 | + config0 |= (uint64_t)(params.loop4Size) << POS_LOOP4_SIZE; | ||
| 621 | + config0 |= (uint64_t)(params.loop2SrcStride | params.loop1SrcStride) << POS_LOOP2_SRC_STRIDE; | ||
| 622 | + config0 |= (uint64_t)(params.loop3SrcStride) << POS_LOOP3_SRC_STRIDE; | ||
| 623 | + config0 |= (uint64_t)(params.loop4SrcStride) << POS_LOOP4_SRC_STRIDE; | ||
| 624 | + | ||
| 625 | + set_fixp_nz_para(config0); | ||
| 626 | +} | ||
| 627 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 628 | +__aicore__ inline void SetFixpNzParaCal(const FixpNzParaParams& params) | ||
| 629 | +{ | ||
| 630 | + constexpr uint8_t POS_LOOP4_SIZE = 0; | ||
| 631 | + constexpr uint8_t POS_LOOP4_SRC_STRIDE = 16; | ||
| 632 | + constexpr uint8_t POS_LOOP4_DST_STRIDE = 32; | ||
| 633 | + | ||
| 634 | + uint64_t config0 = 0; | ||
| 635 | + config0 |= (uint64_t)(params.loop4Size) << POS_LOOP4_SIZE; | ||
| 636 | + config0 |= (uint64_t)(params.loop4SrcStride) << POS_LOOP4_SRC_STRIDE; | ||
| 637 | + config0 |= (uint64_t)(params.loop4DstStride) << POS_LOOP4_DST_STRIDE; | ||
| 638 | + | ||
| 639 | + set_fixp_nz_para(config0); | ||
| 640 | +} | ||
| 641 | +#endif | ||
| 642 | + | ||
| 643 | +__aicore__ inline void SetFixpLoopenhanceParaCal(const FixpLoopenhanceParaBitModeParams& params) | ||
| 644 | +{ | ||
| 645 | + set_loopenhance_para(params.GetConfig0()); | ||
| 646 | +} | ||
| 647 | + | ||
| 648 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 649 | +__aicore__ inline void SetFixpLoopenhanceParaCal(const FixpLoopenhanceParaParams& params) | ||
| 650 | +{ | ||
| 651 | + constexpr uint8_t POS_LOOP3_DST_STRIDE = 0; | ||
| 652 | + constexpr uint8_t POS_LOOP1_SIZE = 40; | ||
| 653 | + constexpr uint8_t POS_PAD_EN = 56; | ||
| 654 | + constexpr uint8_t POS_SPLIT_EN = 57; | ||
| 655 | + | ||
| 656 | + uint64_t config0 = 0; | ||
| 657 | + config0 |= (params.loop3DstStride & 0xFFFFFFFFFFULL) << POS_LOOP3_DST_STRIDE; | ||
| 658 | + config0 |= (uint64_t)(params.loop1Size) << POS_LOOP1_SIZE; | ||
| 659 | + config0 |= (uint64_t)(params.padEn ? 1 : 0) << POS_PAD_EN; | ||
| 660 | + config0 |= (uint64_t)(params.splitEn ? 1 : 0) << POS_SPLIT_EN; | ||
| 661 | + | ||
| 662 | + set_loopenhance_para(config0); | ||
| 663 | +} | ||
| 664 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 665 | +__aicore__ inline void SetFixpLoopenhanceParaCal(const FixpLoopenhanceParaParams& params) | ||
| 666 | +{ | ||
| 667 | + constexpr uint8_t POS_LOOP3_DST_STRIDE = 0; | ||
| 668 | + constexpr uint8_t POS_LOOP1_SIZE = 40; | ||
| 669 | + constexpr uint8_t POS_PAD_EN = 56; | ||
| 670 | + constexpr uint8_t POS_SPLIT_EN = 57; | ||
| 671 | + | ||
| 672 | + uint64_t config0 = 0; | ||
| 673 | + config0 |= (uint64_t)(params.loop3DstStride) << POS_LOOP3_DST_STRIDE; | ||
| 674 | + config0 |= (uint64_t)(params.loop1Size) << POS_LOOP1_SIZE; | ||
| 675 | + config0 |= (uint64_t)(params.padEn ? 1 : 0) << POS_PAD_EN; | ||
| 676 | + config0 |= (uint64_t)(params.splitEn ? 1 : 0) << POS_SPLIT_EN; | ||
| 677 | + | ||
| 678 | + set_loopenhance_para(config0); | ||
| 679 | +} | ||
| 680 | +#endif | ||
| 681 | + | ||
| 682 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 683 | +template <typename DstT, typename SrcT> | ||
| 684 | +__aicore__ inline void FixpipeL1ToL1Cal(__cbuf__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 685 | +{ | ||
| 686 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 687 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 688 | + fix_cbuf_to_cbuf( | ||
| 689 | + dst, src, params.loop2DstStride, params.loop3Size, params.transMode, params.loop4DstStride, params.loop2Size); | ||
| 690 | +} | ||
| 691 | + | ||
| 692 | +template <typename DstT, typename SrcT> | ||
| 693 | +__aicore__ inline void FixpipeL1ToL1Cal(__cbuf__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 694 | +{ | ||
| 695 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 696 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 697 | + fix_cbuf_to_cbuf( | ||
| 698 | + dst, src, params.GetLoop2DstStride(), params.GetLoop3Size(), params.GetTransMode(), params.GetLoop4DstStride(), | ||
| 699 | + params.GetLoop2Size()); | ||
| 700 | +} | ||
| 701 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 702 | +template <typename DstT, typename SrcT> | ||
| 703 | +__aicore__ inline void FixpipeL1ToL1Cal(__cbuf__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 704 | +{ | ||
| 705 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 706 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 707 | + ASSERT( | ||
| 708 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 709 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 710 | + fix_cbuf_to_cbuf( | ||
| 711 | + dst, src, params.loop3Size, params.loop2Size, params.loop2DstStride, params.loop3SrcStride, | ||
| 712 | + params.loop2SrcStride | params.loop1SrcStride, params.transMode); | ||
| 713 | +} | ||
| 714 | + | ||
| 715 | +template <typename DstT, typename SrcT> | ||
| 716 | +__aicore__ inline void FixpipeL1ToL1Cal(__cbuf__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 717 | +{ | ||
| 718 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 719 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 720 | + fix_cbuf_to_cbuf( | ||
| 721 | + dst, src, params.GetLoop3Size(), params.GetLoop2Size(), params.GetLoop2DstStride(), params.GetLoop3SrcStride(), | ||
| 722 | + params.GetLoop2SrcStride(), params.GetTransMode()); | ||
| 723 | +} | ||
| 724 | +#endif | ||
| 725 | + | ||
| 726 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 727 | +template <typename DstT, typename SrcT> | ||
| 728 | +__aicore__ inline void FixpipeL1ToUbCal(__ubuf__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 729 | +{ | ||
| 730 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 731 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 732 | + fix_cbuf_to_ubuf( | ||
| 733 | + dst, src, params.loop2DstStride, params.loop3Size, params.transMode, params.loop4DstStride, params.loop2Size); | ||
| 734 | +} | ||
| 735 | + | ||
| 736 | +template <typename DstT, typename SrcT> | ||
| 737 | +__aicore__ inline void FixpipeL1ToUbCal(__ubuf__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 738 | +{ | ||
| 739 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 740 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 741 | + fix_cbuf_to_ubuf( | ||
| 742 | + dst, src, params.GetLoop2DstStride(), params.GetLoop3Size(), params.GetTransMode(), params.GetLoop4DstStride(), | ||
| 743 | + params.GetLoop2Size()); | ||
| 744 | +} | ||
| 745 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 746 | +template <typename DstT, typename SrcT> | ||
| 747 | +__aicore__ inline void FixpipeL1ToUbCal(__ubuf__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 748 | +{ | ||
| 749 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 750 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 751 | + ASSERT( | ||
| 752 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 753 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 754 | + fix_cbuf_to_ubuf( | ||
| 755 | + dst, src, params.loop3Size, params.loop2Size, params.loop2DstStride, params.loop3SrcStride, | ||
| 756 | + params.loop2SrcStride | params.loop1SrcStride, params.transMode); | ||
| 757 | +} | ||
| 758 | + | ||
| 759 | +template <typename DstT, typename SrcT> | ||
| 760 | +__aicore__ inline void FixpipeL1ToUbCal(__ubuf__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 761 | +{ | ||
| 762 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 763 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 764 | + fix_cbuf_to_ubuf( | ||
| 765 | + dst, src, params.GetLoop3Size(), params.GetLoop2Size(), params.GetLoop2DstStride(), params.GetLoop3SrcStride(), | ||
| 766 | + params.GetLoop2SrcStride(), params.GetTransMode()); | ||
| 767 | +} | ||
| 768 | +#endif | ||
| 769 | + | ||
| 770 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 771 | +template <typename DstT, typename SrcT> | ||
| 772 | +__aicore__ inline void FixpipeL1ToGmCal(__gm__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 773 | +{ | ||
| 774 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 775 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 776 | + fix_cbuf_to_gm( | ||
| 777 | + dst, src, params.loop2DstStride, params.loop3Size, params.transMode, params.loop4DstStride, params.loop2Size, | ||
| 778 | + params.sid); | ||
| 779 | +} | ||
| 780 | + | ||
| 781 | +template <typename DstT, typename SrcT> | ||
| 782 | +__aicore__ inline void FixpipeL1ToGmCal(__gm__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 783 | +{ | ||
| 784 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 785 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 786 | + fix_cbuf_to_gm( | ||
| 787 | + dst, src, params.GetLoop2DstStride(), params.GetLoop3Size(), params.GetTransMode(), params.GetLoop4DstStride(), | ||
| 788 | + params.GetLoop2Size(), params.GetSid()); | ||
| 789 | +} | ||
| 790 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 791 | +template <typename DstT, typename SrcT> | ||
| 792 | +__aicore__ inline void FixpipeL1ToGmCal(__gm__ DstT* dst, __cbuf__ SrcT* src, const FixpParams& params) | ||
| 793 | +{ | ||
| 794 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 795 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 796 | + ASSERT( | ||
| 797 | + !(params.loop2SrcStride != 0 && params.loop1SrcStride != 0) && | ||
| 798 | + "loop2SrcStride and loop1SrcStride are mutually exclusive, only one can be non-zero"); | ||
| 799 | + fix_cbuf_to_gm( | ||
| 800 | + dst, src, params.loop3Size, params.loop2Size, params.loop2DstStride, params.loop3SrcStride, | ||
| 801 | + params.loop2SrcStride | params.loop1SrcStride, params.transMode, params.sid); | ||
| 802 | +} | ||
| 803 | + | ||
| 804 | +template <typename DstT, typename SrcT> | ||
| 805 | +__aicore__ inline void FixpipeL1ToGmCal(__gm__ DstT* dst, __cbuf__ SrcT* src, const FixpBitModeParams& params) | ||
| 806 | +{ | ||
| 807 | + static_assert(IsSameType<DstT, SrcT>::value, "src type and dst type must be same!"); | ||
| 808 | + static_assert(sizeof(DstT) == 1 || sizeof(DstT) == 2, "only b8 and b16 is valid!"); | ||
| 809 | + fix_cbuf_to_gm( | ||
| 810 | + dst, src, params.GetLoop3Size(), params.GetLoop2Size(), params.GetLoop2DstStride(), params.GetLoop3SrcStride(), | ||
| 811 | + params.GetLoop2SrcStride(), params.GetTransMode(), params.GetSid()); | ||
| 812 | +} | ||
| 813 | +#endif | ||
| 582 | } // namespace AscendC | 814 | } // namespace AscendC |
| 583 | 815 | ||
| 584 | #endif // __NPU_ARCH__ | 816 | #endif // __NPU_ARCH__ |
| @@ -255,6 +255,75 @@ __aicore__ inline void PostProcImpl(const LocalTensor<T>& dst, const LocalTensor | |||
| 255 | { | 255 | { |
| 256 | PostProcCal((__cbuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | 256 | PostProcCal((__cbuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); |
| 257 | } | 257 | } |
| 258 | + | ||
| 259 | +#if defined(__NPU_ARCH__) && \ | ||
| 260 | + (__NPU_ARCH__ == 5101 || __NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 261 | +__aicore__ inline void SetFixpNzParaImpl(const FixpNzParaBitModeParams& params) { SetFixpNzParaCal(params); } | ||
| 262 | + | ||
| 263 | +__aicore__ inline void SetFixpNzParaImpl(const FixpNzParaParams& params) { SetFixpNzParaCal(params); } | ||
| 264 | + | ||
| 265 | +__aicore__ inline void SetFixpLoopenhanceParaImpl(const FixpLoopenhanceParaBitModeParams& params) | ||
| 266 | +{ | ||
| 267 | + SetFixpLoopenhanceParaCal(params); | ||
| 268 | +} | ||
| 269 | + | ||
| 270 | +__aicore__ inline void SetFixpLoopenhanceParaImpl(const FixpLoopenhanceParaParams& params) | ||
| 271 | +{ | ||
| 272 | + SetFixpLoopenhanceParaCal(params); | ||
| 273 | +} | ||
| 274 | + | ||
| 275 | +template <typename T, typename U> | ||
| 276 | +__aicore__ inline void FixpipeImpl(const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params) | ||
| 277 | +{ | ||
| 278 | + const Hardware srcScope = GetPhyType((TPosition)src.GetPosition()); | ||
| 279 | + ASSERT(srcScope == Hardware::L1 && "Fixpipe src must be L1 Buffer"); | ||
| 280 | + const Hardware dstScope = GetPhyType((TPosition)dst.GetPosition()); | ||
| 281 | + if (dstScope == Hardware::L1) { | ||
| 282 | + FixpipeL1ToL1Cal((__cbuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 283 | + } else if (dstScope == Hardware::UB) { | ||
| 284 | + FixpipeL1ToUbCal((__ubuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 285 | + } else { | ||
| 286 | + ASSERT(false && "Fixpipe dst only supports L1 Buffer or UB"); | ||
| 287 | + } | ||
| 288 | +} | ||
| 289 | + | ||
| 290 | +template <typename T, typename U> | ||
| 291 | +__aicore__ inline void FixpipeImpl( | ||
| 292 | + const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params) | ||
| 293 | +{ | ||
| 294 | + const Hardware srcScope = GetPhyType((TPosition)src.GetPosition()); | ||
| 295 | + ASSERT(srcScope == Hardware::L1 && "Fixpipe src must be L1 Buffer"); | ||
| 296 | + const Hardware dstScope = GetPhyType((TPosition)dst.GetPosition()); | ||
| 297 | + if (dstScope == Hardware::L1) { | ||
| 298 | + FixpipeL1ToL1Cal((__cbuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 299 | + } else if (dstScope == Hardware::UB) { | ||
| 300 | + FixpipeL1ToUbCal((__ubuf__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 301 | + } else { | ||
| 302 | + ASSERT(false && "Fixpipe dst only supports L1 Buffer or UB"); | ||
| 303 | + } | ||
| 304 | +} | ||
| 305 | + | ||
| 306 | +template <typename T, typename U> | ||
| 307 | +__aicore__ inline void FixpipeImpl(const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params) | ||
| 308 | +{ | ||
| 309 | + const Hardware srcScope = GetPhyType((TPosition)src.GetPosition()); | ||
| 310 | + ASSERT(srcScope == Hardware::L1 && "Fixpipe src must be L1 Buffer"); | ||
| 311 | + const Hardware dstScope = GetPhyType((TPosition)dst.GetPosition()); | ||
| 312 | + ASSERT(dstScope == Hardware::GM && "Fixpipe GlobalTensor dst must be GM"); | ||
| 313 | + FixpipeL1ToGmCal((__gm__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 314 | +} | ||
| 315 | + | ||
| 316 | +template <typename T, typename U> | ||
| 317 | +__aicore__ inline void FixpipeImpl( | ||
| 318 | + const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params) | ||
| 319 | +{ | ||
| 320 | + const Hardware srcScope = GetPhyType((TPosition)src.GetPosition()); | ||
| 321 | + ASSERT(srcScope == Hardware::L1 && "Fixpipe src must be L1 Buffer"); | ||
| 322 | + const Hardware dstScope = GetPhyType((TPosition)dst.GetPosition()); | ||
| 323 | + ASSERT(dstScope == Hardware::GM && "Fixpipe GlobalTensor dst must be GM"); | ||
| 324 | + FixpipeL1ToGmCal((__gm__ PrimT<T>*)dst.GetPhyAddr(), (__cbuf__ PrimT<U>*)src.GetPhyAddr(), params); | ||
| 325 | +} | ||
| 326 | +#endif // __NPU_ARCH__ 5101/5161/5165/5163 | ||
| 258 | } // namespace AscendC | 327 | } // namespace AscendC |
| 259 | 328 | ||
| 260 | #endif // __NPU_ARCH__ | 329 | #endif // __NPU_ARCH__ |
| @@ -228,6 +228,49 @@ __aicore__ inline uint64_t ConvPaddingBitModeParams<T>::GetConfig0() const | |||
| 228 | return config0; | 228 | return config0; |
| 229 | }; | 229 | }; |
| 230 | 230 | ||
| 231 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 232 | +__aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams() { config0 = 0; } | ||
| 233 | +__aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams(const FixPipeConfigParams& fixPipeConfigParams) | ||
| 234 | +{ | ||
| 235 | + config0BitMode.Init(fixPipeConfigParams); | ||
| 236 | +} | ||
| 237 | +__aicore__ inline void FixPipeConfigBitModeParams::SetPreReluAddr(uint8_t preReluAddr_) | ||
| 238 | +{ | ||
| 239 | + config0BitMode.SetPreReluAddr(preReluAddr_); | ||
| 240 | +} | ||
| 241 | +__aicore__ inline void FixPipeConfigBitModeParams::SetPreQuantAddr(uint8_t preQuantAddr_) | ||
| 242 | +{ | ||
| 243 | + config0BitMode.SetPreQuantAddr(preQuantAddr_); | ||
| 244 | +} | ||
| 245 | +__aicore__ inline void FixPipeConfigBitModeParams::SetPostQuantAddr(uint8_t postQuantAddr_) | ||
| 246 | +{ | ||
| 247 | + config0BitMode.SetPostQuantAddr(postQuantAddr_); | ||
| 248 | +} | ||
| 249 | +__aicore__ inline void FixPipeConfigBitModeParams::SetAntiquantAddr(uint8_t antiquantAddr_) | ||
| 250 | +{ | ||
| 251 | + config0BitMode.SetAntiquantAddr(antiquantAddr_); | ||
| 252 | +} | ||
| 253 | +__aicore__ inline void FixPipeConfigBitModeParams::SetShiftValue(uint8_t shiftValue_) | ||
| 254 | +{ | ||
| 255 | + config0BitMode.SetShiftValue(shiftValue_); | ||
| 256 | +} | ||
| 257 | +__aicore__ inline void FixPipeConfigBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 258 | +__aicore__ inline uint8_t FixPipeConfigBitModeParams::GetPreReluAddr() const { return config0BitMode.GetPreReluAddr(); } | ||
| 259 | +__aicore__ inline uint8_t FixPipeConfigBitModeParams::GetPreQuantAddr() const | ||
| 260 | +{ | ||
| 261 | + return config0BitMode.GetPreQuantAddr(); | ||
| 262 | +} | ||
| 263 | +__aicore__ inline uint8_t FixPipeConfigBitModeParams::GetPostQuantAddr() const | ||
| 264 | +{ | ||
| 265 | + return config0BitMode.GetPostQuantAddr(); | ||
| 266 | +} | ||
| 267 | +__aicore__ inline uint8_t FixPipeConfigBitModeParams::GetAntiquantAddr() const | ||
| 268 | +{ | ||
| 269 | + return config0BitMode.GetAntiquantAddr(); | ||
| 270 | +} | ||
| 271 | +__aicore__ inline uint8_t FixPipeConfigBitModeParams::GetShiftValue() const { return config0BitMode.GetShiftValue(); } | ||
| 272 | +__aicore__ inline uint64_t FixPipeConfigBitModeParams::GetConfig0() const { return config0; }; | ||
| 273 | +#else | ||
| 231 | __aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams() { config0 = 0; } | 274 | __aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams() { config0 = 0; } |
| 232 | __aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams(const FixPipeConfigParams& fixPipeConfigParams) | 275 | __aicore__ inline FixPipeConfigBitModeParams::FixPipeConfigBitModeParams(const FixPipeConfigParams& fixPipeConfigParams) |
| 233 | { | 276 | { |
| @@ -277,6 +320,7 @@ __aicore__ inline uint8_t FixPipeConfigBitModeParams::GetRestorationCtrl() const | |||
| 277 | return config0BitMode.GetRestorationCtrl(); | 320 | return config0BitMode.GetRestorationCtrl(); |
| 278 | } | 321 | } |
| 279 | __aicore__ inline uint64_t FixPipeConfigBitModeParams::GetConfig0() const { return config0; }; | 322 | __aicore__ inline uint64_t FixPipeConfigBitModeParams::GetConfig0() const { return config0; }; |
| 323 | +#endif | ||
| 280 | 324 | ||
| 281 | __aicore__ inline FixPipeReluAlphaBitModeParams::FixPipeReluAlphaBitModeParams() { config0 = 0; } | 325 | __aicore__ inline FixPipeReluAlphaBitModeParams::FixPipeReluAlphaBitModeParams() { config0 = 0; } |
| 282 | __aicore__ inline FixPipeReluAlphaBitModeParams::FixPipeReluAlphaBitModeParams( | 326 | __aicore__ inline FixPipeReluAlphaBitModeParams::FixPipeReluAlphaBitModeParams( |
| @@ -722,6 +766,216 @@ __aicore__ inline bool PostProcBitModeParams::GetDependEnable() const { return c | |||
| 722 | __aicore__ inline instr_id_t PostProcBitModeParams::GetInstrId() const { return config0BitMode.GetInstrId(); } | 766 | __aicore__ inline instr_id_t PostProcBitModeParams::GetInstrId() const { return config0BitMode.GetInstrId(); } |
| 723 | __aicore__ inline uint16_t PostProcBitModeParams::GetN() const { return config0BitMode.GetN(); } | 767 | __aicore__ inline uint16_t PostProcBitModeParams::GetN() const { return config0BitMode.GetN(); } |
| 724 | __aicore__ inline uint64_t PostProcBitModeParams::GetConfig0() const { return config0; }; | 768 | __aicore__ inline uint64_t PostProcBitModeParams::GetConfig0() const { return config0; }; |
| 769 | + | ||
| 770 | +#if defined(__NPU_ARCH__) && \ | ||
| 771 | + (__NPU_ARCH__ == 5101 || __NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 772 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 773 | +__aicore__ inline FixpNzParaBitModeParams::FixpNzParaBitModeParams() { config0 = 0; } | ||
| 774 | +__aicore__ inline FixpNzParaBitModeParams::FixpNzParaBitModeParams(const FixpNzParaParams& fixpNzParaParams) | ||
| 775 | +{ | ||
| 776 | + config0BitMode.Init(fixpNzParaParams); | ||
| 777 | +} | ||
| 778 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop4Size(uint16_t loop4Size_) | ||
| 779 | +{ | ||
| 780 | + config0BitMode.SetLoop4Size(loop4Size_); | ||
| 781 | +} | ||
| 782 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop2SrcStride(uint16_t loop2SrcStride_) | ||
| 783 | +{ | ||
| 784 | + config0BitMode.SetLoop2SrcStride(loop2SrcStride_); | ||
| 785 | +} | ||
| 786 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop3SrcStride(uint16_t loop3SrcStride_) | ||
| 787 | +{ | ||
| 788 | + config0BitMode.SetLoop3SrcStride(loop3SrcStride_); | ||
| 789 | +} | ||
| 790 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop4SrcStride(uint16_t loop4SrcStride_) | ||
| 791 | +{ | ||
| 792 | + config0BitMode.SetLoop4SrcStride(loop4SrcStride_); | ||
| 793 | +} | ||
| 794 | +__aicore__ inline void FixpNzParaBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 795 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop4Size() const { return config0BitMode.GetLoop4Size(); } | ||
| 796 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop2SrcStride() const | ||
| 797 | +{ | ||
| 798 | + return config0BitMode.GetLoop2SrcStride(); | ||
| 799 | +} | ||
| 800 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop3SrcStride() const | ||
| 801 | +{ | ||
| 802 | + return config0BitMode.GetLoop3SrcStride(); | ||
| 803 | +} | ||
| 804 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop4SrcStride() const | ||
| 805 | +{ | ||
| 806 | + return config0BitMode.GetLoop4SrcStride(); | ||
| 807 | +} | ||
| 808 | +__aicore__ inline uint64_t FixpNzParaBitModeParams::GetConfig0() const { return config0; }; | ||
| 809 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 810 | +__aicore__ inline FixpNzParaBitModeParams::FixpNzParaBitModeParams() { config0 = 0; } | ||
| 811 | +__aicore__ inline FixpNzParaBitModeParams::FixpNzParaBitModeParams(const FixpNzParaParams& fixpNzParaParams) | ||
| 812 | +{ | ||
| 813 | + config0BitMode.Init(fixpNzParaParams); | ||
| 814 | +} | ||
| 815 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop4Size(uint16_t loop4Size_) | ||
| 816 | +{ | ||
| 817 | + config0BitMode.SetLoop4Size(loop4Size_); | ||
| 818 | +} | ||
| 819 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop4SrcStride(uint16_t loop4SrcStride_) | ||
| 820 | +{ | ||
| 821 | + config0BitMode.SetLoop4SrcStride(loop4SrcStride_); | ||
| 822 | +} | ||
| 823 | +__aicore__ inline void FixpNzParaBitModeParams::SetLoop4DstStride(uint32_t loop4DstStride_) | ||
| 824 | +{ | ||
| 825 | + config0BitMode.SetLoop4DstStride(loop4DstStride_); | ||
| 826 | +} | ||
| 827 | +__aicore__ inline void FixpNzParaBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 828 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop4Size() const { return config0BitMode.GetLoop4Size(); } | ||
| 829 | +__aicore__ inline uint16_t FixpNzParaBitModeParams::GetLoop4SrcStride() const | ||
| 830 | +{ | ||
| 831 | + return config0BitMode.GetLoop4SrcStride(); | ||
| 832 | +} | ||
| 833 | +__aicore__ inline uint32_t FixpNzParaBitModeParams::GetLoop4DstStride() const | ||
| 834 | +{ | ||
| 835 | + return config0BitMode.GetLoop4DstStride(); | ||
| 836 | +} | ||
| 837 | +__aicore__ inline uint64_t FixpNzParaBitModeParams::GetConfig0() const { return config0; }; | ||
| 838 | +#endif | ||
| 839 | + | ||
| 840 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 841 | +__aicore__ inline FixpLoopenhanceParaBitModeParams::FixpLoopenhanceParaBitModeParams() { config0 = 0; } | ||
| 842 | +__aicore__ inline FixpLoopenhanceParaBitModeParams::FixpLoopenhanceParaBitModeParams( | ||
| 843 | + const FixpLoopenhanceParaParams& fixpLoopenhanceParaParams) | ||
| 844 | +{ | ||
| 845 | + config0BitMode.Init(fixpLoopenhanceParaParams); | ||
| 846 | +} | ||
| 847 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetLoop3DstStride(uint64_t loop3DstStride_) | ||
| 848 | +{ | ||
| 849 | + config0BitMode.SetLoop3DstStride(loop3DstStride_); | ||
| 850 | +} | ||
| 851 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetLoop1Size(uint16_t loop1Size_) | ||
| 852 | +{ | ||
| 853 | + config0BitMode.SetLoop1Size(loop1Size_); | ||
| 854 | +} | ||
| 855 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetPadEn(bool padEn_) { config0BitMode.SetPadEn(padEn_); } | ||
| 856 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetSplitEn(bool splitEn_) | ||
| 857 | +{ | ||
| 858 | + config0BitMode.SetSplitEn(splitEn_); | ||
| 859 | +} | ||
| 860 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 861 | +__aicore__ inline uint64_t FixpLoopenhanceParaBitModeParams::GetLoop3DstStride() const | ||
| 862 | +{ | ||
| 863 | + return config0BitMode.GetLoop3DstStride(); | ||
| 864 | +} | ||
| 865 | +__aicore__ inline uint16_t FixpLoopenhanceParaBitModeParams::GetLoop1Size() const | ||
| 866 | +{ | ||
| 867 | + return config0BitMode.GetLoop1Size(); | ||
| 868 | +} | ||
| 869 | +__aicore__ inline bool FixpLoopenhanceParaBitModeParams::GetPadEn() const { return config0BitMode.GetPadEn(); } | ||
| 870 | +__aicore__ inline bool FixpLoopenhanceParaBitModeParams::GetSplitEn() const { return config0BitMode.GetSplitEn(); } | ||
| 871 | +__aicore__ inline uint64_t FixpLoopenhanceParaBitModeParams::GetConfig0() const { return config0; }; | ||
| 872 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 873 | +__aicore__ inline FixpLoopenhanceParaBitModeParams::FixpLoopenhanceParaBitModeParams() { config0 = 0; } | ||
| 874 | +__aicore__ inline FixpLoopenhanceParaBitModeParams::FixpLoopenhanceParaBitModeParams( | ||
| 875 | + const FixpLoopenhanceParaParams& fixpLoopenhanceParaParams) | ||
| 876 | +{ | ||
| 877 | + config0BitMode.Init(fixpLoopenhanceParaParams); | ||
| 878 | +} | ||
| 879 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetLoop3DstStride(uint32_t loop3DstStride_) | ||
| 880 | +{ | ||
| 881 | + config0BitMode.SetLoop3DstStride(loop3DstStride_); | ||
| 882 | +} | ||
| 883 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetLoop1Size(uint16_t loop1Size_) | ||
| 884 | +{ | ||
| 885 | + config0BitMode.SetLoop1Size(loop1Size_); | ||
| 886 | +} | ||
| 887 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetPadEn(bool padEn_) { config0BitMode.SetPadEn(padEn_); } | ||
| 888 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetSplitEn(bool splitEn_) | ||
| 889 | +{ | ||
| 890 | + config0BitMode.SetSplitEn(splitEn_); | ||
| 891 | +} | ||
| 892 | +__aicore__ inline void FixpLoopenhanceParaBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 893 | +__aicore__ inline uint32_t FixpLoopenhanceParaBitModeParams::GetLoop3DstStride() const | ||
| 894 | +{ | ||
| 895 | + return config0BitMode.GetLoop3DstStride(); | ||
| 896 | +} | ||
| 897 | +__aicore__ inline uint16_t FixpLoopenhanceParaBitModeParams::GetLoop1Size() const | ||
| 898 | +{ | ||
| 899 | + return config0BitMode.GetLoop1Size(); | ||
| 900 | +} | ||
| 901 | +__aicore__ inline bool FixpLoopenhanceParaBitModeParams::GetPadEn() const { return config0BitMode.GetPadEn(); } | ||
| 902 | +__aicore__ inline bool FixpLoopenhanceParaBitModeParams::GetSplitEn() const { return config0BitMode.GetSplitEn(); } | ||
| 903 | +__aicore__ inline uint64_t FixpLoopenhanceParaBitModeParams::GetConfig0() const { return config0; }; | ||
| 904 | +#endif | ||
| 905 | + | ||
| 906 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 907 | +__aicore__ inline FixpBitModeParams::FixpBitModeParams() | ||
| 908 | +{ | ||
| 909 | + config0 = 0; | ||
| 910 | + config1 = 0; | ||
| 911 | +} | ||
| 912 | +__aicore__ inline FixpBitModeParams::FixpBitModeParams(const FixpParams& fixpipeParams) | ||
| 913 | +{ | ||
| 914 | + config0BitMode.Init(fixpipeParams); | ||
| 915 | + config1BitMode.Init(fixpipeParams); | ||
| 916 | +} | ||
| 917 | +__aicore__ inline void FixpBitModeParams::SetLoop2DstStride(uint64_t loop2DstStride_) | ||
| 918 | +{ | ||
| 919 | + config0BitMode.SetLoop2DstStride(loop2DstStride_); | ||
| 920 | +} | ||
| 921 | +__aicore__ inline void FixpBitModeParams::SetLoop3Size(uint32_t loop3Size_) { config0BitMode.SetLoop3Size(loop3Size_); } | ||
| 922 | +__aicore__ inline void FixpBitModeParams::SetTransMode(uint8_t transMode_) { config0BitMode.SetTransMode(transMode_); } | ||
| 923 | +__aicore__ inline void FixpBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 924 | +__aicore__ inline void FixpBitModeParams::SetLoop4DstStride(uint64_t loop4DstStride_) | ||
| 925 | +{ | ||
| 926 | + config1BitMode.SetLoop4DstStride(loop4DstStride_); | ||
| 927 | +} | ||
| 928 | +__aicore__ inline void FixpBitModeParams::SetLoop2Size(uint16_t loop2Size_) { config1BitMode.SetLoop2Size(loop2Size_); } | ||
| 929 | +__aicore__ inline void FixpBitModeParams::SetSid(uint8_t sid_) { config1BitMode.SetSid(sid_); } | ||
| 930 | +__aicore__ inline void FixpBitModeParams::SetConfig1(uint64_t config1_) { config1 = config1_; }; | ||
| 931 | +__aicore__ inline uint64_t FixpBitModeParams::GetLoop2DstStride() const { return config0BitMode.GetLoop2DstStride(); } | ||
| 932 | +__aicore__ inline uint32_t FixpBitModeParams::GetLoop3Size() const { return config0BitMode.GetLoop3Size(); } | ||
| 933 | +__aicore__ inline uint8_t FixpBitModeParams::GetTransMode() const { return config0BitMode.GetTransMode(); } | ||
| 934 | +__aicore__ inline uint64_t FixpBitModeParams::GetConfig0() const { return config0; }; | ||
| 935 | +__aicore__ inline uint64_t FixpBitModeParams::GetLoop4DstStride() const { return config1BitMode.GetLoop4DstStride(); } | ||
| 936 | +__aicore__ inline uint16_t FixpBitModeParams::GetLoop2Size() const { return config1BitMode.GetLoop2Size(); } | ||
| 937 | +__aicore__ inline uint8_t FixpBitModeParams::GetSid() const { return config1BitMode.GetSid(); } | ||
| 938 | +__aicore__ inline uint64_t FixpBitModeParams::GetConfig1() const { return config1; }; | ||
| 939 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 940 | +__aicore__ inline FixpBitModeParams::FixpBitModeParams() | ||
| 941 | +{ | ||
| 942 | + config0 = 0; | ||
| 943 | + config1 = 0; | ||
| 944 | +} | ||
| 945 | +__aicore__ inline FixpBitModeParams::FixpBitModeParams(const FixpParams& fixpipeParams) | ||
| 946 | +{ | ||
| 947 | + config0BitMode.Init(fixpipeParams); | ||
| 948 | + config1BitMode.Init(fixpipeParams); | ||
| 949 | +} | ||
| 950 | +__aicore__ inline void FixpBitModeParams::SetLoop3Size(uint16_t loop3Size_) { config0BitMode.SetLoop3Size(loop3Size_); } | ||
| 951 | +__aicore__ inline void FixpBitModeParams::SetLoop2Size(uint16_t loop2Size_) { config0BitMode.SetLoop2Size(loop2Size_); } | ||
| 952 | +__aicore__ inline void FixpBitModeParams::SetLoop2DstStride(uint32_t loop2DstStride_) | ||
| 953 | +{ | ||
| 954 | + config0BitMode.SetLoop2DstStride(loop2DstStride_); | ||
| 955 | +} | ||
| 956 | +__aicore__ inline void FixpBitModeParams::SetConfig0(uint64_t config0_) { config0 = config0_; }; | ||
| 957 | +__aicore__ inline void FixpBitModeParams::SetLoop3SrcStride(uint16_t loop3SrcStride_) | ||
| 958 | +{ | ||
| 959 | + config1BitMode.SetLoop3SrcStride(loop3SrcStride_); | ||
| 960 | +} | ||
| 961 | +__aicore__ inline void FixpBitModeParams::SetLoop2SrcStride(uint16_t loop2SrcStride_) | ||
| 962 | +{ | ||
| 963 | + config1BitMode.SetLoop2SrcStride(loop2SrcStride_); | ||
| 964 | +} | ||
| 965 | +__aicore__ inline void FixpBitModeParams::SetTransMode(uint8_t transMode_) { config1BitMode.SetTransMode(transMode_); } | ||
| 966 | +__aicore__ inline void FixpBitModeParams::SetSid(uint8_t sid_) { config1BitMode.SetSid(sid_); } | ||
| 967 | +__aicore__ inline void FixpBitModeParams::SetConfig1(uint64_t config1_) { config1 = config1_; }; | ||
| 968 | +__aicore__ inline uint16_t FixpBitModeParams::GetLoop3Size() const { return config0BitMode.GetLoop3Size(); } | ||
| 969 | +__aicore__ inline uint16_t FixpBitModeParams::GetLoop2Size() const { return config0BitMode.GetLoop2Size(); } | ||
| 970 | +__aicore__ inline uint32_t FixpBitModeParams::GetLoop2DstStride() const { return config0BitMode.GetLoop2DstStride(); } | ||
| 971 | +__aicore__ inline uint64_t FixpBitModeParams::GetConfig0() const { return config0; }; | ||
| 972 | +__aicore__ inline uint16_t FixpBitModeParams::GetLoop3SrcStride() const { return config1BitMode.GetLoop3SrcStride(); } | ||
| 973 | +__aicore__ inline uint16_t FixpBitModeParams::GetLoop2SrcStride() const { return config1BitMode.GetLoop2SrcStride(); } | ||
| 974 | +__aicore__ inline uint8_t FixpBitModeParams::GetTransMode() const { return config1BitMode.GetTransMode(); } | ||
| 975 | +__aicore__ inline uint8_t FixpBitModeParams::GetSid() const { return config1BitMode.GetSid(); } | ||
| 976 | +__aicore__ inline uint64_t FixpBitModeParams::GetConfig1() const { return config1; }; | ||
| 977 | +#endif | ||
| 978 | +#endif // __NPU_ARCH__ 5101/5161/5165/5163 | ||
| 725 | } // namespace AscendC | 979 | } // namespace AscendC |
| 726 | 980 | ||
| 727 | #endif // __NPU_ARCH__ | 981 | #endif // __NPU_ARCH__ |
| @@ -222,6 +222,47 @@ __aicore__ inline void PostProc(const LocalTensor<T>& dst, const LocalTensor<U>& | |||
| 222 | { | 222 | { |
| 223 | PostProcImpl(dst, src, params); | 223 | PostProcImpl(dst, src, params); |
| 224 | } | 224 | } |
| 225 | + | ||
| 226 | +#if defined(__NPU_ARCH__) && \ | ||
| 227 | + (__NPU_ARCH__ == 5101 || __NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 228 | +__aicore__ inline void SetFixpNzPara(const FixpNzParaBitModeParams& params) { SetFixpNzParaImpl(params); } | ||
| 229 | + | ||
| 230 | +__aicore__ inline void SetFixpNzPara(const FixpNzParaParams& params) { SetFixpNzParaImpl(params); } | ||
| 231 | + | ||
| 232 | +__aicore__ inline void SetFixpLoopenhancePara(const FixpLoopenhanceParaBitModeParams& params) | ||
| 233 | +{ | ||
| 234 | + SetFixpLoopenhanceParaImpl(params); | ||
| 235 | +} | ||
| 236 | + | ||
| 237 | +__aicore__ inline void SetFixpLoopenhancePara(const FixpLoopenhanceParaParams& params) | ||
| 238 | +{ | ||
| 239 | + SetFixpLoopenhanceParaImpl(params); | ||
| 240 | +} | ||
| 241 | + | ||
| 242 | +template <typename T, typename U> | ||
| 243 | +__aicore__ inline void Fixpipe(const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params) | ||
| 244 | +{ | ||
| 245 | + FixpipeImpl(dst, src, params); | ||
| 246 | +} | ||
| 247 | + | ||
| 248 | +template <typename T, typename U> | ||
| 249 | +__aicore__ inline void Fixpipe(const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params) | ||
| 250 | +{ | ||
| 251 | + FixpipeImpl(dst, src, params); | ||
| 252 | +} | ||
| 253 | + | ||
| 254 | +template <typename T, typename U> | ||
| 255 | +__aicore__ inline void Fixpipe(const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params) | ||
| 256 | +{ | ||
| 257 | + FixpipeImpl(dst, src, params); | ||
| 258 | +} | ||
| 259 | + | ||
| 260 | +template <typename T, typename U> | ||
| 261 | +__aicore__ inline void Fixpipe(const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params) | ||
| 262 | +{ | ||
| 263 | + FixpipeImpl(dst, src, params); | ||
| 264 | +} | ||
| 265 | +#endif // __NPU_ARCH__ 5101/5161/5165/5163 | ||
| 225 | } // namespace AscendC | 266 | } // namespace AscendC |
| 226 | 267 | ||
| 227 | #endif // __NPU_ARCH__ | 268 | #endif // __NPU_ARCH__ |
| @@ -175,6 +175,33 @@ private: | |||
| 175 | }; | 175 | }; |
| 176 | }; | 176 | }; |
| 177 | 177 | ||
| 178 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 179 | +class FixPipeConfigBitModeParams { | ||
| 180 | +public: | ||
| 181 | + __aicore__ inline FixPipeConfigBitModeParams(); | ||
| 182 | + __aicore__ inline FixPipeConfigBitModeParams(const FixPipeConfigParams& fixPipeConfigParams); | ||
| 183 | + | ||
| 184 | + __aicore__ inline void SetPreReluAddr(uint8_t preReluAddr_); | ||
| 185 | + __aicore__ inline void SetPreQuantAddr(uint8_t preQuantAddr_); | ||
| 186 | + __aicore__ inline void SetPostQuantAddr(uint8_t postQuantAddr_); | ||
| 187 | + __aicore__ inline void SetAntiquantAddr(uint8_t antiquantAddr_); | ||
| 188 | + __aicore__ inline void SetShiftValue(uint8_t shiftValue_); | ||
| 189 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 190 | + | ||
| 191 | + __aicore__ inline uint8_t GetPreReluAddr() const; | ||
| 192 | + __aicore__ inline uint8_t GetPreQuantAddr() const; | ||
| 193 | + __aicore__ inline uint8_t GetPostQuantAddr() const; | ||
| 194 | + __aicore__ inline uint8_t GetAntiquantAddr() const; | ||
| 195 | + __aicore__ inline uint8_t GetShiftValue() const; | ||
| 196 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 197 | + | ||
| 198 | +private: | ||
| 199 | + union { | ||
| 200 | + uint64_t config0; | ||
| 201 | + struct FixPipeConfigBitModeConfig0 config0BitMode; | ||
| 202 | + }; | ||
| 203 | +}; | ||
| 204 | +#else | ||
| 178 | class FixPipeConfigBitModeParams { | 205 | class FixPipeConfigBitModeParams { |
| 179 | public: | 206 | public: |
| 180 | __aicore__ inline FixPipeConfigBitModeParams(); | 207 | __aicore__ inline FixPipeConfigBitModeParams(); |
| @@ -202,6 +229,7 @@ private: | |||
| 202 | struct FixPipeConfigBitModeConfig0 config0BitMode; | 229 | struct FixPipeConfigBitModeConfig0 config0BitMode; |
| 203 | }; | 230 | }; |
| 204 | }; | 231 | }; |
| 232 | +#endif | ||
| 205 | 233 | ||
| 206 | class FixPipeReluAlphaBitModeParams { | 234 | class FixPipeReluAlphaBitModeParams { |
| 207 | public: | 235 | public: |
| @@ -500,6 +528,183 @@ private: | |||
| 500 | struct PostProcBitModeConfig0 config0BitMode; | 528 | struct PostProcBitModeConfig0 config0BitMode; |
| 501 | }; | 529 | }; |
| 502 | }; | 530 | }; |
| 531 | + | ||
| 532 | +#if defined(__NPU_ARCH__) && \ | ||
| 533 | + (__NPU_ARCH__ == 5101 || __NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 534 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 535 | +class FixpNzParaBitModeParams { | ||
| 536 | +public: | ||
| 537 | + __aicore__ inline FixpNzParaBitModeParams(); | ||
| 538 | + __aicore__ inline FixpNzParaBitModeParams(const FixpNzParaParams& fixpNzParaParams); | ||
| 539 | + | ||
| 540 | + __aicore__ inline void SetLoop4Size(uint16_t loop4Size_); | ||
| 541 | + __aicore__ inline void SetLoop2SrcStride(uint16_t loop2SrcStride_); | ||
| 542 | + __aicore__ inline void SetLoop3SrcStride(uint16_t loop3SrcStride_); | ||
| 543 | + __aicore__ inline void SetLoop4SrcStride(uint16_t loop4SrcStride_); | ||
| 544 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 545 | + | ||
| 546 | + __aicore__ inline uint16_t GetLoop4Size() const; | ||
| 547 | + __aicore__ inline uint16_t GetLoop2SrcStride() const; | ||
| 548 | + __aicore__ inline uint16_t GetLoop3SrcStride() const; | ||
| 549 | + __aicore__ inline uint16_t GetLoop4SrcStride() const; | ||
| 550 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 551 | + | ||
| 552 | +private: | ||
| 553 | + union { | ||
| 554 | + uint64_t config0; | ||
| 555 | + struct FixpNzParaBitModeConfig0 config0BitMode; | ||
| 556 | + }; | ||
| 557 | +}; | ||
| 558 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 559 | +class FixpNzParaBitModeParams { | ||
| 560 | +public: | ||
| 561 | + __aicore__ inline FixpNzParaBitModeParams(); | ||
| 562 | + __aicore__ inline FixpNzParaBitModeParams(const FixpNzParaParams& fixpNzParaParams); | ||
| 563 | + | ||
| 564 | + __aicore__ inline void SetLoop4Size(uint16_t loop4Size_); | ||
| 565 | + __aicore__ inline void SetLoop4SrcStride(uint16_t loop4SrcStride_); | ||
| 566 | + __aicore__ inline void SetLoop4DstStride(uint32_t loop4DstStride_); | ||
| 567 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 568 | + | ||
| 569 | + __aicore__ inline uint16_t GetLoop4Size() const; | ||
| 570 | + __aicore__ inline uint16_t GetLoop4SrcStride() const; | ||
| 571 | + __aicore__ inline uint32_t GetLoop4DstStride() const; | ||
| 572 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 573 | + | ||
| 574 | +private: | ||
| 575 | + union { | ||
| 576 | + uint64_t config0; | ||
| 577 | + struct FixpNzParaBitModeConfig0 config0BitMode; | ||
| 578 | + }; | ||
| 579 | +}; | ||
| 580 | +#endif | ||
| 581 | + | ||
| 582 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 583 | +class FixpLoopenhanceParaBitModeParams { | ||
| 584 | +public: | ||
| 585 | + __aicore__ inline FixpLoopenhanceParaBitModeParams(); | ||
| 586 | + __aicore__ inline FixpLoopenhanceParaBitModeParams(const FixpLoopenhanceParaParams& fixpLoopenhanceParaParams); | ||
| 587 | + | ||
| 588 | + __aicore__ inline void SetLoop3DstStride(uint64_t loop3DstStride_); | ||
| 589 | + __aicore__ inline void SetLoop1Size(uint16_t loop1Size_); | ||
| 590 | + __aicore__ inline void SetPadEn(bool padEn_); | ||
| 591 | + __aicore__ inline void SetSplitEn(bool splitEn_); | ||
| 592 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 593 | + | ||
| 594 | + __aicore__ inline uint64_t GetLoop3DstStride() const; | ||
| 595 | + __aicore__ inline uint16_t GetLoop1Size() const; | ||
| 596 | + __aicore__ inline bool GetPadEn() const; | ||
| 597 | + __aicore__ inline bool GetSplitEn() const; | ||
| 598 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 599 | + | ||
| 600 | +private: | ||
| 601 | + union { | ||
| 602 | + uint64_t config0; | ||
| 603 | + struct FixpLoopenhanceParaBitModeConfig0 config0BitMode; | ||
| 604 | + }; | ||
| 605 | +}; | ||
| 606 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 607 | +class FixpLoopenhanceParaBitModeParams { | ||
| 608 | +public: | ||
| 609 | + __aicore__ inline FixpLoopenhanceParaBitModeParams(); | ||
| 610 | + __aicore__ inline FixpLoopenhanceParaBitModeParams(const FixpLoopenhanceParaParams& fixpLoopenhanceParaParams); | ||
| 611 | + | ||
| 612 | + __aicore__ inline void SetLoop3DstStride(uint32_t loop3DstStride_); | ||
| 613 | + __aicore__ inline void SetLoop1Size(uint16_t loop1Size_); | ||
| 614 | + __aicore__ inline void SetPadEn(bool padEn_); | ||
| 615 | + __aicore__ inline void SetSplitEn(bool splitEn_); | ||
| 616 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 617 | + | ||
| 618 | + __aicore__ inline uint32_t GetLoop3DstStride() const; | ||
| 619 | + __aicore__ inline uint16_t GetLoop1Size() const; | ||
| 620 | + __aicore__ inline bool GetPadEn() const; | ||
| 621 | + __aicore__ inline bool GetSplitEn() const; | ||
| 622 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 623 | + | ||
| 624 | +private: | ||
| 625 | + union { | ||
| 626 | + uint64_t config0; | ||
| 627 | + struct FixpLoopenhanceParaBitModeConfig0 config0BitMode; | ||
| 628 | + }; | ||
| 629 | +}; | ||
| 630 | +#endif | ||
| 631 | + | ||
| 632 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 633 | +class FixpBitModeParams { | ||
| 634 | +public: | ||
| 635 | + __aicore__ inline FixpBitModeParams(); | ||
| 636 | + __aicore__ inline FixpBitModeParams(const FixpParams& fixpipeParams); | ||
| 637 | + | ||
| 638 | + __aicore__ inline void SetLoop2DstStride(uint64_t loop2DstStride_); | ||
| 639 | + __aicore__ inline void SetLoop3Size(uint32_t loop3Size_); | ||
| 640 | + __aicore__ inline void SetTransMode(uint8_t transMode_); | ||
| 641 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 642 | + | ||
| 643 | + __aicore__ inline void SetLoop4DstStride(uint64_t loop4DstStride_); | ||
| 644 | + __aicore__ inline void SetLoop2Size(uint16_t loop2Size_); | ||
| 645 | + __aicore__ inline void SetSid(uint8_t sid_); | ||
| 646 | + __aicore__ inline void SetConfig1(uint64_t config1_); | ||
| 647 | + | ||
| 648 | + __aicore__ inline uint64_t GetLoop2DstStride() const; | ||
| 649 | + __aicore__ inline uint32_t GetLoop3Size() const; | ||
| 650 | + __aicore__ inline uint8_t GetTransMode() const; | ||
| 651 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 652 | + | ||
| 653 | + __aicore__ inline uint64_t GetLoop4DstStride() const; | ||
| 654 | + __aicore__ inline uint16_t GetLoop2Size() const; | ||
| 655 | + __aicore__ inline uint8_t GetSid() const; | ||
| 656 | + __aicore__ inline uint64_t GetConfig1() const; | ||
| 657 | + | ||
| 658 | +private: | ||
| 659 | + union { | ||
| 660 | + uint64_t config0; | ||
| 661 | + struct FixpBitModeConfig0 config0BitMode; | ||
| 662 | + }; | ||
| 663 | + union { | ||
| 664 | + uint64_t config1; | ||
| 665 | + struct FixpBitModeConfig1 config1BitMode; | ||
| 666 | + }; | ||
| 667 | +}; | ||
| 668 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 669 | +class FixpBitModeParams { | ||
| 670 | +public: | ||
| 671 | + __aicore__ inline FixpBitModeParams(); | ||
| 672 | + __aicore__ inline FixpBitModeParams(const FixpParams& fixpipeParams); | ||
| 673 | + | ||
| 674 | + __aicore__ inline void SetLoop3Size(uint16_t loop3Size_); | ||
| 675 | + __aicore__ inline void SetLoop2Size(uint16_t loop2Size_); | ||
| 676 | + __aicore__ inline void SetLoop2DstStride(uint32_t loop2DstStride_); | ||
| 677 | + __aicore__ inline void SetConfig0(uint64_t config0_); | ||
| 678 | + | ||
| 679 | + __aicore__ inline void SetLoop3SrcStride(uint16_t loop3SrcStride_); | ||
| 680 | + __aicore__ inline void SetLoop2SrcStride(uint16_t loop2SrcStride_); | ||
| 681 | + __aicore__ inline void SetTransMode(uint8_t transMode_); | ||
| 682 | + __aicore__ inline void SetSid(uint8_t sid_); | ||
| 683 | + __aicore__ inline void SetConfig1(uint64_t config1_); | ||
| 684 | + | ||
| 685 | + __aicore__ inline uint16_t GetLoop3Size() const; | ||
| 686 | + __aicore__ inline uint16_t GetLoop2Size() const; | ||
| 687 | + __aicore__ inline uint32_t GetLoop2DstStride() const; | ||
| 688 | + __aicore__ inline uint64_t GetConfig0() const; | ||
| 689 | + | ||
| 690 | + __aicore__ inline uint16_t GetLoop3SrcStride() const; | ||
| 691 | + __aicore__ inline uint16_t GetLoop2SrcStride() const; | ||
| 692 | + __aicore__ inline uint8_t GetTransMode() const; | ||
| 693 | + __aicore__ inline uint8_t GetSid() const; | ||
| 694 | + __aicore__ inline uint64_t GetConfig1() const; | ||
| 695 | + | ||
| 696 | +private: | ||
| 697 | + union { | ||
| 698 | + uint64_t config0; | ||
| 699 | + struct FixpBitModeConfig0 config0BitMode; | ||
| 700 | + }; | ||
| 701 | + union { | ||
| 702 | + uint64_t config1; | ||
| 703 | + struct FixpBitModeConfig1 config1BitMode; | ||
| 704 | + }; | ||
| 705 | +}; | ||
| 706 | +#endif | ||
| 707 | +#endif // __NPU_ARCH__ 5101/5161/5165/5163 | ||
| 503 | } // namespace AscendC | 708 | } // namespace AscendC |
| 504 | 709 | ||
| 505 | #if defined(__NPU_ARCH__) | 710 | #if defined(__NPU_ARCH__) |
| @@ -269,6 +269,42 @@ __aicore__ inline void PostProc( | |||
| 269 | const LocalTensor<T>& dst, const LocalTensor<U>& src, const PostProcBitModeParams& params); | 269 | const LocalTensor<T>& dst, const LocalTensor<U>& src, const PostProcBitModeParams& params); |
| 270 | template <typename T, typename U> | 270 | template <typename T, typename U> |
| 271 | __aicore__ inline void PostProc(const LocalTensor<T>& dst, const LocalTensor<U>& src, const PostProcParams& params); | 271 | __aicore__ inline void PostProc(const LocalTensor<T>& dst, const LocalTensor<U>& src, const PostProcParams& params); |
| 272 | + | ||
| 273 | +#if defined(__NPU_ARCH__) && \ | ||
| 274 | + (__NPU_ARCH__ == 5101 || __NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 275 | +/* | ||
| 276 | + * @ingroup MacroCube | ||
| 277 | + * @brief setting the register | ||
| 278 | + * @param [in] params register | ||
| 279 | + */ | ||
| 280 | +__aicore__ inline void SetFixpNzPara(const FixpNzParaBitModeParams& params); | ||
| 281 | +__aicore__ inline void SetFixpNzPara(const FixpNzParaParams& params); | ||
| 282 | + | ||
| 283 | +/* | ||
| 284 | + * @ingroup MacroCube | ||
| 285 | + * @brief setting the register | ||
| 286 | + * @param [in] params register | ||
| 287 | + */ | ||
| 288 | +__aicore__ inline void SetFixpLoopenhancePara(const FixpLoopenhanceParaBitModeParams& params); | ||
| 289 | +__aicore__ inline void SetFixpLoopenhancePara(const FixpLoopenhanceParaParams& params); | ||
| 290 | + | ||
| 291 | +/* | ||
| 292 | + * @ingroup MacroCube | ||
| 293 | + * @brief performs fixpipe copy | ||
| 294 | + * @param [out] dst | ||
| 295 | + * @param [in] src | ||
| 296 | + * @param [in] Params | ||
| 297 | + */ | ||
| 298 | +template <typename T, typename U> | ||
| 299 | +__aicore__ inline void Fixpipe(const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params); | ||
| 300 | +template <typename T, typename U> | ||
| 301 | +__aicore__ inline void Fixpipe(const LocalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params); | ||
| 302 | +template <typename T, typename U> | ||
| 303 | +__aicore__ inline void Fixpipe(const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpParams& params); | ||
| 304 | +template <typename T, typename U> | ||
| 305 | +__aicore__ inline void Fixpipe(const GlobalTensor<T>& dst, const LocalTensor<U>& src, const FixpBitModeParams& params); | ||
| 306 | +#endif // __NPU_ARCH__ 5101/5161/5165/5163 | ||
| 307 | + | ||
| 272 | } // namespace AscendC | 308 | } // namespace AscendC |
| 273 | 309 | ||
| 274 | #if defined(__NPU_ARCH__) | 310 | #if defined(__NPU_ARCH__) |
| @@ -378,6 +378,151 @@ struct PostProcParams { | |||
| 378 | instr_id_t instrId = instr_id_t::ID_0; | 378 | instr_id_t instrId = instr_id_t::ID_0; |
| 379 | uint16_t n = 0; | 379 | uint16_t n = 0; |
| 380 | }; | 380 | }; |
| 381 | + | ||
| 382 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 383 | +struct FixpNzParaParamsArch5101 { | ||
| 384 | + __aicore__ FixpNzParaParamsArch5101() {} | ||
| 385 | + | ||
| 386 | + __aicore__ FixpNzParaParamsArch5101( | ||
| 387 | + const uint16_t loop4SizeIn, const uint16_t loop2SrcStrideIn, const uint16_t loop1SrcStrideIn, | ||
| 388 | + const uint16_t loop3SrcStrideIn, const uint16_t loop4SrcStrideIn) | ||
| 389 | + { | ||
| 390 | + loop4Size = loop4SizeIn; | ||
| 391 | + loop2SrcStride = loop2SrcStrideIn; | ||
| 392 | + loop1SrcStride = loop1SrcStrideIn; | ||
| 393 | + loop3SrcStride = loop3SrcStrideIn; | ||
| 394 | + loop4SrcStride = loop4SrcStrideIn; | ||
| 395 | + } | ||
| 396 | + | ||
| 397 | + uint16_t loop4Size = 0; | ||
| 398 | + uint16_t loop2SrcStride = 0; | ||
| 399 | + uint16_t loop1SrcStride = 0; | ||
| 400 | + uint16_t loop3SrcStride = 0; | ||
| 401 | + uint16_t loop4SrcStride = 0; | ||
| 402 | +}; | ||
| 403 | +using FixpNzParaParams = FixpNzParaParamsArch5101; | ||
| 404 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 405 | +struct FixpNzParaParamsArch5161 { | ||
| 406 | + __aicore__ FixpNzParaParamsArch5161() {} | ||
| 407 | + | ||
| 408 | + __aicore__ FixpNzParaParamsArch5161( | ||
| 409 | + const uint16_t loop4SizeIn, const uint16_t loop4SrcStrideIn, const uint32_t loop4DstStrideIn) | ||
| 410 | + { | ||
| 411 | + loop4Size = loop4SizeIn; | ||
| 412 | + loop4SrcStride = loop4SrcStrideIn; | ||
| 413 | + loop4DstStride = loop4DstStrideIn; | ||
| 414 | + } | ||
| 415 | + | ||
| 416 | + uint16_t loop4Size = 0; | ||
| 417 | + uint16_t loop4SrcStride = 0; | ||
| 418 | + uint32_t loop4DstStride = 0; | ||
| 419 | +}; | ||
| 420 | +using FixpNzParaParams = FixpNzParaParamsArch5161; | ||
| 421 | +#else | ||
| 422 | +struct FixpNzParaParams { | ||
| 423 | + __aicore__ FixpNzParaParams() {} | ||
| 424 | +}; | ||
| 425 | +#endif | ||
| 426 | + | ||
| 427 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 428 | +struct FixpLoopenhanceParaParamsArch5101 { | ||
| 429 | + __aicore__ FixpLoopenhanceParaParamsArch5101() {} | ||
| 430 | + | ||
| 431 | + __aicore__ FixpLoopenhanceParaParamsArch5101( | ||
| 432 | + const uint64_t loop3DstStrideIn, const uint16_t loop1SizeIn, const bool padEnIn, const bool splitEnIn) | ||
| 433 | + : loop3DstStride(loop3DstStrideIn), loop1Size(loop1SizeIn), padEn(padEnIn), splitEn(splitEnIn) | ||
| 434 | + {} | ||
| 435 | + | ||
| 436 | + uint64_t loop3DstStride = 0; | ||
| 437 | + uint16_t loop1Size = 0; | ||
| 438 | + bool padEn = 0; | ||
| 439 | + bool splitEn = 0; | ||
| 440 | +}; | ||
| 441 | +using FixpLoopenhanceParaParams = FixpLoopenhanceParaParamsArch5101; | ||
| 442 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 443 | +struct FixpLoopenhanceParaParamsArch5161 { | ||
| 444 | + __aicore__ FixpLoopenhanceParaParamsArch5161() {} | ||
| 445 | + | ||
| 446 | + __aicore__ FixpLoopenhanceParaParamsArch5161( | ||
| 447 | + const uint32_t loop3DstStrideIn, const uint16_t loop1SizeIn, const bool padEnIn, const bool splitEnIn) | ||
| 448 | + : loop3DstStride(loop3DstStrideIn), loop1Size(loop1SizeIn), padEn(padEnIn), splitEn(splitEnIn) | ||
| 449 | + {} | ||
| 450 | + | ||
| 451 | + uint32_t loop3DstStride = 0; | ||
| 452 | + uint16_t loop1Size = 0; | ||
| 453 | + bool padEn = 0; | ||
| 454 | + bool splitEn = 0; | ||
| 455 | +}; | ||
| 456 | +using FixpLoopenhanceParaParams = FixpLoopenhanceParaParamsArch5161; | ||
| 457 | +#else | ||
| 458 | +struct FixpLoopenhanceParaParams { | ||
| 459 | + __aicore__ FixpLoopenhanceParaParams() {} | ||
| 460 | +}; | ||
| 461 | +#endif | ||
| 462 | + | ||
| 463 | +#if defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5101) | ||
| 464 | +struct FixpParamsArch5101 { | ||
| 465 | + __aicore__ FixpParamsArch5101() {} | ||
| 466 | + | ||
| 467 | + __aicore__ FixpParamsArch5101( | ||
| 468 | + const uint64_t loop2DstStrideIn, const uint32_t loop3SizeIn, | ||
| 469 | + const fixp_trans_mode_t transModeIn = fixp_trans_mode_t::NORMAL_DMA, const uint64_t loop4DstStrideIn = 0, | ||
| 470 | + const uint16_t loop2SizeIn = 0, const uint8_t sidIn = 0) | ||
| 471 | + { | ||
| 472 | + loop2DstStride = loop2DstStrideIn; | ||
| 473 | + loop3Size = loop3SizeIn; | ||
| 474 | + transMode = transModeIn; | ||
| 475 | + | ||
| 476 | + loop4DstStride = loop4DstStrideIn; | ||
| 477 | + loop2Size = loop2SizeIn; | ||
| 478 | + sid = sidIn; | ||
| 479 | + } | ||
| 480 | + | ||
| 481 | + uint64_t loop2DstStride = 0; | ||
| 482 | + uint32_t loop3Size = 0; | ||
| 483 | + fixp_trans_mode_t transMode = fixp_trans_mode_t::NORMAL_DMA; | ||
| 484 | + | ||
| 485 | + uint64_t loop4DstStride = 0; | ||
| 486 | + uint16_t loop2Size = 0; | ||
| 487 | + uint8_t sid = 0; | ||
| 488 | +}; | ||
| 489 | +using FixpParams = FixpParamsArch5101; | ||
| 490 | +#elif defined(__NPU_ARCH__) && (__NPU_ARCH__ == 5161 || __NPU_ARCH__ == 5165 || __NPU_ARCH__ == 5163) | ||
| 491 | +struct FixpParamsArch5161 { | ||
| 492 | + __aicore__ FixpParamsArch5161() {} | ||
| 493 | + | ||
| 494 | + __aicore__ FixpParamsArch5161( | ||
| 495 | + const uint16_t loop3SizeIn, const uint16_t loop2SizeIn, const uint32_t loop2DstStrideIn, | ||
| 496 | + const uint16_t loop3SrcStrideIn, const uint16_t loop2SrcStrideIn, const uint16_t loop1SrcStrideIn, | ||
| 497 | + const fixp_trans_mode_t transModeIn = fixp_trans_mode_t::NORMAL_DMA, const uint8_t sidIn = 0) | ||
| 498 | + { | ||
| 499 | + loop3Size = loop3SizeIn; | ||
| 500 | + loop2Size = loop2SizeIn; | ||
| 501 | + loop2DstStride = loop2DstStrideIn; | ||
| 502 | + | ||
| 503 | + loop3SrcStride = loop3SrcStrideIn; | ||
| 504 | + loop2SrcStride = loop2SrcStrideIn; | ||
| 505 | + loop1SrcStride = loop1SrcStrideIn; | ||
| 506 | + transMode = transModeIn; | ||
| 507 | + sid = sidIn; | ||
| 508 | + } | ||
| 509 | + | ||
| 510 | + uint16_t loop3Size = 0; | ||
| 511 | + uint16_t loop2Size = 0; | ||
| 512 | + uint32_t loop2DstStride = 0; | ||
| 513 | + | ||
| 514 | + uint16_t loop3SrcStride = 0; | ||
| 515 | + uint16_t loop2SrcStride = 0; | ||
| 516 | + uint16_t loop1SrcStride = 0; | ||
| 517 | + fixp_trans_mode_t transMode = fixp_trans_mode_t::NORMAL_DMA; | ||
| 518 | + uint8_t sid = 0; | ||
| 519 | +}; | ||
| 520 | +using FixpParams = FixpParamsArch5161; | ||
| 521 | +#else | ||
| 522 | +struct FixpParams { | ||
| 523 | + __aicore__ FixpParams() {} | ||
| 524 | +}; | ||
| 525 | +#endif | ||
| 381 | } // namespace AscendC | 526 | } // namespace AscendC |
| 382 | 527 | ||
| 383 | #endif // __NPU_ARCH__ | 528 | #endif // __NPU_ARCH__ |