| // Copyright 2022 Google LLC |
| // |
| // This source code is licensed under the BSD-style license found in the |
| // LICENSE file in the root directory of this source tree. |
| |
| #include <xnnpack/assembly.h> |
| |
| .syntax unified |
| |
| // void xnn_qc8_dwconv_minmax_fp32_ukernel_up16x3__aarch32_neonv8_mla8_cortex_a35( |
| // size_t channels, r0, r11 |
| // size_t output_width, r1 |
| // const int8_t** input, r2 |
| // const void* weights, r3 |
| // int8_t* output, r10, [sp, 88] |
| // size_t input_stride, r6, [sp, 92] |
| // size_t output_increment, r12, [sp, 96] |
| // size_t input_offset, (r11),[sp, 100] |
| // const int8_t* zero, r4, [sp, 104] |
| // const union xnn_qs8_minmax_params params r5, [sp, 108] |
| |
| // d8-d15, r4-r11,r14(lr) need to be preserved if used. r13(sp),r15(pc) are reserved. |
| |
| // Register usage |
| // A0 r5 q4 |
| // A1 r6 q5 |
| // A2 r8 q6 |
| |
| // B r7/r3/lr q12 q13 q14 |
| |
| // C0 r10 q12 q13 q14 q15 |
| |
| // Prod q0 q1 q2 q3 |
| |
| // params structure is 4 bytes |
| // struct { |
| // int16_t output_zero_point; d20[0] q10 |
| // int8_t output_min; d20[2] q9 |
| // int8_t output_max; d20[3] q11 |
| // } xnn_qs8_minmax_params.neonv8; |
| |
| // r7 temp B |
| // r9 B post increment 80 or 16 |
| |
| // unused q7 |
| |
| BEGIN_FUNCTION xnn_qc8_dwconv_minmax_fp32_ukernel_up16x3__aarch32_neonv8_mla8_cortex_a35 |
| // 88 bytes of stack |
| PUSH {r4, r5, r6, r7, r8, r9, r10, r11, lr} // 40 |
| SUB sp, sp, 4 |
| VPUSH {d8, d9, d10, d11, d12, d13} // 48 |
| |
| LDR r5, [sp, 108] // params |
| LDR r10, [sp, 88] // output |
| LDR r12, [sp, 96] // output_increment |
| LDR r4, [sp, 104] // zero |
| |
| VLD1.32 {d20[]}, [r5] // QC8 params |
| VDUP.8 q9 , d20[2] // output_min |
| VDUP.8 q11, d20[3] // output_max |
| VDUP.16 q10, d20[0] // output_zero_point |
| |
| .p2align 3 |
| 0: |
| LDR r11, [sp, 100] // input_offset |
| LDMIB r2, {r5, r6} // i0, i1 |
| LDR r8, [r2] // i2 |
| CMP r5, r4 // i0 == zero? |
| ADDNE r5, r5, r11 // i0 += input_offset |
| CMP r6, r4 // i1 == zero? |
| ADDNE r6, r6, r11 // i1 += input_offset |
| CMP r8, r4 // i2 == zero? |
| ADDNE r8, r8, r11 // i2 += input_offset |
| |
| MOV lr, r3 |
| MOV r9, 80 |
| |
| // Is there at least 16 channels for main loop? |
| SUBS r11, r0, 16 |
| BLO 2f |
| |
| // Main loop - 16 channels |
| // lr weights. r3 reset |
| // r0/r11 loop counter. |
| // r5 i0 |
| // r6 i1 |
| // r8 i2 |
| // q12 q13 q14 q15 accumulators |
| |
| .p2align 3 |
| 1: |
| ADD r7, lr, 64 // skip over bias to get weights |
| VLD1.8 {q4}, [r8]! // i2 |
| VLD1.8 {q12}, [r7]! // w0 |
| VLD1.8 {q5}, [r5]! // i0 |
| VLD1.8 {q13}, [r7]! // w1 |
| VLD1.8 {q6}, [r6]! // i1 |
| VLD1.8 {q14}, [r7] // w2 |
| |
| VMULL.S8 q1, d8, d24 // i2 * w0 |
| VMULL.S8 q2, d9, d25 |
| VMLAL.S8 q1, d10, d26 // i0 * w1 |
| VMLAL.S8 q2, d11, d27 |
| VMULL.S8 q0, d12, d28 // i1 * w2 |
| VLD1.8 {q12, q13}, [lr]! // load bias |
| VMULL.S8 q3, d13, d29 |
| VLD1.8 {q14, q15}, [lr], r9 |
| |
| VADDW.S16 q12, q12, d0 |
| VADDW.S16 q13, q13, d1 |
| VADDW.S16 q14, q14, d4 |
| VADDW.S16 q15, q15, d5 |
| VADDW.S16 q12, q12, d2 |
| VADDW.S16 q13, q13, d3 |
| VADDW.S16 q14, q14, d6 |
| VLD1.32 {q0, q1}, [lr]! // quant per channel scale values |
| VADDW.S16 q15, q15, d7 |
| VLD1.32 {q2, q3}, [lr]! |
| |
| // QC8 FP32 quantization |
| |
| VCVT.F32.S32 q12, q12 |
| VCVT.F32.S32 q13, q13 |
| VCVT.F32.S32 q14, q14 |
| VCVT.F32.S32 q15, q15 |
| |
| VMUL.F32 q12, q0, q12 |
| VMUL.F32 q13, q1, q13 |
| VMUL.F32 q14, q2, q14 |
| VMUL.F32 q15, q3, q15 |
| |
| VCVTN.S32.F32 q12, q12 |
| VCVTN.S32.F32 q13, q13 |
| VCVTN.S32.F32 q14, q14 |
| VCVTN.S32.F32 q15, q15 |
| |
| VQMOVN.S32 d24, q12 |
| VQMOVN.S32 d25, q13 |
| VQMOVN.S32 d28, q14 |
| VQMOVN.S32 d29, q15 |
| |
| VQADD.S16 q12, q12, q10 |
| VQADD.S16 q14, q14, q10 |
| VQMOVN.S16 d24, q12 |
| VQMOVN.S16 d25, q14 |
| VMIN.S8 q12, q12, q11 |
| VMAX.S8 q12, q12, q9 |
| SUBS r11, r11, 16 |
| VST1.8 {q12}, [r10]! |
| BHS 1b |
| |
| 2: |
| // Is there a remainder channels? 1-15 |
| ANDS r11, r11, 15 |
| BNE 4f |
| |
| 3: |
| LDR r6, [sp, 92] // input_stride |
| SUBS r1, r1, 1 // output_width |
| ADD r10, r10, r12 // output += output_increment |
| ADD r2, r2, r6 // input += input_stride |
| BNE 0b |
| |
| VPOP {d8, d9, d10, d11, d12, d13} |
| ADD sp, sp, 4 // pad |
| POP {r4, r5, r6, r7, r8, r9, r10, r11, pc} |
| |
| // Small Remainder - 1-8 channels |
| 4: |
| CMP r11, 9 // handle 9 or more |
| ADD r7, lr, 64 // skip over bias to get weights |
| BHS 5f |
| |
| MOV r9, 16 |
| |
| VLD1.8 {d8}, [r8] // i2 |
| VLD1.8 {d24}, [r7], r9 // w0 |
| VLD1.8 {d10}, [r5] // i0 |
| VLD1.8 {d26}, [r7], r9 // w1 |
| VLD1.8 {d12}, [r6] // i1 |
| VLD1.8 {d28}, [r7] // w2 |
| |
| VMULL.S8 q1, d8, d24 // i2 * w0 |
| VMLAL.S8 q1, d10, d26 // i0 * w1 |
| VMULL.S8 q0, d12, d28 // i1 * w2 |
| VLD1.8 {q12, q13}, [lr] // load bias |
| ADD lr, lr, 112 |
| |
| VADDW.S16 q12, q12, d0 |
| VADDW.S16 q13, q13, d1 |
| VADDW.S16 q12, q12, d2 |
| VADDW.S16 q13, q13, d3 |
| VLD1.32 {q0, q1}, [lr] // quant per channel scale values |
| |
| // QC8 FP32 quantization |
| |
| VCVT.F32.S32 q12, q12 |
| VCVT.F32.S32 q13, q13 |
| |
| VMUL.F32 q12, q0, q12 |
| VMUL.F32 q13, q1, q13 |
| |
| VCVTN.S32.F32 q12, q12 |
| VCVTN.S32.F32 q13, q13 |
| |
| VQMOVN.S32 d24, q12 |
| VQMOVN.S32 d25, q13 |
| |
| VQADD.S16 q12, q12, q10 |
| VQMOVN.S16 d24, q12 |
| VMIN.S8 d24, d24, d22 |
| VMAX.S8 d24, d24, d18 |
| |
| // Store 8 |
| TST r11, 8 |
| BEQ 6f |
| VST1.8 {d24}, [r10]! |
| B 3b |
| |
| .p2align 3 |
| // Large Remainder - 9-15 channels |
| // Process 16 same as main loop, but conditional store |
| |
| 5: |
| VLD1.8 {q4}, [r8]! // i2 |
| VLD1.8 {q12}, [r7]! // w0 |
| VLD1.8 {q5}, [r5]! // i0 |
| VLD1.8 {q13}, [r7]! // w1 |
| VLD1.8 {q6}, [r6]! // i1 |
| VLD1.8 {q14}, [r7] // w2 |
| |
| VMULL.S8 q1, d8, d24 // i2 * w0 |
| VMULL.S8 q2, d9, d25 |
| VMLAL.S8 q1, d10, d26 // i0 * w1 |
| VMLAL.S8 q2, d11, d27 |
| VMULL.S8 q0, d12, d28 // i1 * w2 |
| VLD1.8 {q12, q13}, [lr]! // load bias |
| VMULL.S8 q3, d13, d29 |
| VLD1.8 {q14, q15}, [lr], r9 |
| |
| VADDW.S16 q12, q12, d0 |
| VADDW.S16 q13, q13, d1 |
| VADDW.S16 q14, q14, d4 |
| VADDW.S16 q15, q15, d5 |
| VADDW.S16 q12, q12, d2 |
| VADDW.S16 q13, q13, d3 |
| VADDW.S16 q14, q14, d6 |
| VLD1.32 {q0, q1}, [lr]! // quant per channel scale values |
| VADDW.S16 q15, q15, d7 |
| VLD1.32 {q2, q3}, [lr] |
| |
| // QC8 FP32 quantization |
| |
| VCVT.F32.S32 q12, q12 |
| VCVT.F32.S32 q13, q13 |
| VCVT.F32.S32 q14, q14 |
| VCVT.F32.S32 q15, q15 |
| |
| VMUL.F32 q12, q0, q12 |
| VMUL.F32 q13, q1, q13 |
| VMUL.F32 q14, q2, q14 |
| VMUL.F32 q15, q3, q15 |
| |
| VCVTN.S32.F32 q12, q12 |
| VCVTN.S32.F32 q13, q13 |
| VCVTN.S32.F32 q14, q14 |
| VCVTN.S32.F32 q15, q15 |
| |
| VQMOVN.S32 d24, q12 |
| VQMOVN.S32 d25, q13 |
| VQMOVN.S32 d28, q14 |
| VQMOVN.S32 d29, q15 |
| |
| VQADD.S16 q12, q12, q10 |
| VQADD.S16 q14, q14, q10 |
| VQMOVN.S16 d24, q12 |
| VQMOVN.S16 d25, q14 |
| VMIN.S8 q12, q12, q11 |
| VMAX.S8 q12, q12, q9 |
| |
| // Store 8 |
| VST1.8 {d24}, [r10]! |
| VMOV d24, d25 |
| |
| // Store 4 |
| 6: |
| TST r11, 4 |
| BEQ 7f |
| VST1.32 {d24[0]}, [r10]! |
| VEXT.8 d24, d24, d24, 4 |
| |
| // Store 2 |
| 7: |
| TST r11, 2 |
| BEQ 8f |
| VST1.16 {d24[0]}, [r10]! |
| VEXT.8 d24, d24, d24, 2 |
| |
| // Store 1 |
| 8: |
| TST r11, 1 |
| BEQ 3b |
| VST1.8 {d24[0]}, [r10]! |
| B 3b |
| |
| |
| END_FUNCTION xnn_qc8_dwconv_minmax_fp32_ukernel_up16x3__aarch32_neonv8_mla8_cortex_a35 |
| #ifdef __ELF__ |
| .section ".note.GNU-stack","",%progbits |
| #endif |
