1 /* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Library
3 * Title: arm_dot_prod_q7.c
4 * Description: Q7 dot product
5 *
6 * $Date: 23 April 2021
7 * $Revision: V1.9.0
8 *
9 * Target Processor: Cortex-M and Cortex-A cores
10 * -------------------------------------------------------------------- */
11 /*
12 * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13 *
14 * SPDX-License-Identifier: Apache-2.0
15 *
16 * Licensed under the Apache License, Version 2.0 (the License); you may
17 * not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29 #include "dsp/basic_math_functions.h"
30
31 /**
32 @ingroup groupMath
33 */
34
35 /**
36 @addtogroup BasicDotProd
37 @{
38 */
39
40 /**
41 @brief Dot product of Q7 vectors.
42 @param[in] pSrcA points to the first input vector
43 @param[in] pSrcB points to the second input vector
44 @param[in] blockSize number of samples in each vector
45 @param[out] result output result returned here
46 @return none
47
48 @par Scaling and Overflow Behavior
49 The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these
50 results are added to an accumulator in 18.14 format.
51 Nonsaturating additions are used and there is no danger of wrap around as long as
52 the vectors are less than 2^18 elements long.
53 The return result is in 18.14 format.
54 */
55
56 #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
57
58 #include "arm_helium_utils.h"
59
arm_dot_prod_q7(const q7_t * pSrcA,const q7_t * pSrcB,uint32_t blockSize,q31_t * result)60 void arm_dot_prod_q7(
61 const q7_t * pSrcA,
62 const q7_t * pSrcB,
63 uint32_t blockSize,
64 q31_t * result)
65 {
66 uint32_t blkCnt; /* loop counters */
67 q7x16_t vecA;
68 q7x16_t vecB;
69 q31_t sum = 0;
70
71 /* Compute 16 outputs at a time */
72 blkCnt = blockSize >> 4;
73 while (blkCnt > 0U)
74 {
75 /*
76 * C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1]
77 * Calculate dot product and then store the result in a temporary buffer.
78 */
79 vecA = vld1q(pSrcA);
80 vecB = vld1q(pSrcB);
81 sum = vmladavaq(sum, vecA, vecB);
82 /*
83 * Decrement the blockSize loop counter
84 */
85 blkCnt--;
86 /*
87 * advance vector source and destination pointers
88 */
89 pSrcA += 16;
90 pSrcB += 16;
91 }
92 /*
93 * tail
94 */
95 blkCnt = blockSize & 0xF;
96 if (blkCnt > 0U)
97 {
98 mve_pred16_t p0 = vctp8q(blkCnt);
99 vecA = vld1q(pSrcA);
100 vecB = vld1q(pSrcB);
101 sum = vmladavaq_p(sum, vecA, vecB, p0);
102 }
103
104 *result = sum;
105 }
106 #else
arm_dot_prod_q7(const q7_t * pSrcA,const q7_t * pSrcB,uint32_t blockSize,q31_t * result)107 void arm_dot_prod_q7(
108 const q7_t * pSrcA,
109 const q7_t * pSrcB,
110 uint32_t blockSize,
111 q31_t * result)
112 {
113 uint32_t blkCnt; /* Loop counter */
114 q31_t sum = 0; /* Temporary return variable */
115
116 #if defined (ARM_MATH_LOOPUNROLL)
117
118 #if defined (ARM_MATH_DSP)
119 q31_t input1, input2; /* Temporary variables */
120 q31_t inA1, inA2, inB1, inB2; /* Temporary variables */
121 #endif
122
123 /* Loop unrolling: Compute 4 outputs at a time */
124 blkCnt = blockSize >> 2U;
125
126 while (blkCnt > 0U)
127 {
128 /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
129
130 #if defined (ARM_MATH_DSP)
131 /* read 4 samples at a time from sourceA */
132 input1 = read_q7x4_ia ((q7_t **) &pSrcA);
133 /* read 4 samples at a time from sourceB */
134 input2 = read_q7x4_ia ((q7_t **) &pSrcB);
135
136 /* extract two q7_t samples to q15_t samples */
137 inA1 = __SXTB16(__ROR(input1, 8));
138 /* extract reminaing two samples */
139 inA2 = __SXTB16(input1);
140 /* extract two q7_t samples to q15_t samples */
141 inB1 = __SXTB16(__ROR(input2, 8));
142 /* extract reminaing two samples */
143 inB2 = __SXTB16(input2);
144
145 /* multiply and accumulate two samples at a time */
146 sum = __SMLAD(inA1, inB1, sum);
147 sum = __SMLAD(inA2, inB2, sum);
148 #else
149 sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
150 sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
151 sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
152 sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
153 #endif
154
155 /* Decrement loop counter */
156 blkCnt--;
157 }
158
159 /* Loop unrolling: Compute remaining outputs */
160 blkCnt = blockSize % 0x4U;
161
162 #else
163
164 /* Initialize blkCnt with number of samples */
165 blkCnt = blockSize;
166
167 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
168
169 while (blkCnt > 0U)
170 {
171 /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
172
173 /* Calculate dot product and store result in a temporary buffer. */
174 //#if defined (ARM_MATH_DSP)
175 // sum = __SMLAD(*pSrcA++, *pSrcB++, sum);
176 //#else
177 sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
178 //#endif
179
180 /* Decrement loop counter */
181 blkCnt--;
182 }
183
184 /* Store result in destination buffer in 18.14 format */
185 *result = sum;
186 }
187 #endif /* defined(ARM_MATH_MVEI) */
188
189 /**
190 @} end of BasicDotProd group
191 */
192