From e66ac2f4768112216993b2ac5b64a6ce66650ab5 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 22:53:05 +0100
Subject: [PATCH 01/29] neon hook

---
 ...gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 660 +++++++++++-------
 ...sdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h |  31 +
 2 files changed, 441 insertions(+), 250 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index a958743a7..f49a3738d 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -51,24 +51,24 @@
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-	lv_16sc_t tmp16;
-	lv_32fc_t tmp32;
-	for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-	{
-		result[n_vec] = lv_cmake(0,0);
-	}
-	for (unsigned int n = 0; n < num_points; n++)
-	{
-		tmp16 = *in_common++;
-		tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-		tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-		(*phase) *= phase_inc;
-		for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-		{
-			lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
-			result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
-		}
-	}
+    lv_16sc_t tmp16;
+    lv_32fc_t tmp32;
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            result[n_vec] = lv_cmake(0,0);
+        }
+    for (unsigned int n = 0; n < num_points; n++)
+        {
+            tmp16 = *in_common++;
+            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+            tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            (*phase) *= phase_inc;
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                {
+                    lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
+                    result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
+                }
+        }
 }
 
 #endif /*LV_HAVE_GENERIC*/
@@ -87,150 +87,149 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
-	lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0,0);
 
-	const unsigned int sse_iters = num_points / 4;
+    const unsigned int sse_iters = num_points / 4;
 
-	const lv_16sc_t** _in_a = in_a;
-	const lv_16sc_t* _in_common = in_common;
-	lv_16sc_t* _out = out;
+    const lv_16sc_t** _in_a = in_a;
+    const lv_16sc_t* _in_common = in_common;
+    lv_16sc_t* _out = out;
 
-	__VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
 
-	//todo dyn mem reg
+    //todo dyn mem reg
 
-	__m128i* realcacc;
-	__m128i* imagcacc;
+    __m128i* realcacc;
+    __m128i* imagcacc;
 
-	realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
-	imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
+    realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
+    imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
 
-	__m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
 
-	mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
-	mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
+    mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
+    mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
 
-	// phase rotation registers
-	__m128 pa, pb, two_phase_acc_reg, two_phase_inc_reg;
-	__m128i pc1, pc2;
-	__attribute__((aligned(16))) lv_32fc_t two_phase_inc[2];
-	two_phase_inc[0] = phase_inc * phase_inc;
-	two_phase_inc[1] = phase_inc * phase_inc;
-	two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-	__attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
-	two_phase_acc[0] = (*phase);
-	two_phase_acc[1] = (*phase) * phase_inc;
-	two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
-	__m128 yl, yh, tmp1, tmp2, tmp3;
-	lv_16sc_t tmp16;
-	lv_32fc_t tmp32;
+    // phase rotation registers
+    __m128 pa, pb, two_phase_acc_reg, two_phase_inc_reg;
+    __m128i pc1, pc2;
+    __attribute__((aligned(16))) lv_32fc_t two_phase_inc[2];
+    two_phase_inc[0] = phase_inc * phase_inc;
+    two_phase_inc[1] = phase_inc * phase_inc;
+    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
+    __attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
+    two_phase_acc[0] = (*phase);
+    two_phase_acc[1] = (*phase) * phase_inc;
+    two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
+    __m128 yl, yh, tmp1, tmp2, tmp3;
+    lv_16sc_t tmp16;
+    lv_32fc_t tmp32;
 
-	for(unsigned int number = 0; number < sse_iters; number++)
-	{
-		// Phase rotation on operand in_common starts here:
+    for(unsigned int number = 0; number < sse_iters; number++)
+        {
+            // Phase rotation on operand in_common starts here:
 
-		pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-		//complex 32fc multiplication b=a*two_phase_acc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-		pc1 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
+            pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            pc1 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
 
-		//complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-		//next two samples
-		_in_common += 2;
-		pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-		//complex 32fc multiplication b=a*two_phase_acc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-		pc2 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
+            //next two samples
+            _in_common += 2;
+            pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            pc2 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
 
-		//complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-		// store four rotated in_common samples in the register b
-		b = _mm_packs_epi32(pc1, pc2);// convert from 32ic to 16ic
+            // store four rotated in_common samples in the register b
+            b = _mm_packs_epi32(pc1, pc2);// convert from 32ic to 16ic
 
-		//next two samples
-		_in_common += 2;
+            //next two samples
+            _in_common += 2;
 
-		for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-		{
-			a = _mm_load_si128((__m128i*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                {
+                    a = _mm_load_si128((__m128i*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
 
-			c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                    c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
 
-			c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
-			real = _mm_subs_epi16 (c, c_sr);
+                    c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    real = _mm_subs_epi16(c, c_sr);
 
-			b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-			a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+                    b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+                    a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
 
-			imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-			imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+                    imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+                    imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
 
-			imag = _mm_adds_epi16(imag1, imag2);
+                    imag = _mm_adds_epi16(imag1, imag2);
 
-			realcacc[n_vec] = _mm_adds_epi16 (realcacc[n_vec], real);
-			imagcacc[n_vec] = _mm_adds_epi16 (imagcacc[n_vec], imag);
+                    realcacc[n_vec] = _mm_adds_epi16 (realcacc[n_vec], real);
+                    imagcacc[n_vec] = _mm_adds_epi16 (imagcacc[n_vec], imag);
+                }
+        }
 
-		}
-	}
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            realcacc[n_vec] = _mm_and_si128(realcacc[n_vec], mask_real);
+            imagcacc[n_vec] = _mm_and_si128(imagcacc[n_vec], mask_imag);
 
-	for (int n_vec=0;n_vec<num_a_vectors;n_vec++)
-	{
-		realcacc[n_vec] = _mm_and_si128 (realcacc[n_vec], mask_real);
-		imagcacc[n_vec] = _mm_and_si128 (imagcacc[n_vec], mask_imag);
+            result = _mm_or_si128(realcacc[n_vec], imagcacc[n_vec]);
 
-		result = _mm_or_si128 (realcacc[n_vec], imagcacc[n_vec]);
+            _mm_store_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0,0);
+            for (int i = 0; i < 4; ++i)
+                {
+                    dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
+                            sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
+                }
+            _out[n_vec] = dotProduct;
+        }
+    free(realcacc);
+    free(imagcacc);
 
-		_mm_store_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
-		dotProduct = lv_cmake(0,0);
-		for (int i = 0; i<4; ++i)
-		{
-			dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
-					sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
-		}
-		_out[n_vec] = dotProduct;
-	}
-	free(realcacc);
-	free(imagcacc);
+    _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
+    (*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
 
-	_mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
-	(*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
-
-	for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-	{
-		for(unsigned int n  = sse_iters * 4; n < num_points; n++)
-		{
-			tmp16 = *in_common++;
-			tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-			tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-			(*phase) *= phase_inc;
-			lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
-			_out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-					sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
-		}
-	}
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+                {
+                    tmp16 = *in_common++;
+                    tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+                    tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+                    (*phase) *= phase_inc;
+                    lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
+                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
+                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                }
+        }
 
 }
 #endif /* LV_HAVE_SSE3 */
@@ -248,151 +247,312 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
-	lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0,0);
 
-	const unsigned int sse_iters = num_points / 4;
+    const unsigned int sse_iters = num_points / 4;
 
-	const lv_16sc_t** _in_a = in_a;
-	const lv_16sc_t* _in_common = in_common;
-	lv_16sc_t* _out = out;
+    const lv_16sc_t** _in_a = in_a;
+    const lv_16sc_t* _in_common = in_common;
+    lv_16sc_t* _out = out;
 
-	__VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
 
-	//todo dyn mem reg
+    //todo dyn mem reg
 
-	__m128i* realcacc;
-	__m128i* imagcacc;
+    __m128i* realcacc;
+    __m128i* imagcacc;
 
-	realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
-	imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
+    realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
+    imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
 
-	__m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
 
-	mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
-	mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
+    mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
+    mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
 
-	// phase rotation registers
-	__m128 pa, pb, two_phase_acc_reg, two_phase_inc_reg;
-	__m128i pc1, pc2;
-	__attribute__((aligned(16))) lv_32fc_t two_phase_inc[2];
-	two_phase_inc[0] = phase_inc * phase_inc;
-	two_phase_inc[1] = phase_inc * phase_inc;
-	two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-	__attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
-	two_phase_acc[0] = (*phase);
-	two_phase_acc[1] = (*phase) * phase_inc;
-	two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
-	__m128 yl, yh, tmp1, tmp2, tmp3;
-	lv_16sc_t tmp16;
-	lv_32fc_t tmp32;
+    // phase rotation registers
+    __m128 pa, pb, two_phase_acc_reg, two_phase_inc_reg;
+    __m128i pc1, pc2;
+    __attribute__((aligned(16))) lv_32fc_t two_phase_inc[2];
+    two_phase_inc[0] = phase_inc * phase_inc;
+    two_phase_inc[1] = phase_inc * phase_inc;
+    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
+    __attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
+    two_phase_acc[0] = (*phase);
+    two_phase_acc[1] = (*phase) * phase_inc;
+    two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
+    __m128 yl, yh, tmp1, tmp2, tmp3;
+    lv_16sc_t tmp16;
+    lv_32fc_t tmp32;
 
-	for(unsigned int number = 0; number < sse_iters; number++)
-	{
-		// Phase rotation on operand in_common starts here:
+    for(unsigned int number = 0; number < sse_iters; number++)
+        {
+            // Phase rotation on operand in_common starts here:
 
-		pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-		//complex 32fc multiplication b=a*two_phase_acc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-		pc1 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
+            pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            pc1 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
 
-		//complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-		//next two samples
-		_in_common += 2;
-		pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-		//complex 32fc multiplication b=a*two_phase_acc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-		pc2 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
+            //next two samples
+            _in_common += 2;
+            pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(pa, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            pa = _mm_shuffle_ps(pa, pa, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(pa, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            pb = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            pc2 = _mm_cvtps_epi32(pb); // convert from 32fc to 32ic
 
-		//complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-		yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-		yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-		tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-		tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-		tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-		two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-		// store four rotated in_common samples in the register b
-		b = _mm_packs_epi32(pc1, pc2);// convert from 32ic to 16ic
+            // store four rotated in_common samples in the register b
+            b = _mm_packs_epi32(pc1, pc2);// convert from 32ic to 16ic
 
-		//next two samples
-		_in_common += 2;
+            //next two samples
+            _in_common += 2;
 
-		for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-		{
-			a = _mm_loadu_si128((__m128i*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                {
+                    a = _mm_loadu_si128((__m128i*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
 
-			c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                    c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
 
-			c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
-			real = _mm_subs_epi16 (c, c_sr);
+                    c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    real = _mm_subs_epi16 (c, c_sr);
 
-			b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-			a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+                    b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+                    a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
 
-			imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-			imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+                    imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+                    imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
 
-			imag = _mm_adds_epi16(imag1, imag2);
+                    imag = _mm_adds_epi16(imag1, imag2);
 
-			realcacc[n_vec] = _mm_adds_epi16 (realcacc[n_vec], real);
-			imagcacc[n_vec] = _mm_adds_epi16 (imagcacc[n_vec], imag);
+                    realcacc[n_vec] = _mm_adds_epi16(realcacc[n_vec], real);
+                    imagcacc[n_vec] = _mm_adds_epi16(imagcacc[n_vec], imag);
 
-		}
-	}
+                }
+        }
 
-	for (int n_vec=0;n_vec<num_a_vectors;n_vec++)
-	{
-		realcacc[n_vec] = _mm_and_si128 (realcacc[n_vec], mask_real);
-		imagcacc[n_vec] = _mm_and_si128 (imagcacc[n_vec], mask_imag);
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            realcacc[n_vec] = _mm_and_si128 (realcacc[n_vec], mask_real);
+            imagcacc[n_vec] = _mm_and_si128 (imagcacc[n_vec], mask_imag);
 
-		result = _mm_or_si128 (realcacc[n_vec], imagcacc[n_vec]);
+            result = _mm_or_si128(realcacc[n_vec], imagcacc[n_vec]);
 
-		_mm_storeu_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
-		dotProduct = lv_cmake(0,0);
-		for (int i = 0; i<4; ++i)
-		{
-			dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
-					sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
-		}
-		_out[n_vec] = dotProduct;
-	}
-	free(realcacc);
-	free(imagcacc);
+            _mm_storeu_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0,0);
+            for (int i = 0; i<4; ++i)
+                {
+                    dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
+                            sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
+                }
+            _out[n_vec] = dotProduct;
+        }
+    free(realcacc);
+    free(imagcacc);
 
-	_mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
-	(*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
-
-	for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-	{
-		for(unsigned int n  = sse_iters * 4; n < num_points; n++)
-		{
-			tmp16 = *in_common++;
-			tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-			tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-			(*phase) *= phase_inc;
-			lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
-			_out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-					sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
-		}
-	}
+    _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
+    (*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
 
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+                {
+                    tmp16 = *in_common++;
+                    tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+                    tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+                    (*phase) *= phase_inc;
+                    lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
+                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
+                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                }
+        }
+    _out[2] =
 }
 #endif /* LV_HAVE_SSE3 */
+
+
+#ifdef LV_HAVE_NEON
+#include <arm_neon.h>
+
+static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+{
+//    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+//        {
+//            result[n_vec] = lv_cmake(0,0);
+//        }
+    lv_16sc_t dotProduct = lv_cmake(0,0);
+
+    const unsigned int neon_iters = num_points / 4;
+
+    const lv_16sc_t** _in_a = in_a;
+    const lv_16sc_t* _in_common = in_common;
+    lv_16sc_t* _out = out;
+    lv_16sc_t tmp16_;
+    lv_32fc_t tmp32_;
+
+    lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
+    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
+    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
+
+    float32x4_t _phase4_real = vld1q_f32(__phase4_real);
+    float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
+
+    lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
+    lv_32fc_t phase3 = phase2 * phase_inc;
+    lv_32fc_t phase4 = phase3 * phase_inc;
+
+    __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
+    __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+
+    float32x4_t _phase_real = vld1q_f32(__phase_real);
+    float32x4_t _phase_imag = vld1q_f32(__phase_imag);
+
+    float32x4_t half = vdupq_n_f32(0.5f);
+    int16x4x2_t tmp16;
+    int32x4x2_t tmp32i;
+    float32x4x2_t tmp32f, tmp_real, tmp_imag;
+    float32x4_t sign, PlusHalf, Round;
+
+    int16x4x2_t* accumulator;
+    accumulator = (int16x4x2_t*)calloc(num_a_vectors, sizeof(int16x4x2_t));
+
+    int16x4x2_t tmp_real, tmp_imag;
+
+    for(int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            accumulator[n_vec].val[0] = vdup_n_s16(0);
+            accumulator[n_vec].val[1] = vdup_n_s16(0);
+        }
+
+    if (neon_iters > 0)
+        {
+            int16x4x2_t a_val, b_val, c_val;
+
+
+            for(unsigned int number = 0; number < neon_iters; number++)
+                {
+                    /* load 4 complex numbers (int 16 bits each component) */
+                    tmp16 = vld2_s16((int16_t*)_in_common);
+                    __builtin_prefetch(_in_common + 8);
+                    _in_common += 4;
+
+                    /* promote them to int 32 bits */
+                    tmp32i.val[0] = vmovl_s16(tmp16.val[0]);
+                    tmp32i.val[1] = vmovl_s16(tmp16.val[1]);
+
+                    /* promote them to float 32 bits */
+                    tmp32f.val[0] = vcvtq_f32_s32(tmp32i.val[0]);
+                    tmp32f.val[1] = vcvtq_f32_s32(tmp32i.val[1]);
+
+                    /* complex multiplication of four complex samples (float 32 bits each component) */
+                    tmp_real.val[0] = vmulq_f32(tmp32f.val[0], _phase_real);
+                    tmp_real.val[1] = vmulq_f32(tmp32f.val[1], _phase_imag);
+                    tmp_imag.val[0] = vmulq_f32(tmp32f.val[0], _phase_imag);
+                    tmp_imag.val[1] = vmulq_f32(tmp32f.val[1], _phase_real);
+
+                    tmp32f.val[0] = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
+                    tmp32f.val[1] = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
+
+                    /* downcast results to int32 */
+                    /* in __aarch64__ we can do that with vcvtaq_s32_f32(ret1); vcvtaq_s32_f32(ret2); */
+                    sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(tmp32f.val[0]), 31)));
+                    PlusHalf = vaddq_f32(tmp32f.val[0], half);
+                    Round = vsubq_f32(PlusHalf, sign);
+                    tmp32i.val[0] = vcvtq_s32_f32(Round);
+
+                    sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(tmp32f.val[1]), 31)));
+                    PlusHalf = vaddq_f32(tmp32f.val[1], half);
+                    Round = vsubq_f32(PlusHalf, sign);
+                    tmp32i.val[1] = vcvtq_s32_f32(Round);
+
+                    /* downcast results to int16 */
+                    tmp16.val[0] = vqmovn_s32(tmp32i.val[0]);
+                    tmp16.val[1] = vqmovn_s32(tmp32i.val[1]);
+
+                    /* compute next four phases */
+                    tmp_real.val[0] = vmulq_f32(_phase_real, _phase4_real);
+                    tmp_real.val[1] = vmulq_f32(_phase_imag, _phase4_imag);
+                    tmp_imag.val[0] = vmulq_f32(_phase_real, _phase4_imag);
+                    tmp_imag.val[1] = vmulq_f32(_phase_imag, _phase4_real);
+
+                    _phase_real = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
+                    _phase_imag = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
+
+
+                    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                        {
+                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                            //__builtin_prefetch(_in_a[n_vec] + 8);
+
+                            // multiply the real*real and imag*imag to get real result
+                            // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
+                            tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+                            // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
+                            tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
+
+                            // Multiply cross terms to get the imaginary result
+                            // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
+                            tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
+                            // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
+                            tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+
+                            c_val.val[0] = vsub_s16(tmp_real.val[0], tmp_real.val[1]);
+                            c_val.val[1] = vadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
+
+                            accumulator[n_vec].val[0] = vadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
+                            accumulator[n_vec].val[1] = vadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
+                        }
+
+
+
+
+                }
+
+
+        }
+
+
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+                {
+                    tmp16_ = *in_common++;
+                    tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);
+                    tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
+                    (*phase) *= phase_inc;
+                    lv_16sc_t tmp = tmp16_ * in_a[n_vec][n];
+                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
+                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                }
+        }
+}
+
+
+#endif /* LV_HAVE_NEON */
+
 #endif /*INCLUDED_volk_gnsssdr_16ic_xn_dot_prod_16ic_xn_H*/
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index 28ca96609..a49259d77 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -132,6 +132,37 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
 
 #endif // SSE3
 
+#ifdef LV_HAVE_NEON
+
+static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
+{
+    // phases must be normalized. Phase rotator expects a complex exponential input!
+    float rem_carrier_phase_in_rad = 0.345;
+    float phase_step_rad = 0.123;
+    lv_32fc_t phase[1];
+    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), -sin(rem_carrier_phase_in_rad));
+    lv_32fc_t phase_inc[1];
+    phase_inc[0] = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad));
+
+    int num_a_vectors = 3;
+    lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_a_vectors; n++)
+    {
+       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
+       memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
+    }
+    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+
+    for(unsigned int n = 0; n < num_a_vectors; n++)
+    {
+        volk_gnsssdr_free(in_a[n]);
+    }
+    volk_gnsssdr_free(in_a);
+}
+
+#endif // NEON
+
 #endif  // INCLUDED_volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_H
 
 

From 787c28480b6c045241960956144c7a82712d2342 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 22:58:56 +0100
Subject: [PATCH 02/29] kk

---
 ...volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index f49a3738d..8ff7efc6b 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -441,7 +441,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     int16x4x2_t* accumulator;
     accumulator = (int16x4x2_t*)calloc(num_a_vectors, sizeof(int16x4x2_t));
 
-    int16x4x2_t tmp_real, tmp_imag;
+    int16x4x2_t tmp_real16, tmp_imag16;
 
     for(int n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
@@ -511,18 +511,18 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
                             // multiply the real*real and imag*imag to get real result
                             // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
-                            tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+                            tmp_real16.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
                             // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
-                            tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
+                            tmp_real16.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
 
                             // Multiply cross terms to get the imaginary result
                             // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
-                            tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
+                            tmp_imag16.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
                             // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
-                            tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+                            tmp_imag16.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
 
-                            c_val.val[0] = vsub_s16(tmp_real.val[0], tmp_real.val[1]);
-                            c_val.val[1] = vadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
+                            c_val.val[0] = vsub_s16(tmp_real16.val[0], tmp_real16.val[1]);
+                            c_val.val[1] = vadd_s16(tmp_imag16.val[0], tmp_imag16.val[1]);
 
                             accumulator[n_vec].val[0] = vadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
                             accumulator[n_vec].val[1] = vadd_s16(accumulator[n_vec].val[1], c_val.val[1]);

From 4454d8800adc3262194f9876a377449a27c9bf87 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 23:01:28 +0100
Subject: [PATCH 03/29] kk2

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h            | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 8ff7efc6b..6d9fd89d4 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -391,7 +391,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
                             sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
-    _out[2] =
 }
 #endif /* LV_HAVE_SSE3 */
 
@@ -539,7 +538,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+            for(unsigned int n  = neon_iters * 4; n < num_points; n++)
                 {
                     tmp16_ = *in_common++;
                     tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);

From 8820e59eab2243b085bdd027a0f047339b2733f0 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 23:03:11 +0100
Subject: [PATCH 04/29] stupid error

---
 .../volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index a49259d77..d67609676 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -152,7 +152,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
        memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
     }
     result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
     {

From c184fafbb3987ceda4945f583939598d4de8249b Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 23:05:01 +0100
Subject: [PATCH 05/29] even more stupid error

---
 ...sdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h | 58 +++++++++----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index d67609676..63a86cf45 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -55,17 +55,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-       memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
-    }
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
+        }
     result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -85,17 +85,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
-    }
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
     result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -116,17 +116,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
-    }
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
+            memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
+        }
     result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -147,17 +147,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
-    }
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
+            memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
+        }
     result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 

From bef9638729d9c9f37a34dfc58280281508d65f96 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 23:36:32 +0100
Subject: [PATCH 06/29] missing part

---
 ...gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 6d9fd89d4..90a7ed17d 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -404,7 +404,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 //        {
 //            result[n_vec] = lv_cmake(0,0);
 //        }
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+   lv_16sc_t dotProduct;
 
     const unsigned int neon_iters = num_points / 4;
 
@@ -451,7 +451,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     if (neon_iters > 0)
         {
             int16x4x2_t a_val, b_val, c_val;
-
+            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
 
             for(unsigned int number = 0; number < neon_iters; number++)
                 {
@@ -502,11 +502,9 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     _phase_real = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
                     _phase_imag = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
 
-
                     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
                             a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
-                            //__builtin_prefetch(_in_a[n_vec] + 8);
 
                             // multiply the real*real and imag*imag to get real result
                             // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
@@ -528,11 +526,20 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                         }
 
 
-
-
                 }
 
-
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                {
+                    vst2_s16((int16_t*)dotProductVector, accumulator[n_vec]); // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0,0);
+                    for (int i = 0; i < 4; ++i)
+                        {
+                            dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
+                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
+                        }
+                    _out[n_vec] = dotProduct;
+                }
+            free(accumulator);
         }
 
 

From 27afafce0fd146a2434722f4d97cdc091e2ffacc Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Thu, 11 Feb 2016 23:53:03 +0100
Subject: [PATCH 07/29] first attempt

---
 ...gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 91 ++++++++++---------
 1 file changed, 46 insertions(+), 45 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 90a7ed17d..ea28e9c60 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -42,12 +42,14 @@
 
 #ifdef LV_HAVE_GENERIC
 /*!
- \brief Multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
- \param[out] result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
- \param[in]  in_common     Pointer to one of the vectors to be multiplied and accumulated (reference vector)
- \param[in]  in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
- \param[in]  num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
- \param[in]  num_points    The Number of complex values to be multiplied together, accumulated and stored into result
+ \brief Rotates and multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
+ \param[out]    result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
+ \param[in]     in_common     Pointer to one of the vectors to be rotated, multiplied and accumulated (reference vector)
+ \param[in]     phase_inc     Phase increment = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad))
+ \param[in,out] phase         Initial / final phase
+ \param[in]     in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
+ \param[in]     num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
+ \param[in]     num_points    The Number of complex values to be multiplied together, accumulated and stored into result
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
@@ -78,12 +80,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc
 #include <pmmintrin.h>
 
 /*!
- \brief Multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
- \param[out] result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
- \param[in]  in_common     Pointer to one of the vectors to be multiplied and accumulated (reference vector)
- \param[in]  in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
- \param[in]  num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
- \param[in]  num_points    The Number of complex values to be multiplied together, accumulated and stored into result
+ \brief Rotates and multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
+ \param[out]    result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
+ \param[in]     in_common     Pointer to one of the vectors to be rotated, multiplied and accumulated (reference vector)
+ \param[in]     phase_inc     Phase increment = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad))
+ \param[in,out] phase         Initial / final phase
+ \param[in]     in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
+ \param[in]     num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
+ \param[in]     num_points    The Number of complex values to be multiplied together, accumulated and stored into result
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
@@ -238,12 +242,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
 #include <pmmintrin.h>
 
 /*!
- \brief Multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
- \param[out] result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
- \param[in]  in_common     Pointer to one of the vectors to be multiplied and accumulated (reference vector)
- \param[in]  in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
- \param[in]  num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
- \param[in]  num_points    The Number of complex values to be multiplied together, accumulated and stored into result
+ \brief Rotates and multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
+ \param[out]    result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
+ \param[in]     in_common     Pointer to one of the vectors to be rotated, multiplied and accumulated (reference vector)
+ \param[in]     phase_inc     Phase increment = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad))
+ \param[in,out] phase         Initial / final phase
+ \param[in]     in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
+ \param[in]     num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
+ \param[in]     num_points    The Number of complex values to be multiplied together, accumulated and stored into result
  */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
@@ -352,7 +358,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
 
                     realcacc[n_vec] = _mm_adds_epi16(realcacc[n_vec], real);
                     imagcacc[n_vec] = _mm_adds_epi16(imagcacc[n_vec], imag);
-
                 }
         }
 
@@ -400,12 +405,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
 
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
-//    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-//        {
-//            result[n_vec] = lv_cmake(0,0);
-//        }
-   lv_16sc_t dotProduct;
-
     const unsigned int neon_iters = num_points / 4;
 
     const lv_16sc_t** _in_a = in_a;
@@ -414,6 +413,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     lv_16sc_t tmp16_;
     lv_32fc_t tmp32_;
 
+    lv_16sc_t dotProduct;
+
     lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
     __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
     __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
@@ -431,27 +432,26 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     float32x4_t _phase_real = vld1q_f32(__phase_real);
     float32x4_t _phase_imag = vld1q_f32(__phase_imag);
 
-    float32x4_t half = vdupq_n_f32(0.5f);
-    int16x4x2_t tmp16;
-    int32x4x2_t tmp32i;
-    float32x4x2_t tmp32f, tmp_real, tmp_imag;
-    float32x4_t sign, PlusHalf, Round;
-
-    int16x4x2_t* accumulator;
-    accumulator = (int16x4x2_t*)calloc(num_a_vectors, sizeof(int16x4x2_t));
-
-    int16x4x2_t tmp_real16, tmp_imag16;
-
-    for(int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-        {
-            accumulator[n_vec].val[0] = vdup_n_s16(0);
-            accumulator[n_vec].val[1] = vdup_n_s16(0);
-        }
-
     if (neon_iters > 0)
         {
             int16x4x2_t a_val, b_val, c_val;
             __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            float32x4_t half = vdupq_n_f32(0.5f);
+            int16x4x2_t tmp16;
+            int32x4x2_t tmp32i;
+            float32x4x2_t tmp32f, tmp_real, tmp_imag;
+            float32x4_t sign, PlusHalf, Round;
+
+            int16x4x2_t* accumulator;
+            accumulator = (int16x4x2_t*)calloc(num_a_vectors, sizeof(int16x4x2_t));
+
+            int16x4x2_t tmp_real16, tmp_imag16;
+
+            for(int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+                {
+                    accumulator[n_vec].val[0] = vdup_n_s16(0);
+                    accumulator[n_vec].val[1] = vdup_n_s16(0);
+                }
 
             for(unsigned int number = 0; number < neon_iters; number++)
                 {
@@ -524,8 +524,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                             accumulator[n_vec].val[0] = vadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
                             accumulator[n_vec].val[1] = vadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
                         }
-
-
                 }
 
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
@@ -540,6 +538,10 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     _out[n_vec] = dotProduct;
                 }
             free(accumulator);
+            vst1q_f32((float32_t*)__phase_real, _phase_real);
+            vst1q_f32((float32_t*)__phase_imag, _phase_imag);
+
+            (*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
         }
 
 
@@ -558,7 +560,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
         }
 }
 
-
 #endif /* LV_HAVE_NEON */
 
 #endif /*INCLUDED_volk_gnsssdr_16ic_xn_dot_prod_16ic_xn_H*/

From 5067c5852c4c4179351927b156e750daef2df525 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 10:57:53 +0100
Subject: [PATCH 08/29] fixes

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h    | 10 +++++-----
 ...volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index ea28e9c60..44f142a94 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -434,7 +434,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     if (neon_iters > 0)
         {
-            int16x4x2_t a_val, b_val, c_val;
+            int16x4x2_t a_val, c_val;
             __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
             float32x4_t half = vdupq_n_f32(0.5f);
             int16x4x2_t tmp16;
@@ -508,15 +508,15 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
                             // multiply the real*real and imag*imag to get real result
                             // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
-                            tmp_real16.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+                            tmp_real16.val[0] = vmul_s16(a_val.val[0], tmp16.val[0]);
                             // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
-                            tmp_real16.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
+                            tmp_real16.val[1] = vmul_s16(a_val.val[1], tmp16.val[1]);
 
                             // Multiply cross terms to get the imaginary result
                             // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
-                            tmp_imag16.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
+                            tmp_imag16.val[0] = vmul_s16(a_val.val[0], tmp16.val[1]);
                             // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
-                            tmp_imag16.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+                            tmp_imag16.val[1] = vmul_s16(a_val.val[1], tmp16.val[0]);
 
                             c_val.val[0] = vsub_s16(tmp_real16.val[0], tmp_real16.val[1]);
                             c_val.val[1] = vadd_s16(tmp_imag16.val[0], tmp_imag16.val[1]);
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index 63a86cf45..bc8a7bbf6 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -59,7 +59,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
         }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
@@ -151,7 +151,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
             memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
         }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)

From 912db4fe292dbd6be6d43aef3d0daf3a91101ea5 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 12:00:54 +0100
Subject: [PATCH 09/29] fixes

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h    |  4 ++--
 ...volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 44f142a94..22cf04bb1 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -410,7 +410,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     const lv_16sc_t** _in_a = in_a;
     const lv_16sc_t* _in_common = in_common;
     lv_16sc_t* _out = out;
-    lv_16sc_t tmp16_;
+    lv_16sc_t tmp16_, tmp;
     lv_32fc_t tmp32_;
 
     lv_16sc_t dotProduct;
@@ -553,7 +553,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);
                     tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
                     (*phase) *= phase_inc;
-                    lv_16sc_t tmp = tmp16_ * in_a[n_vec][n];
+                    tmp = tmp16_ * in_a[n_vec][n];
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
                             sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index bc8a7bbf6..4240b8710 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -60,7 +60,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
             memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
         }
     //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(&result[0], local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
@@ -89,8 +89,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(&result[0], local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
@@ -120,8 +120,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
             memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
         }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(&result[0], local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {

From 70ec7a66f88fafe5553f574f35d13e03ccb9b307 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 21:24:07 +0100
Subject: [PATCH 10/29] fixes

---
 .../volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h |  8 ++++----
 ...k_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 17 ++++++++---------
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h
index a435ca272..762fd4d8b 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h
@@ -51,7 +51,7 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_generic(lv_16sc_t*
        in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
        memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
     }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
@@ -73,7 +73,7 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_a_sse2(lv_16sc_t* r
        in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
        memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
     }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
@@ -96,7 +96,7 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_u_sse2(lv_16sc_t* r
        in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
        memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
     }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
@@ -119,7 +119,7 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_neon(lv_16sc_t* res
        in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
        memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
     }
-    result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 902e98877..527b11b41 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -546,17 +546,16 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
         }
 
 
-    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+    for (unsigned int n  = neon_iters * 4; n < num_points; n++)
         {
-            for(unsigned int n  = neon_iters * 4; n < num_points; n++)
+            tmp16 = *in_common++;
+            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+            tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            (*phase) *= phase_inc;
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    tmp16_ = *in_common++;
-                    tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);
-                    tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
-                    (*phase) *= phase_inc;
-                    tmp = tmp16_ * in_a[n_vec][n];
-                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                    tmp = tmp16 * in_a[n_vec][n];
+                    result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
                 }
         }
 }

From dd6b804364d6eacb1d810b873c218215af92a69b Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 21:27:01 +0100
Subject: [PATCH 11/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 527b11b41..e4dc2892c 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -548,14 +548,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     for (unsigned int n  = neon_iters * 4; n < num_points; n++)
         {
-            tmp16 = *in_common++;
-            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-            tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            tmp16_ = *_in_common++;
+            tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);
+            tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
             (*phase) *= phase_inc;
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    tmp = tmp16 * in_a[n_vec][n];
-                    result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
+                    tmp = tmp16_ * in_a[n_vec][n];
+                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
                 }
         }
 }

From 3abefa246ddb62988e9abd5f35551a54e94e7a98 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 21:28:37 +0100
Subject: [PATCH 12/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index e4dc2892c..af3fc17c3 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -555,7 +555,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     tmp = tmp16_ * in_a[n_vec][n];
-                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
+                    _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }

From 036b8805db5a3d420399941064921c0937b761f2 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 12 Feb 2016 21:56:44 +0100
Subject: [PATCH 13/29] fix

---
 ...gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 46 +++++++++++--------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index af3fc17c3..83d70f9fa 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -411,30 +411,36 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     const lv_16sc_t** _in_a = in_a;
     const lv_16sc_t* _in_common = in_common;
     lv_16sc_t* _out = out;
+
+    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+        {
+            _out[n_vec] = lv_cmake(0,0);
+        }
+
     lv_16sc_t tmp16_, tmp;
     lv_32fc_t tmp32_;
 
-    lv_16sc_t dotProduct;
-
-    lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
-
-    float32x4_t _phase4_real = vld1q_f32(__phase4_real);
-    float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
-
-    lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
-    lv_32fc_t phase3 = phase2 * phase_inc;
-    lv_32fc_t phase4 = phase3 * phase_inc;
-
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
-
-    float32x4_t _phase_real = vld1q_f32(__phase_real);
-    float32x4_t _phase_imag = vld1q_f32(__phase_imag);
-
     if (neon_iters > 0)
         {
+            lv_16sc_t dotProduct;
+
+            lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
+            __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
+            __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
+
+            float32x4_t _phase4_real = vld1q_f32(__phase4_real);
+            float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
+
+            lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
+            lv_32fc_t phase3 = phase2 * phase_inc;
+            lv_32fc_t phase4 = phase3 * phase_inc;
+
+            __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
+            __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+
+            float32x4_t _phase_real = vld1q_f32(__phase_real);
+            float32x4_t _phase_imag = vld1q_f32(__phase_imag);
+
             int16x4x2_t a_val, c_val;
             __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
             float32x4_t half = vdupq_n_f32(0.5f);
@@ -546,7 +552,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
         }
 
 
-    for (unsigned int n  = neon_iters * 4; n < num_points; n++)
+    for (unsigned int n = neon_iters * 4; n < num_points; n++)
         {
             tmp16_ = *_in_common++;
             tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);

From f535259bedc3b2f288aeac0e8b30de1898cd5885 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 11:07:55 +0100
Subject: [PATCH 14/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h   | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 83d70f9fa..8eb73f9e9 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -110,7 +110,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
     realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
     imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
 
-    __m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
 
     mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
     mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
@@ -272,7 +272,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
     realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
     imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
 
-    __m128i a,b,c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
 
     mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
     mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
@@ -412,11 +412,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     const lv_16sc_t* _in_common = in_common;
     lv_16sc_t* _out = out;
 
-    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
-        {
-            _out[n_vec] = lv_cmake(0,0);
-        }
-
     lv_16sc_t tmp16_, tmp;
     lv_32fc_t tmp32_;
 
@@ -560,7 +555,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
             (*phase) *= phase_inc;
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    tmp = tmp16_ * in_a[n_vec][n];
+                    tmp = tmp16_ * _in_a[n_vec][n];
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }

From 85bd40ed91d227c9c07a12f348eab83a4dc6649e Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 12:20:59 +0100
Subject: [PATCH 15/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h         | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 8eb73f9e9..51dd18616 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -417,7 +417,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     if (neon_iters > 0)
         {
-            lv_16sc_t dotProduct;
+            lv_16sc_t dotProduct = lv_cmake(0,0);
 
             lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
             __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
@@ -428,7 +428,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
             lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
             lv_32fc_t phase3 = phase2 * phase_inc;
-            lv_32fc_t phase4 = phase3 * phase_inc;
+            lv_32fc_t phase4 = ___phase4;
 
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
@@ -550,7 +550,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
     for (unsigned int n = neon_iters * 4; n < num_points; n++)
         {
             tmp16_ = *_in_common++;
-            tmp32_ = lv_cmake((float)lv_creal(tmp16_), (float)lv_cimag(tmp16_)) * (*phase);
+            tmp32_ = lv_cmake((float32_t)lv_creal(tmp16_), (float32_t)lv_cimag(tmp16_)) * (*phase);
             tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
             (*phase) *= phase_inc;
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)

From 5ed27443fe2849ded4c1d31b0f825f39d76a344a Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 12:32:03 +0100
Subject: [PATCH 16/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 51dd18616..c8212ef64 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -428,7 +428,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
             lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
             lv_32fc_t phase3 = phase2 * phase_inc;
-            lv_32fc_t phase4 = ___phase4;
+            lv_32fc_t phase4 = phase3 * phase_inc;;
 
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };

From 83d7b72743a3837e1b78846576614897a270e34f Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 12:53:39 +0100
Subject: [PATCH 17/29] fixes

---
 ...volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 14 ++++++++++++--
 ..._gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h | 10 +++++-----
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index c8212ef64..40a78b01c 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -371,7 +371,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
 
             _mm_storeu_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
             dotProduct = lv_cmake(0,0);
-            for (int i = 0; i<4; ++i)
+            for (int i = 0; i < 4; ++i)
                 {
                     dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[i])),
                             sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[i])));
@@ -404,6 +404,16 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
+/*!
+ \brief Rotates and multiplies the reference complex vector with multiple versions of another complex vector, accumulates the results and stores them in the output vector
+ \param[out]    result        Array of num_a_vectors components with the multiple versions of in_a multiplied and accumulated The vector where the accumulated result will be stored
+ \param[in]     in_common     Pointer to one of the vectors to be rotated, multiplied and accumulated (reference vector)
+ \param[in]     phase_inc     Phase increment = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad))
+ \param[in,out] phase         Initial / final phase
+ \param[in]     in_a          Pointer to an array of pointers to multiple versions of the other vector to be multiplied and accumulated
+ \param[in]     num_a_vectors Number of vectors to be multiplied by the reference vector and accumulated
+ \param[in]     num_points    The Number of complex values to be multiplied together, accumulated and stored into result
+ */
 static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t* out, const lv_16sc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
 {
     const unsigned int neon_iters = num_points / 4;
@@ -428,7 +438,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
             lv_32fc_t phase2 = (lv_32fc_t)(*phase) * phase_inc;
             lv_32fc_t phase3 = phase2 * phase_inc;
-            lv_32fc_t phase4 = phase3 * phase_inc;;
+            lv_32fc_t phase4 = phase3 * phase_inc;
 
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
             __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index 4240b8710..ae2c9ec44 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -57,7 +57,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-            memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
     //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(&result[0], local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
@@ -117,8 +117,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-            memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
         }
     //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(&result[0], local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
@@ -148,8 +148,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-            memcpy(in_a[n], in, sizeof(lv_16sc_t)*num_points);
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
     //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);

From ca3046a9a97b7a3fbd8e303c44fdc889127b3f73 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 13:18:49 +0100
Subject: [PATCH 18/29] fix

---
 .../libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc   | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
index e849ce15c..d4f06e151 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
@@ -76,10 +76,8 @@ void load_random_data(void *data, volk_gnsssdr_type_t type, unsigned int n)
                         else ((uint32_t *)data)[i] = (uint32_t) scaled_rand;
                         break;
                     case 2:
-                        // 16 bits dot product saturates very fast even with moderate length vectors
-                    	// we produce here only 4 bits input range
-                        if(type.is_signed) ((int16_t *)data)[i] = (int16_t)((int16_t) scaled_rand % 16);
-                        else ((uint16_t *)data)[i] = (uint16_t) (int16_t)((int16_t) scaled_rand % 16);
+                        if(type.is_signed) ((int16_t *)data)[i] = (int16_t) scaled_rand;
+                        else ((uint16_t *)data)[i] = (uint16_t) scaled_rand;
                         break;
                     case 1:
                         if(type.is_signed) ((int8_t *)data)[i] = (int8_t) scaled_rand;

From 7b9daf3d539fed8c1c06ae084a3c5cac8d46c4ac Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 13:27:03 +0100
Subject: [PATCH 19/29] fix

---
 ...k_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index ae2c9ec44..c0db5decb 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -59,8 +59,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(&result[0], local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
@@ -89,8 +88,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(&result[0], local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
@@ -120,8 +119,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy(in_a[n], in, sizeof(lv_16sc_t) * num_points);
         }
-    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(&result[0], local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)
         {
@@ -151,7 +150,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    //result = (lv_16sc_t*)calloc(num_points, sizeof(lv_16sc_t));
+
     volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
 
     for(unsigned int n = 0; n < num_a_vectors; n++)

From 907846d70b37fdb2d58fae92edd5adafde7e115d Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Sat, 13 Feb 2016 13:30:19 +0100
Subject: [PATCH 20/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h      | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 40a78b01c..91e6c523c 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -272,7 +272,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
     realcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
     imagcacc = (__m128i*)calloc(num_a_vectors, sizeof(__m128i)); //calloc also sets memory to 0
 
-    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, result;
 
     mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
     mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
@@ -344,10 +344,10 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
                 {
                     a = _mm_loadu_si128((__m128i*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
 
-                    c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                    c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
 
-                    c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
-                    real = _mm_subs_epi16 (c, c_sr);
+                    c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    real = _mm_subs_epi16(c, c_sr);
 
                     b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
                     a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
@@ -556,7 +556,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
             (*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
         }
 
-
     for (unsigned int n = neon_iters * 4; n < num_points; n++)
         {
             tmp16_ = *_in_common++;

From 505b13a21a473d801bf2d758ca84ad8a86bcdf95 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Tue, 16 Feb 2016 18:46:37 +0100
Subject: [PATCH 21/29] updating

---
 .../libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc   | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
index d4f06e151..e849ce15c 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
@@ -76,8 +76,10 @@ void load_random_data(void *data, volk_gnsssdr_type_t type, unsigned int n)
                         else ((uint32_t *)data)[i] = (uint32_t) scaled_rand;
                         break;
                     case 2:
-                        if(type.is_signed) ((int16_t *)data)[i] = (int16_t) scaled_rand;
-                        else ((uint16_t *)data)[i] = (uint16_t) scaled_rand;
+                        // 16 bits dot product saturates very fast even with moderate length vectors
+                    	// we produce here only 4 bits input range
+                        if(type.is_signed) ((int16_t *)data)[i] = (int16_t)((int16_t) scaled_rand % 16);
+                        else ((uint16_t *)data)[i] = (uint16_t) (int16_t)((int16_t) scaled_rand % 16);
                         break;
                     case 1:
                         if(type.is_signed) ((int8_t *)data)[i] = (int8_t) scaled_rand;

From 39ce43f7e3963987ce7306c96594995c2de5a337 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 08:25:41 +0100
Subject: [PATCH 22/29] fixes

---
 .../volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h   | 10 ++--
 ...gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 51 +++++++++++--------
 ...sdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h | 20 ++++----
 .../volk_gnsssdr/lib/kernel_tests.h           |  5 +-
 4 files changed, 48 insertions(+), 38 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h
index 6a79ffbde..b5f11e9ba 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h
@@ -302,7 +302,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 
             //todo dyn mem reg
             int16x4x2_t* accumulator;
-            accumulator = (int16x4x2_t*)calloc(num_a_vectors, sizeof(int16x4x2_t));
+            accumulator = (int16x4x2_t*)malloc(num_a_vectors * sizeof(int16x4x2_t));
 
             int16x4x2_t tmp_real, tmp_imag;
 
@@ -333,11 +333,11 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
                             // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
                             tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
 
-                            c_val.val[0] = vsub_s16(tmp_real.val[0], tmp_real.val[1]);
-                            c_val.val[1] = vadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
+                            c_val.val[0] = vqsub_s16(tmp_real.val[0], tmp_real.val[1]);
+                            c_val.val[1] = vqadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
 
-                            accumulator[n_vec].val[0] = vadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
-                            accumulator[n_vec].val[1] = vadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
+                            accumulator[n_vec].val[0] = vqadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
+                            accumulator[n_vec].val[1] = vqadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
                         }
                     _in_common += 4;
                 }
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 0b234c8f3..55b7e547f 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -43,6 +43,7 @@
 #include <volk_gnsssdr/volk_gnsssdr_complex.h>
 #include <volk_gnsssdr/saturation_arithmetic.h>
 #include <math.h>
+#include <stdio.h>
 
 #ifdef LV_HAVE_GENERIC
 /*!
@@ -65,13 +66,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc
         }
     for (unsigned int n = 0; n < num_points; n++)
         {
-            tmp16 = *in_common++;
+            tmp16 = *in_common++; if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
             tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
             (*phase) *= phase_inc;
             for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
+                    //lv_16sc_t tmp = lv_cmake(sat_adds16i(sat_muls16i(lv_creal(tmp16), lv_creal(in_a[n_vec][n])), - sat_muls16i(lv_cimag(tmp16), lv_cimag(in_a[n_vec][n]))) , sat_adds16i(sat_muls16i(lv_creal(tmp16), lv_cimag(in_a[n_vec][n])), sat_muls16i(lv_cimag(tmp16), lv_creal(in_a[n_vec][n]))));
                     result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
                 }
         }
@@ -128,6 +130,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
     __attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
+    printf("a_sse phase %i: %f,%f\n", 0,lv_creal(two_phase_acc[0]),lv_cimag(two_phase_acc[0]));
+    printf("a_sse phase %i: %f,%f\n", 1,lv_creal(two_phase_acc[1]),lv_cimag(two_phase_acc[1]));
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
     __m128 yl, yh, tmp1, tmp2, tmp3;
     lv_16sc_t tmp16;
@@ -136,7 +140,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
     for(unsigned int number = 0; number < sse_iters; number++)
         {
             // Phase rotation on operand in_common starts here:
-
+            //printf("generic phase %i: %f,%f\n", n*4,lv_creal(*phase),lv_cimag(*phase));
             pa = _mm_set_ps((float)(lv_cimag(_in_common[1])), (float)(lv_creal(_in_common[1])), (float)(lv_cimag(_in_common[0])), (float)(lv_creal(_in_common[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             //complex 32fc multiplication b=a*two_phase_acc_reg
             yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
@@ -223,17 +227,20 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
     free(imagcacc);
 
     _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
-    (*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
+    //(*phase) = lv_cmake((float*)two_phase_acc[0], (float*)two_phase_acc[1]);
+    (*phase) = two_phase_acc[0];
 
-    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+    for(unsigned int n  = sse_iters * 4; n < num_points; n++)
         {
-            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+            tmp16 = *in_common++;  printf("a_sse phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+            tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            (*phase) *= phase_inc;
+
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    tmp16 = *in_common++;
-                    tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-                    tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-                    (*phase) *= phase_inc;
                     lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
+                    //lv_16sc_t tmp = lv_cmake(sat_adds16i(sat_muls16i(lv_creal(tmp16), lv_creal(in_a[n_vec][n])), - sat_muls16i(lv_cimag(tmp16), lv_cimag(in_a[n_vec][n]))) , sat_adds16i(sat_muls16i(lv_creal(tmp16), lv_cimag(in_a[n_vec][n])), sat_muls16i(lv_cimag(tmp16), lv_creal(in_a[n_vec][n]))));
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
                             sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
@@ -386,16 +393,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
     free(imagcacc);
 
     _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
-    (*phase) = lv_cmake(two_phase_acc[0], two_phase_acc[0]);
+    (*phase) = two_phase_acc[0];//lv_cmake(two_phase_acc[0], two_phase_acc[1]);
 
-    for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
+
+    for(unsigned int n  = sse_iters * 4; n < num_points; n++)
         {
-            for(unsigned int n  = sse_iters * 4; n < num_points; n++)
+            tmp16 = *in_common++;
+            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+            tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            (*phase) *= phase_inc;
+            for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    tmp16 = *in_common++;
-                    tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-                    tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-                    (*phase) *= phase_inc;
                     lv_16sc_t tmp = tmp16 * in_a[n_vec][n];
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
                             sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
@@ -484,7 +492,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     tmp32f.val[1] = vcvtq_f32_s32(tmp32i.val[1]);
 
                     /* complex multiplication of four complex samples (float 32 bits each component) */
-
                     tmp32_real.val[0] = vmulq_f32(tmp32f.val[0], _phase_real);
                     tmp32_real.val[1] = vmulq_f32(tmp32f.val[1], _phase_imag);
                     tmp32_imag.val[0] = vmulq_f32(tmp32f.val[0], _phase_imag);
@@ -528,17 +535,17 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                             b_val.val[0] = vmul_s16(a_val.val[0], tmp16.val[0]);
                             // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
                             b_val.val[1] = vmul_s16(a_val.val[1], tmp16.val[1]);
-                            c_val.val[0] = vsub_s16(b_val.val[0], b_val.val[1]);
+                            c_val.val[0] = vqsub_s16(b_val.val[0], b_val.val[1]);
 
                             // Multiply cross terms to get the imaginary result
                             // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
                             b_val.val[0] = vmul_s16(a_val.val[0], tmp16.val[1]);
                             // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
                             b_val.val[1] = vmul_s16(a_val.val[1], tmp16.val[0]);
-                            c_val.val[1] = vadd_s16(b_val.val[0], b_val.val[1]);
+                            c_val.val[1] = vqadd_s16(b_val.val[0], b_val.val[1]);
 
-                            accumulator[n_vec].val[0] = vadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
-                            accumulator[n_vec].val[1] = vadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
+                            accumulator[n_vec].val[0] = vqadd_s16(accumulator[n_vec].val[0], c_val.val[0]);
+                            accumulator[n_vec].val[1] = vqadd_s16(accumulator[n_vec].val[1], c_val.val[1]);
                         }
                 }
 
@@ -562,7 +569,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     for (unsigned int n = neon_iters * 4; n < num_points; n++)
         {
-            tmp16_ = in_common[n];
+            tmp16_ = in_common[n];  printf("neon phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32_ = lv_cmake((float32_t)lv_creal(tmp16_), (float32_t)lv_cimag(tmp16_)) * (*phase);
             tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
             (*phase) *= phase_inc;
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index c0db5decb..666650b76 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -37,8 +37,8 @@
 
 #include "volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h"
 #include <volk_gnsssdr/volk_gnsssdr_malloc.h>
-#include <volk_gnsssdr/volk_gnsssdr_complex.h>
-#include <volk_gnsssdr/volk_gnsssdr.h>
+//#include <volk_gnsssdr/volk_gnsssdr_complex.h>
+//#include <volk_gnsssdr/volk_gnsssdr.h>
 #include <string.h>
 
 #ifdef LV_HAVE_GENERIC
@@ -46,11 +46,11 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.001;
     lv_32fc_t phase[1];
-    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), -sin(rem_carrier_phase_in_rad));
+    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
-    phase_inc[0] = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad));
+    phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
 
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
@@ -75,11 +75,11 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.001;
     lv_32fc_t phase[1];
-    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), -sin(rem_carrier_phase_in_rad));
+    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
-    phase_inc[0] = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad));
+    phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
 
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
@@ -108,9 +108,9 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
     float rem_carrier_phase_in_rad = 0.345;
     float phase_step_rad = 0.123;
     lv_32fc_t phase[1];
-    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), -sin(rem_carrier_phase_in_rad));
+    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
-    phase_inc[0] = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad));
+    phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
 
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
index 97bf1ee97..2f2511d92 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
@@ -59,6 +59,9 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
     volk_gnsssdr_test_params_t test_params_more_iters = volk_gnsssdr_test_params_t(test_params.tol(), test_params.scalar(),
                 test_params.vlen(), 100000, test_params.benchmark_mode(), test_params.kernel_regex());
 
+    volk_gnsssdr_test_params_t test_params_1_iter = volk_gnsssdr_test_params_t(test_params.tol(), test_params.scalar(),
+                   test_params.vlen(), 1, test_params.benchmark_mode(), test_params.kernel_regex());
+
     std::vector<volk_gnsssdr_test_case_t> test_cases = boost::assign::list_of
 
         (VOLK_INIT_TEST(volk_gnsssdr_8i_accumulator_s8i, test_params_more_iters))
@@ -81,7 +84,7 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerpuppet_16ic, volk_gnsssdr_16ic_resampler_16ic, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_16ic_xn, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_dot_prod_16ic_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params))
+        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_1_iter))
         ;
 
     return test_cases;

From 076cbb636ed9f8e23702ee5c1cd2f63f4db9c689 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 09:35:25 +0100
Subject: [PATCH 23/29] fix

---
 ...lk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h | 16 ++++++++++------
 ...nsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h |  4 ++--
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 55b7e547f..3d8fa52e9 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -232,7 +232,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
 
     for(unsigned int n  = sse_iters * 4; n < num_points; n++)
         {
-            tmp16 = *in_common++;  printf("a_sse phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp16 = in_common[n];  printf("a_sse phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
             tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
             (*phase) *= phase_inc;
@@ -284,7 +284,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
 
     __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, results;
 
-
     mask_imag = _mm_set_epi8(255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0);
     mask_real = _mm_set_epi8(0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255);
 
@@ -294,11 +293,11 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
     __attribute__((aligned(16))) lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
+    two_phase_inc_reg = _mm_loadu_ps((float*) two_phase_inc);
     __attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
-    two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
+    two_phase_acc_reg = _mm_loadu_ps((float*)two_phase_acc);
     __m128 yl, yh, tmp1, tmp2, tmp3;
     lv_16sc_t tmp16;
     lv_32fc_t tmp32;
@@ -392,13 +391,13 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(lv_16sc_
     free(realcacc);
     free(imagcacc);
 
-    _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
+    _mm_storeu_ps((float*)two_phase_acc, two_phase_acc_reg);
     (*phase) = two_phase_acc[0];//lv_cmake(two_phase_acc[0], two_phase_acc[1]);
 
 
     for(unsigned int n  = sse_iters * 4; n < num_points; n++)
         {
-            tmp16 = *in_common++;
+            tmp16 = in_common[n];
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
             tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
             (*phase) *= phase_inc;
@@ -525,6 +524,11 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     _phase_real = vsubq_f32(tmp32_real.val[0], tmp32_real.val[1]);
                     _phase_imag = vaddq_f32(tmp32_imag.val[0], tmp32_imag.val[1]);
 
+                    vst1q_f32((float32_t*)__phase_real, _phase_real);
+                    vst1q_f32((float32_t*)__phase_imag, _phase_imag);
+
+                    //(*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
+                    printf("neon phase %i: %f,%f\n", number*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
                     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
                             a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index 666650b76..c59a1c0ad 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -46,7 +46,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.001;
+    float phase_step_rad = 0.123;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
@@ -75,7 +75,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.001;
+    float phase_step_rad = 0.123;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];

From 383b9669635ae0c6bf47eba2ef3ee1631681d0f5 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 09:48:23 +0100
Subject: [PATCH 24/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 3d8fa52e9..7e3bc5d93 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -528,7 +528,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     vst1q_f32((float32_t*)__phase_imag, _phase_imag);
 
                     //(*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
-                    printf("neon phase %i: %f,%f\n", number*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
+                    if(n<10 || n >= 8108) printf("neon phase %i: %f,%f\n", (1+number)*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
                     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
                             a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg

From 22bcd0dce414ea582ec160f63f59a6e356505a08 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 09:49:59 +0100
Subject: [PATCH 25/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 7e3bc5d93..1c5b5c1b2 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -528,7 +528,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     vst1q_f32((float32_t*)__phase_imag, _phase_imag);
 
                     //(*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
-                    if(n<10 || n >= 8108) printf("neon phase %i: %f,%f\n", (1+number)*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
+                    if((1+number)*4 <10 || (1+number)*4 >= 8108) printf("neon phase %i: %f,%f\n", (1+number)*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
                     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
                             a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg

From 9e9cb3bb77c0a58359c30fe03fa6e04f0be635e6 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 10:00:03 +0100
Subject: [PATCH 26/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index c59a1c0ad..f53244e09 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -139,9 +139,9 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
     float rem_carrier_phase_in_rad = 0.345;
     float phase_step_rad = 0.123;
     lv_32fc_t phase[1];
-    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), -sin(rem_carrier_phase_in_rad));
+    phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
-    phase_inc[0] = lv_cmake(cos(phase_step_rad), -sin(phase_step_rad));
+    phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
 
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());

From 1e9b4a7b10e623a7e3b91a4d502cd550b0287f9a Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 10:21:51 +0100
Subject: [PATCH 27/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
index f53244e09..b46f00a0f 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h
@@ -46,7 +46,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.1;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
@@ -75,7 +75,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.1;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
@@ -106,7 +106,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.1;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];
@@ -137,7 +137,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
-    float phase_step_rad = 0.123;
+    float phase_step_rad = 0.1;
     lv_32fc_t phase[1];
     phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
     lv_32fc_t phase_inc[1];

From fde7176fc8246e0a152594d1e62009e293dc1349 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 10:34:27 +0100
Subject: [PATCH 28/29] fix

---
 .../volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h  | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
index 1c5b5c1b2..8fcd5599c 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
@@ -43,7 +43,7 @@
 #include <volk_gnsssdr/volk_gnsssdr_complex.h>
 #include <volk_gnsssdr/saturation_arithmetic.h>
 #include <math.h>
-#include <stdio.h>
+//#include <stdio.h>
 
 #ifdef LV_HAVE_GENERIC
 /*!
@@ -66,7 +66,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(lv_16sc
         }
     for (unsigned int n = 0; n < num_points; n++)
         {
-            tmp16 = *in_common++; if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp16 = *in_common++; //if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
             tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
             (*phase) *= phase_inc;
@@ -130,8 +130,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
     __attribute__((aligned(16))) lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
-    printf("a_sse phase %i: %f,%f\n", 0,lv_creal(two_phase_acc[0]),lv_cimag(two_phase_acc[0]));
-    printf("a_sse phase %i: %f,%f\n", 1,lv_creal(two_phase_acc[1]),lv_cimag(two_phase_acc[1]));
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
     __m128 yl, yh, tmp1, tmp2, tmp3;
     lv_16sc_t tmp16;
@@ -232,7 +230,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(lv_16sc_
 
     for(unsigned int n  = sse_iters * 4; n < num_points; n++)
         {
-            tmp16 = in_common[n];  printf("a_sse phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp16 = in_common[n];  //printf("a_sse phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
             tmp16 = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
             (*phase) *= phase_inc;
@@ -527,8 +525,6 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
                     vst1q_f32((float32_t*)__phase_real, _phase_real);
                     vst1q_f32((float32_t*)__phase_imag, _phase_imag);
 
-                    //(*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
-                    if((1+number)*4 <10 || (1+number)*4 >= 8108) printf("neon phase %i: %f,%f\n", (1+number)*4,(float32_t)__phase_real[0],(float32_t)__phase_imag[0]);
                     for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
                             a_val = vld2_s16((int16_t*)&(_in_a[n_vec][number*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
@@ -573,7 +569,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(lv_16sc_t*
 
     for (unsigned int n = neon_iters * 4; n < num_points; n++)
         {
-            tmp16_ = in_common[n];  printf("neon phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp16_ = in_common[n];  //printf("neon phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
             tmp32_ = lv_cmake((float32_t)lv_creal(tmp16_), (float32_t)lv_cimag(tmp16_)) * (*phase);
             tmp16_ = lv_cmake((int16_t)rintf(lv_creal(tmp32_)), (int16_t)rintf(lv_cimag(tmp32_)));
             (*phase) *= phase_inc;

From a17da468f5275d51c67037204a50eb8ee0842a99 Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Fri, 19 Feb 2016 10:41:29 +0100
Subject: [PATCH 29/29] fix

---
 .../libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
index 2f2511d92..97bf1ee97 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h
@@ -59,9 +59,6 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
     volk_gnsssdr_test_params_t test_params_more_iters = volk_gnsssdr_test_params_t(test_params.tol(), test_params.scalar(),
                 test_params.vlen(), 100000, test_params.benchmark_mode(), test_params.kernel_regex());
 
-    volk_gnsssdr_test_params_t test_params_1_iter = volk_gnsssdr_test_params_t(test_params.tol(), test_params.scalar(),
-                   test_params.vlen(), 1, test_params.benchmark_mode(), test_params.kernel_regex());
-
     std::vector<volk_gnsssdr_test_case_t> test_cases = boost::assign::list_of
 
         (VOLK_INIT_TEST(volk_gnsssdr_8i_accumulator_s8i, test_params_more_iters))
@@ -84,7 +81,7 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerpuppet_16ic, volk_gnsssdr_16ic_resampler_16ic, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_16ic_xn, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_dot_prod_16ic_xn, test_params))
-        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_1_iter))
+        (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params))
         ;
 
     return test_cases;