void test_vmlaf32 (void)
{
float32x2_t out_float32x2_t;
float32x2_t arg0_float32x2_t;
float32x2_t arg1_float32x2_t;
float32x2_t arg2_float32x2_t;
out_float32x2_t = vmla_f32 (arg0_float32x2_t, arg1_float32x2_t, arg2_float32x2_t);
}
static inline void mix_block_into_with_gain(cbox_sample_t **outputs, int oofs, float *src_leftright, float gain)
{
float *dst_left = outputs[oofs];
float *dst_right = outputs[oofs + 1];
float32x2_t gain2 = {gain, gain};
for (size_t i = 0; i < CBOX_BLOCK_SIZE; i += 2)
{
float32x2_t lr1 = vld1_f32(&src_leftright[2 * i]);
float32x2_t lr2 = vld1_f32(&src_leftright[2 * i + 2]);
float32x2x2_t lr12 = vtrn_f32(lr1, lr2);
float32x2_t dl1 = vld1_f32(&dst_left[i]);
float32x2_t dr1 = vld1_f32(&dst_right[i]);
float32x2_t l1 = vmla_f32(dl1, lr12.val[0], gain2);
vst1_f32(&dst_left[i], l1);
float32x2_t r1 = vmla_f32(dr1, lr12.val[1], gain2);
vst1_f32(&dst_right[i], r1);
}
}
void dot_loop(const GLfloat *verts, const GLfloat *params, GLfloat *out, GLint count) {
#ifdef __ARM_NEON__
float32x2_t acc;
float32x2x3_t vert;
float32x2x3_t param = vld3_f32((const float32_t *)params);
for (; count != 0; count -= 1) {
vert = vld3_f32((const float32_t *)verts);
acc = vmul_f32(vert.val[0], param.val[0]);
acc = vmla_f32(acc, vert.val[1], param.val[1]);
acc = vmla_f32(acc, vert.val[2], param.val[2]);
vst1_f32((float32_t *)out, acc);
out += 2;
verts += 3;
}
#else
for (int i = 0; i < count; i++) {
out[0] = dot(verts, params);
out += 2;
verts += 3;
}
#endif
}
/**
* @brief vector_mul_matrix.
*
* @param src1[in] the input vector(1*k)
* src2[in] the input matrix(k*n)
* dst[out] the output vector(1*n)
* kn[in] DIM_K & DIM_N
*
* @return void
*/
void neon_vectormulmatrix_float(float * dst,
const float * src1,
const float * src2,
int *kn)
{
int j ,l;
int k = kn[0];
int n = kn[1];
const float * src1_p = src1;
const float * src2_p = src2;
float * dst_p = dst;
for (j = 0; j <= n - 4; j += 4) {
float32x2_t d16 = {0};
float32x2_t d17 = {0};
float32x2_t d18 = {0};
float32x2_t d19 = {0};
float32x2_t d20;
float32x2_t d21;
float32x4_t q0;
src1_p = src1;
src2_p = src2 + j * k;
for (l = 0; l <= k - 4; l += 4) {
// Matrix A
float32x4_t q8 = vld1q_f32(src1_p);
float32x2_t d0 = vget_low_f32(q8);
float32x2_t d1 = vget_high_f32(q8);
// Matrix B
float32x4_t q12 = vld1q_f32(src2_p);
float32x4_t q13 = vld1q_f32(src2_p + k);
float32x4_t q14 = vld1q_f32(src2_p + k * 2);
float32x4_t q15 = vld1q_f32(src2_p + k * 3);
float32x2_t d8 = vget_low_f32(q12);
float32x2_t d9 = vget_high_f32(q12);
float32x2_t d10 = vget_low_f32(q13);
float32x2_t d11 = vget_high_f32(q13);
float32x2_t d12 = vget_low_f32(q14);
float32x2_t d13 = vget_high_f32(q14);
float32x2_t d14 = vget_low_f32(q15);
float32x2_t d15 = vget_high_f32(q15);
d16 = vmla_f32(d16, d0, d8);
d17 = vmla_f32(d17, d0, d10);
d18 = vmla_f32(d18, d0, d12);
d19 = vmla_f32(d19, d0, d14);
d16 = vmla_f32(d16, d1, d9);
d17 = vmla_f32(d17, d1, d11);
d18 = vmla_f32(d18, d1, d13);
d19 = vmla_f32(d19, d1, d15);
src1_p += 4;
src2_p += 4;
}// end for l
d16 = vpadd_f32(d16, d17);
d18 = vpadd_f32(d18, d19);
float sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
for(; l < k; l ++) {
float src1_d;
src1_d = *src1_p;
sum0 += src1_d * *src2_p;
sum1 += src1_d * *(src2_p + k);
sum2 += src1_d * *(src2_p + 2 * k);
sum3 += src1_d * *(src2_p + 3 * k);
src1_p++;
src2_p++;
}
d20 = vset_lane_f32(sum0, d20, 0);
d20 = vset_lane_f32(sum1, d20, 1);
d21 = vset_lane_f32(sum2, d21, 0);
d21 = vset_lane_f32(sum3, d21, 1);
q0 = vaddq_f32(vcombine_f32(d16, d18), vcombine_f32(d20, d21));
vst1q_f32(dst_p, q0);
dst_p += 4;
}// end for j
}
/**
* @brief Elem_t¿‡–Õæÿ’ÛA”ÎElem_t¿‡–Õæÿ’ÛBœ‡≥À.
*
* @param dst[out] ‰≥ˆæÿ’ÛC.
* src1[in] ‰»Îæÿ’ÛA.
* src2[in] ‰»Îæÿ’ÛB.
* mkn[in] æÿ’Ûµƒ∏˜∏ˆŒ¨ ˝.
*
* @return void
*/
void neon_matrixmul_4x4float(Elem_t * dst,
Elem_t * src1,
Elem_t * src2,
int *mkn)
{
int m = mkn[0];
int k = mkn[1];
int n = mkn[2];
for (int i = 0; i < m; i += 4)
{
for (int j = 0; j < n; j += 4)
{
float32x2_t d16 = {0};
float32x2_t d17 = {0};
float32x2_t d18 = {0};
float32x2_t d19 = {0};
float32x2_t d20 = {0};
float32x2_t d21 = {0};
float32x2_t d22 = {0};
float32x2_t d23 = {0};
float32x2_t d24 = {0};
float32x2_t d25 = {0};
float32x2_t d26 = {0};
float32x2_t d27 = {0};
float32x2_t d28 = {0};
float32x2_t d29 = {0};
float32x2_t d30 = {0};
float32x2_t d31 = {0};
for (int l = 0; l < k; l += 4)
{
// Matrix A
float32x4_t q8 = vld1q_f32(src1 );
float32x4_t q9 = vld1q_f32(src1 + k );
float32x4_t q10 = vld1q_f32(src1 + k*2);
float32x4_t q11 = vld1q_f32(src1 + k*3);
float32x2_t d0 = vget_low_f32(q8);
float32x2_t d1 = vget_high_f32(q8);
float32x2_t d2 = vget_low_f32(q9);
float32x2_t d3 = vget_high_f32(q9);
float32x2_t d4 = vget_low_f32(q10);
float32x2_t d5 = vget_high_f32(q10);
float32x2_t d6 = vget_low_f32(q11);
float32x2_t d7 = vget_high_f32(q11);
// Matrix B
float32x4_t q12 = vld1q_f32(src2 );
float32x4_t q13 = vld1q_f32(src2 + k );
float32x4_t q14 = vld1q_f32(src2 + k*2);
float32x4_t q15 = vld1q_f32(src2 + k*3);
float32x2_t d8 = vget_low_f32(q12);
float32x2_t d9 = vget_high_f32(q12);
float32x2_t d10 = vget_low_f32(q13);
float32x2_t d11 = vget_high_f32(q13);
float32x2_t d12 = vget_low_f32(q14);
float32x2_t d13 = vget_high_f32(q14);
float32x2_t d14 = vget_low_f32(q15);
float32x2_t d15 = vget_high_f32(q15);
d16 = vmla_f32(d16, d0, d8);
d17 = vmla_f32(d17, d0, d10);
d18 = vmla_f32(d18, d0, d12);
d19 = vmla_f32(d19, d0, d14);
d16 = vmla_f32(d16, d1, d9);
d17 = vmla_f32(d17, d1, d11);
d18 = vmla_f32(d18, d1, d13);
d19 = vmla_f32(d19, d1, d15);
d20 = vmla_f32(d20, d2, d8);
d21 = vmla_f32(d21, d2, d10);
d22 = vmla_f32(d22, d2, d12);
d23 = vmla_f32(d23, d2, d14);
d20 = vmla_f32(d20, d3, d9);
d21 = vmla_f32(d21, d3, d11);
d22 = vmla_f32(d22, d3, d13);
d23 = vmla_f32(d23, d3, d15);
d24 = vmla_f32(d24, d4, d8);
d25 = vmla_f32(d25, d4, d10);
d26 = vmla_f32(d26, d4, d12);
d27 = vmla_f32(d27, d4, d14);
d24 = vmla_f32(d24, d5, d9);
d25 = vmla_f32(d25, d5, d11);
d26 = vmla_f32(d26, d5, d13);
d27 = vmla_f32(d27, d5, d15);
d28 = vmla_f32(d28, d6, d8);
d29 = vmla_f32(d29, d6, d10);
d30 = vmla_f32(d30, d6, d12);
d31 = vmla_f32(d31, d6, d14);
d28 = vmla_f32(d28, d7, d9);
d29 = vmla_f32(d29, d7, d11);
d30 = vmla_f32(d30, d7, d13);
d31 = vmla_f32(d31, d7, d15);
src1 += 4;
src2 += 4;
}// end for l
d16 = vpadd_f32(d16, d17);
d18 = vpadd_f32(d18, d19);
d20 = vpadd_f32(d20, d21);
d22 = vpadd_f32(d22, d23);
d24 = vpadd_f32(d24, d25);
d26 = vpadd_f32(d26, d27);
d28 = vpadd_f32(d28, d29);
d30 = vpadd_f32(d30, d31);
vst1q_f32(dst , vcombine_f32(d16, d18));
vst1q_f32(dst + n , vcombine_f32(d20, d22));
vst1q_f32(dst + n*2, vcombine_f32(d24, d26));
vst1q_f32(dst + n*3, vcombine_f32(d28, d30));
src1 -= k;
src2 += k*3;
dst += 4;
}// end for j
src1 += k*4;
src2 -= k*n;
dst += n*3;
}// end for i
}
