diff --git a/lib/include/srslte/phy/utils/vector.h b/lib/include/srslte/phy/utils/vector.h
index 4a55d18b6..0fadfb334 100644
--- a/lib/include/srslte/phy/utils/vector.h
+++ b/lib/include/srslte/phy/utils/vector.h
@@ -80,8 +80,8 @@ SRSLTE_API void srslte_vec_load_file(char *filename, void *buffer, uint32_t len)
 SRSLTE_API void srslte_vec_sum_ch(uint8_t *x, uint8_t *y, char *z, uint32_t len);
 SRSLTE_API void srslte_vec_sum_fff(float *x, float *y, float *z, uint32_t len);
 SRSLTE_API void srslte_vec_sum_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
-SRSLTE_API void srslte_vec_sub_sss(short *x, short *y, short *z, uint32_t len);
-SRSLTE_API void srslte_vec_sum_sss(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_sub_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len);
+SRSLTE_API void srslte_vec_sum_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len);
 
 /* substract two vectors z=x-y */
 SRSLTE_API void srslte_vec_sub_fff(float *x, float *y, float *z, uint32_t len); 
@@ -91,7 +91,7 @@ SRSLTE_API void srslte_vec_sub_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
 SRSLTE_API void srslte_vec_ema_filter(cf_t *new_data, cf_t *average, cf_t *output, float coeff, uint32_t len); 
 
 /* Square distance */
-SRSLTE_API void srslte_vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints);
+//SRSLTE_API void srslte_vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints);
 
 /* scalar addition */
 SRSLTE_API void srslte_vec_sc_add_fff(float *x, float h, float *z, uint32_t len); 
@@ -132,7 +132,7 @@ SRSLTE_API void srslte_vec_prod_conj_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len
 
 /* real vector product (element-wise) */
 SRSLTE_API void srslte_vec_prod_fff(float *x, float *y, float *z, uint32_t len);
-SRSLTE_API void srslte_vec_prod_sss(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len);
 
 /* Dot-product */
 SRSLTE_API cf_t srslte_vec_dot_prod_cfc(cf_t *x, float *y, uint32_t len);
diff --git a/lib/include/srslte/phy/utils/vector_simd.h b/lib/include/srslte/phy/utils/vector_simd.h
index 1010cbed6..8ea2ce9bc 100644
--- a/lib/include/srslte/phy/utils/vector_simd.h
+++ b/lib/include/srslte/phy/utils/vector_simd.h
@@ -35,47 +35,66 @@ extern "C" {
 #include <stdint.h>
 #include "srslte/config.h"
 
-SRSLTE_API int srslte_vec_dot_prod_sss_sse(short *x, short *y, uint32_t len); 
+#ifdef LV_HAVE_AVX512
+#define SRSLTE_IS_ALIGNED(PTR) (((size_t)(PTR) & 0x3F) == 0)
+#else /* LV_HAVE_AVX512 */
+#ifdef LV_HAVE_AVX
+#define SRSLTE_IS_ALIGNED(PTR) (((size_t)(PTR) & 0x1F) == 0)
+#else /* LV_HAVE_AVX */
+#ifdef LV_HAVE_SSE
+#define SRSLTE_IS_ALIGNED(PTR) (((size_t)(PTR) & 0x0F) == 0)
+#else /* LV_HAVE_SSE */
+#define SRSLTE_IS_ALIGNED(PTR) (true)
+#endif /* LV_HAVE_SSE */
+#endif /* LV_HAVE_AVX */
+#endif /* LV_HAVE_AVX512 */
+
+SRSLTE_API int srslte_vec_dot_prod_sss_simd(int16_t *x, int16_t *y, int len);
+
+SRSLTE_API void srslte_vec_sum_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len);
+
+SRSLTE_API void srslte_vec_sub_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len);
 
-SRSLTE_API int srslte_vec_dot_prod_sss_avx2(short *x, short *y, uint32_t len); 
-
-SRSLTE_API void srslte_vec_sum_sss_sse(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_sub_sss_avx2(short *x, short *y, short *z, uint32_t len);
 
-SRSLTE_API void srslte_vec_sum_sss_avx2(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API cf_t srslte_vec_acc_cc_simd(cf_t *x, int len);
 
-SRSLTE_API void srslte_vec_sub_sss_sse(short *x, short *y, short *z, uint32_t len); 
+SRSLTE_API void srslte_vec_add_fff_simd(float *x, float *y, float *z, int len);
 
-SRSLTE_API void srslte_vec_sub_sss_avx2(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_sub_fff_simd(float *x, float *y, float *z, int len);
 
-SRSLTE_API void srslte_vec_sum_fff_sse(float *x, float *y, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_sc_prod_fff_simd(float *x, float h, float *z, int len);
 
-SRSLTE_API void srslte_vec_sum_fff_avx(float *x, float *y, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_sc_prod_ccc_simd(cf_t *x, cf_t h, cf_t *z, int len);
 
-SRSLTE_API void srslte_vec_sub_fff_sse(float *x, float *y, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_fff_simd(float *x, float *y, float *z, int len);
 
-SRSLTE_API void srslte_vec_sub_fff_avx(float *x, float *y, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_ccc_simd(cf_t *x,cf_t *y, cf_t *z, int len);
 
-SRSLTE_API void srslte_vec_sc_prod_fff_sse(float *x, float h, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_conj_ccc_simd(cf_t *x,cf_t *y, cf_t *z, int len);
 
-SRSLTE_API void srslte_vec_sc_prod_ccc_sse(cf_t *x, cf_t h, cf_t *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_ccc_cf_simd(float *a_re, float *a_im, float *b_re, float *b_im, float *r_re, float *r_im, int len);
 
-SRSLTE_API void srslte_vec_prod_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len);
-
-SRSLTE_API void srslte_vec_prod_sss_sse(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_ccc_c16_simd(int16_t *a_re, int16_t *a_im, int16_t *b_re, int16_t *b_im, int16_t *r_re,
+                                             int16_t *r_im, int len);
 
-SRSLTE_API void srslte_vec_prod_sss_avx2(short *x, short *y, short *z, uint32_t len);
+SRSLTE_API void srslte_vec_prod_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len);
 
-SRSLTE_API cf_t srslte_vec_dot_prod_conj_ccc_sse(cf_t *x, cf_t *y, uint32_t len);
+SRSLTE_API cf_t srslte_vec_dot_prod_conj_ccc_simd(cf_t *x, cf_t *y, int len);
 
-SRSLTE_API void srslte_vec_prod_conj_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len);
+SRSLTE_API cf_t srslte_vec_dot_prod_ccc_simd(cf_t *x, cf_t *y, int len);
 
 SRSLTE_API cf_t srslte_vec_dot_prod_ccc_sse(cf_t *x, cf_t *y, uint32_t len);
 
+SRSLTE_API c16_t srslte_vec_dot_prod_ccc_c16i_simd(c16_t *x, c16_t *y, int len);
+
 SRSLTE_API  void srslte_vec_sc_div2_sss_avx2(short *x, int k, short *z, uint32_t len);
 
-SRSLTE_API void srslte_vec_abs_square_cf_sse(cf_t *x, float *z, uint32_t len);
+SRSLTE_API void srslte_vec_abs_cf_simd(cf_t *x, float *z, int len);
+
+SRSLTE_API void srslte_vec_abs_square_cf_simd(cf_t *x, float *z, int len);
 
-SRSLTE_API void srslte_vec_prod_sss_sse(short *x, short *y, short *z, uint32_t len); 
+SRSLTE_API void srslte_vec_prod_sss_sse(short *x, short *y, short *z, uint32_t len);
 
 SRSLTE_API void srslte_vec_prod_sss_avx(short *x, short *y, short *z, uint32_t len);
 
@@ -93,7 +112,9 @@ SRSLTE_API void srslte_vec_lut_sss_sse(short *x, unsigned short *lut, short *y,
 
 SRSLTE_API void srslte_vec_convert_fi_sse(float *x, int16_t *z, float scale, uint32_t len);
 
-SRSLTE_API void srslte_vec_sc_prod_cfc_avx(const cf_t *x,const float h,cf_t *y,const uint32_t len);
+SRSLTE_API void srslte_vec_sc_prod_cfc_simd(const cf_t *x,const float h,cf_t *y,const int len);
+
+SRSLTE_API void srslte_vec_cp_simd(cf_t *src, cf_t *dst, int len);
 
 #ifdef __cplusplus
 }
diff --git a/lib/src/phy/utils/test/CMakeLists.txt b/lib/src/phy/utils/test/CMakeLists.txt
index 4dccbf2a0..76df7ac59 100644
--- a/lib/src/phy/utils/test/CMakeLists.txt
+++ b/lib/src/phy/utils/test/CMakeLists.txt
@@ -42,3 +42,6 @@ target_link_libraries(algebra_test srslte_phy)
 
 add_test(algebra_2x2_zf_solver_test algebra_test -z)
 add_test(algebra_2x2_mmse_solver_test algebra_test -m)
+
+add_executable(vector_test vector_test.c)
+target_link_libraries(vector_test srslte_phy)
\ No newline at end of file
diff --git a/lib/src/phy/utils/test/vector_test.c b/lib/src/phy/utils/test/vector_test.c
new file mode 100644
index 000000000..e781d05b9
--- /dev/null
+++ b/lib/src/phy/utils/test/vector_test.c
@@ -0,0 +1,555 @@
+/**
+ *
+ * \section COPYRIGHT
+ *
+ * Copyright 2013-2015 Software Radio Systems Limited
+ *
+ * \section LICENSE
+ *
+ * This file is part of the srsLTE library.
+ *
+ * srsLTE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * srsLTE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * A copy of the GNU Affero General Public License can be found in
+ * the LICENSE file in the top-level directory of this distribution
+ * and at http://www.gnu.org/licenses/.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <complex.h>
+#include <stdbool.h>
+#include <immintrin.h>
+#include <sys/time.h>
+#include <srslte/phy/utils/vector_simd.h>
+#include <memory.h>
+#include <math.h>
+
+#include "srslte/phy/utils/mat.h"
+#include "srslte/phy/utils/simd.h"
+#include "srslte/phy/utils/vector.h"
+
+
+bool zf_solver = false;
+bool mmse_solver = false;
+bool verbose = false;
+
+#define MAX_MSE (1e-3)
+#define NOF_REPETITIONS (1024*128)
+#define MAX_FUNCTIONS (64)
+#define MAX_BLOCKS (16)
+
+#define RANDOM_F() ((float)rand())/((float)RAND_MAX)
+#define RANDOM_S() ((int16_t)(rand() && 0x800F))
+#define RANDOM_CF() (RANDOM_F() + _Complex_I*RANDOM_F())
+
+#define TEST_CALL(TEST_CODE)   gettimeofday(&start, NULL);\
+  for (int i = 0; i < NOF_REPETITIONS; i++){TEST_CODE;}\
+  gettimeofday(&end, NULL); \
+  *timing = elapsed_us(&start, &end);
+
+#define TEST(X, CODE) static bool test_##X (char *func_name, double *timing, uint32_t block_size) {\
+    struct timeval start, end;\
+    float mse = 0.0f;\
+    bool passed;\
+    strncpy(func_name, #X, 32);\
+    CODE;\
+    passed = (mse < MAX_MSE);\
+    printf("%32s (%5d) ... %7.1f MSamp/s ... %3s Passed\n", func_name, block_size, \
+    (double) block_size*NOF_REPETITIONS/ *timing, passed?"":"Not");\
+    return passed;\
+}
+
+#define MALLOC(TYPE, NAME) TYPE *NAME = srslte_vec_malloc(sizeof(TYPE)*block_size)
+
+
+static double elapsed_us(struct timeval *ts_start, struct timeval *ts_end) {
+  if (ts_end->tv_usec > ts_start->tv_usec) {
+    return ((double) ts_end->tv_sec - (double) ts_start->tv_sec) * 1000000 +
+           (double) ts_end->tv_usec - (double) ts_start->tv_usec;
+  } else {
+    return ((double) ts_end->tv_sec - (double) ts_start->tv_sec - 1) * 1000000 +
+           ((double) ts_end->tv_usec + 1000000) - (double) ts_start->tv_usec;
+  }
+}
+
+float squared_error (cf_t a, cf_t b) {
+  float diff_re = __real__ a - __real__ b;
+  float diff_im = __imag__ a - __imag__ b;
+  return diff_re*diff_re + diff_im*diff_im;
+}
+
+TEST(srslte_vec_dot_prod_sss,
+     MALLOC(int16_t, x);
+         MALLOC(int16_t, y);
+         int16_t z;
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_S();
+           y[i] = RANDOM_S();
+         }
+
+         TEST_CALL(z = srslte_vec_dot_prod_sss(x, y, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold += x[i] * y[i];
+         }
+
+         mse += cabsf(gold - z) / cabsf(gold);
+
+         free(x);
+         free(y);
+)
+
+TEST(srslte_vec_sum_sss,
+     MALLOC(int16_t, x);
+         MALLOC(int16_t, y);
+         MALLOC(int16_t, z);
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_S();
+           y[i] = RANDOM_S();
+         }
+
+         TEST_CALL(srslte_vec_sum_sss(x, y, z, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold = x[i] + y[i];
+           mse += cabsf(gold - z[i]);
+         }
+
+         free(x);
+         free(y);
+         free(z);
+)
+
+TEST(srslte_vec_sub_sss,
+     MALLOC(int16_t, x);
+         MALLOC(int16_t, y);
+         MALLOC(int16_t, z);
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_S();
+           y[i] = RANDOM_S();
+         }
+
+         TEST_CALL(srslte_vec_sub_sss(x, y, z, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold = x[i] - y[i];
+           mse += cabsf(gold - z[i]);
+         }
+
+         free(x);
+         free(y);
+         free(z);
+)
+
+TEST(srslte_vec_prod_sss,
+     MALLOC(int16_t, x);
+         MALLOC(int16_t, y);
+         MALLOC(int16_t, z);
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_S();
+           y[i] = RANDOM_S();
+         }
+
+         TEST_CALL(srslte_vec_prod_sss(x, y, z, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold = x[i] * y[i];
+           mse += cabsf(gold - z[i]);
+         }
+
+         free(x);
+         free(y);
+         free(z);
+)
+
+TEST(srslte_vec_acc_cc,
+     MALLOC(cf_t, x);
+         cf_t z;
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_F();
+         }
+
+         TEST_CALL(z = srslte_vec_acc_cc(x, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold += x[i];
+         }
+
+         mse += cabsf(gold - z)/cabsf(gold);
+
+         free(x);
+)
+
+
+TEST(srslte_vec_sum_fff,
+     MALLOC(float, x);
+         MALLOC(float, y);
+         MALLOC(float, z);
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+         x[i] = RANDOM_F();
+         y[i] = RANDOM_F();
+     }
+
+         TEST_CALL(srslte_vec_sum_fff(x, y, z, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+         gold = x[i] + y[i];
+         mse += cabsf(gold - z[i]);
+     }
+
+         free(x);
+         free(y);
+)
+
+TEST(srslte_vec_sub_fff,
+     MALLOC(float, x);
+         MALLOC(float, y);
+         MALLOC(float, z);
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+         x[i] = RANDOM_F();
+         y[i] = RANDOM_F();
+     }
+
+         TEST_CALL(srslte_vec_sub_fff(x, y, z, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+         gold = x[i] - y[i];
+         mse += cabsf(gold - z[i]);
+     }
+
+         free(x);
+         free(y);
+)
+
+TEST(srslte_vec_dot_prod_ccc,
+     MALLOC(cf_t, x);
+         MALLOC(cf_t, y);
+         cf_t z;
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_CF();
+           y[i] = RANDOM_CF();
+         }
+
+         TEST_CALL(z = srslte_vec_dot_prod_ccc(x, y, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold += x[i] * y[i];
+         }
+
+         mse = cabsf(gold - z) / cabsf(gold);
+
+         free(x);
+         free(y);
+)
+
+TEST(srslte_vec_dot_prod_conj_ccc,
+     MALLOC(cf_t, x);
+         MALLOC(cf_t, y);
+         cf_t z;
+
+         cf_t gold = 0.0f;
+         for (int i = 0; i < block_size; i++) {
+           x[i] = RANDOM_CF();
+           y[i] = RANDOM_CF();
+         }
+
+         TEST_CALL(z = srslte_vec_dot_prod_conj_ccc(x, y, block_size))
+
+         for (int i = 0; i < block_size; i++) {
+           gold += x[i] * conjf(y[i]);
+         }
+
+         mse = cabsf(gold - z) / cabsf(gold);
+
+         free(x);
+         free(y);
+)
+
+TEST(srslte_vec_prod_ccc,
+  MALLOC(cf_t, x);
+  MALLOC(cf_t, y);
+  MALLOC(cf_t, z);
+
+  cf_t gold;
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+    y[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_prod_ccc(x, y, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * y[i];
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_prod_conj_ccc,
+  MALLOC(cf_t, x);
+  MALLOC(cf_t, y);
+  MALLOC(cf_t, z);
+
+  cf_t gold;
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+    y[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_prod_conj_ccc(x, y, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * conjf(y[i]);
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_sc_prod_ccc,
+  MALLOC(cf_t, x);
+  MALLOC(cf_t, z);
+  cf_t y = RANDOM_F();
+
+  cf_t gold;
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_sc_prod_ccc(x, y, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * y;
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_prod_fff,
+  MALLOC(float, x);
+  MALLOC(float, y);
+  MALLOC(float, z);
+
+  cf_t gold;
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+    y[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_prod_fff(x, y, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * y[i];
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_sc_prod_fff,
+  MALLOC(float, x);
+  MALLOC(float, z);
+  float y = RANDOM_F();
+
+  float gold;
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_sc_prod_fff(x, y, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * y;
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_abs_cf,
+  MALLOC(cf_t, x);
+  MALLOC(float, z);
+  float gold;
+
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_abs_cf(x, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = sqrtf(crealf(x[i]) * crealf(x[i]) + cimagf(x[i])*cimagf(x[i]));
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_abs_square_cf,
+  MALLOC(cf_t, x);
+  MALLOC(float, z);
+  float gold;
+
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_abs_square_cf(x, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = crealf(x[i]) * crealf(x[i]) + cimagf(x[i])*cimagf(x[i]);
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+TEST(srslte_vec_sc_prod_cfc,
+  MALLOC(cf_t, x);
+  MALLOC(cf_t, z);
+  cf_t gold;
+  float h = RANDOM_F();
+
+  for (int i = 0; i < block_size; i++) {
+    x[i] = RANDOM_CF();
+  }
+
+  TEST_CALL(srslte_vec_sc_prod_cfc(x, h, z, block_size))
+
+  for (int i = 0; i < block_size; i++) {
+    gold = x[i] * h;
+    mse += cabsf(gold - z[i]);
+  }
+
+  free(x);
+  free(z);
+)
+
+int main(int argc, char **argv) {
+  char func_names[MAX_FUNCTIONS][32];
+  double timmings[MAX_FUNCTIONS][MAX_BLOCKS];
+  uint32_t sizes[32];
+  uint32_t size_count = 0;
+  uint32_t func_count = 0;
+  bool passed = true;
+
+  for (uint32_t block_size = 1; block_size <= 1024*16; block_size *= 2) {
+    func_count = 0;
+
+    passed &= test_srslte_vec_dot_prod_sss(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sum_sss(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sub_sss(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_prod_sss(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_acc_cc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sum_fff(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sub_fff(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_dot_prod_ccc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_dot_prod_conj_ccc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_prod_fff(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_prod_ccc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_prod_conj_ccc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sc_prod_ccc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sc_prod_fff(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_abs_cf(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_abs_square_cf(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    passed &= test_srslte_vec_sc_prod_cfc(func_names[func_count], &timmings[func_count][size_count], block_size);
+    func_count++;
+
+    sizes[size_count] = block_size;
+    size_count++;
+  }
+
+  printf("\n");
+  printf("%32s |", "Subroutine/MSps");
+  for (int i = 0; i < size_count; i++) {
+    printf(" %7d", sizes[i]);
+  }
+  printf("  |\n");
+
+  for (int j = 0; j < 32; j++) {
+    printf("-");
+  }
+  printf("-+-");
+  for (int j = 0; j < size_count; j++) {
+    printf("--------");
+  }
+  printf("-|\n");
+
+  for (int i = 0; i < func_count; i++) {
+    printf("%32s | ", func_names[i]);
+    for (int j = 0; j < size_count; j++) {
+      printf(" %7.1f", (double) NOF_REPETITIONS*(double)sizes[j]/timmings[i][j]);
+    }
+    printf(" |\n");
+  }
+
+  return (passed)?SRSLTE_SUCCESS:SRSLTE_ERROR;
+}
diff --git a/lib/src/phy/utils/vector.c b/lib/src/phy/utils/vector.c
index 917810e92..cb21f24f1 100644
--- a/lib/src/phy/utils/vector.c
+++ b/lib/src/phy/utils/vector.c
@@ -36,25 +36,6 @@
 #include "srslte/phy/utils/bit.h"
 
 
-#ifdef LV_HAVE_SSE
-#include <smmintrin.h>
-#endif
-
-#ifdef LV_HAVE_AVX
-#include <immintrin.h>
-#endif
-
-
-#ifdef HAVE_VOLK
-#include "volk/volk.h"
-#endif
-
-#ifdef DEBUG_MODE
-#warning FIXME: Disabling SSE/AVX vector code
-#undef LV_HAVE_SSE
-#undef LV_HAVE_AVX
-#endif
-
 
 int srslte_vec_acc_ii(int *x, uint32_t len) {
   int i;
@@ -88,51 +69,25 @@ void srslte_vec_ema_filter(cf_t *new_data, cf_t *average, cf_t *output, float co
 }
 
 cf_t srslte_vec_acc_cc(cf_t *x, uint32_t len) {
-  int i;
-  cf_t z=0;
-  for (i=0;i<len;i++) {
-    z+=x[i];
-  }
-  return z;
+  return srslte_vec_acc_cc_simd(x, len);
 }
 
-void srslte_vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints) {
+#warning Remove function if not used!
+/*void srslte_vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints) {
   uint32_t i;
   cf_t diff; 
   for (i=0;i<npoints;i++) {
     diff = symbol - points[i];
     distance[i] = crealf(diff) * crealf(diff) + cimagf(diff) * cimagf(diff);
   }
-}
+}*/
 
 void srslte_vec_sub_fff(float *x, float *y, float *z, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]-y[i];
-  }
-#else
-#ifdef LV_HAVE_AVX
-  srslte_vec_sub_fff_avx(x, y, z, len);
-#else
-  srslte_vec_sub_fff_sse(x, y, z, len);
-#endif
-#endif
+  srslte_vec_sub_fff_simd(x, y, z, len);
 }
 
-void srslte_vec_sub_sss(short *x, short *y, short *z, uint32_t len) {
-#ifdef LV_HAVE_AVX2
-  srslte_vec_sub_sss_avx2(x, y, z, len);
-#else
-#ifdef LV_HAVE_SSE
-  srslte_vec_sub_sss_sse(x, y, z, len);
-#else
-    int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]-y[i];
-  }
-#endif
-#endif
+void srslte_vec_sub_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len) {
+  srslte_vec_sub_sss_simd(x, y, z, len);
 }
 
 // Noise estimation in chest_dl, interpolation 
@@ -142,33 +97,11 @@ void srslte_vec_sub_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len) {
 
 // Used in PSS/SSS and sum_ccc
 void srslte_vec_sum_fff(float *x, float *y, float *z, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]+y[i];
-  }
-#else
-  #ifdef LV_HAVE_AVX
-    srslte_vec_sum_fff_avx(x, y, z, len);
-  #else
-    srslte_vec_sum_fff_sse(x, y, z, len);
-  #endif
-#endif
+  srslte_vec_add_fff_simd(x, y, z, len);
 }
 
-void srslte_vec_sum_sss(short *x, short *y, short *z, uint32_t len) {
-#ifdef LV_HAVE_AVX2
-  srslte_vec_sum_sss_avx2(x, y, z, len);
-#else
-#ifdef LV_HAVE_SSE
-  srslte_vec_sum_sss_sse(x, y, z, len);
-#else
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]+y[i];
-  }
-#endif
-#endif
+void srslte_vec_sum_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len) {
+  srslte_vec_sum_sss_simd(x, y, z, len);
 }
 
 void srslte_vec_sum_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len) {
@@ -197,7 +130,7 @@ void srslte_vec_sc_add_cfc(cf_t *x, float h, cf_t *z, uint32_t len) {
 }
 
 void srslte_vec_sc_add_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len) {
-  int i; 
+  int i;
   for (i=0;i<len;i++) {
     z[i] = x[i]+ h;
   }
@@ -211,14 +144,7 @@ void srslte_vec_sc_add_sss(int16_t *x, int16_t h, int16_t *z, uint32_t len) {
 }
 // PSS, PBCH, DEMOD, FFTW, etc. 
 void srslte_vec_sc_prod_fff(float *x, float h, float *z, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*h;
-  }
-#else
-  srslte_vec_sc_prod_fff_sse(x, h, z, len);
-#endif
+  srslte_vec_sc_prod_fff_simd(x, h, z, len);
 }
 
 void srslte_vec_sc_prod_sfs(short *x, float h, short *z, uint32_t len) {
@@ -228,7 +154,8 @@ void srslte_vec_sc_prod_sfs(short *x, float h, short *z, uint32_t len) {
   }
 }
 
-void srslte_vec_sc_div2_sss(short *x, int n_rightshift, short *z, uint32_t len) {
+#warning remove function if it is not used
+/*void srslte_vec_sc_div2_sss(short *x, int n_rightshift, short *z, uint32_t len) {
 #ifdef LV_HAVE_AVX2
   srslte_vec_sc_div2_sss_avx2(x, n_rightshift, z, len);
 #else
@@ -242,7 +169,7 @@ void srslte_vec_sc_div2_sss(short *x, int n_rightshift, short *z, uint32_t len)
   }
 #endif
 #endif
-}
+}*/
 
 // TODO: Improve this implementation
 void srslte_vec_norm_cfc(cf_t *x, float amplitude, cf_t *y, uint32_t len) {
@@ -257,14 +184,7 @@ void srslte_vec_norm_cfc(cf_t *x, float amplitude, cf_t *y, uint32_t len) {
 
 // Used throughout 
 void srslte_vec_sc_prod_cfc(cf_t *x, float h, cf_t *z, uint32_t len) { 
-#ifdef LV_HAVE_AVX
-  srslte_vec_sc_prod_cfc_avx(x,h,z,len);
-#else
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*h;
-  }
-#endif
+  srslte_vec_sc_prod_cfc_simd(x,h,z,len);
 }
 
 
@@ -276,7 +196,7 @@ void srslte_vec_sc_prod_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len) {
     z[i] = x[i]*h;
   }
 #else
-  srslte_vec_sc_prod_ccc_sse(x,h,z,len);
+  srslte_vec_sc_prod_ccc_simd(x,h,z,len);
 #endif
 }
 
@@ -360,7 +280,7 @@ void srslte_vec_deinterleave_real_cf(cf_t *x, float *real, uint32_t len) {
  */
 void *srslte_vec_malloc(uint32_t size) {
   void *ptr;
-  if (posix_memalign(&ptr,256,size)) {
+  if (posix_memalign(&ptr,512,size)) {
     return NULL;
   } else {
     return ptr;
@@ -511,50 +431,22 @@ void srslte_vec_prod_cfc(cf_t *x, float *y, cf_t *z, uint32_t len) {
 
 // Used in scrambling float
 void srslte_vec_prod_fff(float *x, float *y, float *z, uint32_t len) {
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*y[i];
-  }
+  srslte_vec_prod_fff_simd(x, y, z, len);
 }
 
 // Scrambling Short
-void srslte_vec_prod_sss(short *x, short *y, short *z, uint32_t len) {
-#ifdef LV_HAVE_AVX2
-  srslte_vec_prod_sss_avx2(x,y,z,len);
-#else
-#ifdef LV_HAVE_SSE
-  srslte_vec_prod_sss_sse(x,y,z,len);
-#else
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*y[i];
-  }
-#endif
-#endif
+void srslte_vec_prod_sss(int16_t *x, int16_t *y, int16_t *z, uint32_t len) {
+  srslte_vec_prod_sss_simd(x,y,z,len);
 }
 
 // CFO and OFDM processing
 void srslte_vec_prod_ccc(cf_t *x,cf_t *y, cf_t *z, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*y[i];
-  }
-#else
-  srslte_vec_prod_ccc_sse(x,y,z,len);
-#endif
+  srslte_vec_prod_ccc_simd(x,y,z,len);
 }
 
 // PRACH, CHEST UL, etc. 
 void srslte_vec_prod_conj_ccc(cf_t *x,cf_t *y, cf_t *z, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    z[i] = x[i]*conjf(y[i]);
-  }
-#else
-  srslte_vec_prod_conj_ccc_sse(x,y,z,len);
-#endif
+  srslte_vec_prod_conj_ccc_simd(x,y,z,len);
 }
 
 //#define DIV_USE_VEC
@@ -598,16 +490,7 @@ void srslte_vec_div_fff(float *x, float *y, float *z, uint32_t len) {
 
 // PSS. convolution 
 cf_t srslte_vec_dot_prod_ccc(cf_t *x, cf_t *y, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  uint32_t i;
-  cf_t res = 0;
-  for (i=0;i<len;i++) {
-    res += x[i]*y[i];
-  }
-  return res;
-#else
-  return srslte_vec_dot_prod_ccc_sse(x, y, len);
-#endif
+  return srslte_vec_dot_prod_ccc_simd(x, y, len);
 }
 
 // Convolution filter and in SSS search 
@@ -622,17 +505,7 @@ cf_t srslte_vec_dot_prod_cfc(cf_t *x, float *y, uint32_t len) {
 
 // SYNC 
 cf_t srslte_vec_dot_prod_conj_ccc(cf_t *x, cf_t *y, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  uint32_t i;
-  cf_t res = 0;
-  for (i=0;i<len;i++) {
-    res += x[i]*conjf(y[i]);
-  }
-  return res;
-#else
-  return srslte_vec_dot_prod_conj_ccc_sse(x, y, len);
-#endif
-  
+  return srslte_vec_dot_prod_conj_ccc_simd(x, y, len);
 }
 
 // PHICH 
@@ -646,20 +519,7 @@ float srslte_vec_dot_prod_fff(float *x, float *y, uint32_t len) {
 }
 
 int32_t srslte_vec_dot_prod_sss(int16_t *x, int16_t *y, uint32_t len) {
-#ifdef LV_HAVE_AVX2
-  return srslte_vec_dot_prod_sss_avx2(x, y, len);
-#else
-#ifdef LV_HAVE_SSE
-  return srslte_vec_dot_prod_sss_sse(x, y, len);
-#else
-  uint32_t i;
-  int32_t res = 0;
-  for (i=0;i<len;i++) {
-    res += x[i]*y[i];
-  }
-  return res;
-#endif
-#endif
+  return srslte_vec_dot_prod_sss_simd(x, y, len);
 }
 
 float srslte_vec_avg_power_cf(cf_t *x, uint32_t len) {
@@ -672,27 +532,17 @@ float srslte_vec_corr_ccc(cf_t *x, cf_t *y, uint32_t len) {
   float s_x = crealf(srslte_vec_dot_prod_conj_ccc(x, x, len))/len;
   float s_y = crealf(srslte_vec_dot_prod_conj_ccc(y, y, len))/len;
   float cov = crealf(srslte_vec_dot_prod_conj_ccc(x, y, len))/len;
-  return cov/(sqrt(s_x*s_y));
+  return cov/(sqrtf(s_x*s_y));
 }
 
 // PSS (disabled and using abs_square )
 void srslte_vec_abs_cf(cf_t *x, float *abs, uint32_t len) {
-  int i;
-  for (i=0;i<len;i++) {
-    abs[i] = cabsf(x[i]);
-  }
+  srslte_vec_abs_cf_simd(x, abs, len);
 }
 
 // PRACH 
 void srslte_vec_abs_square_cf(cf_t *x, float *abs_square, uint32_t len) {
-#ifndef LV_HAVE_SSE
-  int i;
-  for (i=0;i<len;i++) {
-    abs_square[i] = crealf(x[i])*crealf(x[i])+cimagf(x[i])*cimagf(x[i]);
-  }
-#else
-  srslte_vec_abs_square_cf_sse(x,abs_square,len);
-#endif
+  srslte_vec_abs_square_cf_simd(x,abs_square,len);
 }
 
 
@@ -821,23 +671,5 @@ void srslte_vec_quant_suc(int16_t *in, uint8_t *out, float gain, int16_t offset,
 }
 
 void srs_vec_cf_cpy(cf_t *dst, cf_t *src, int len) {
-  int i = 0;
-
-#ifdef LV_HAVE_AVX
-    for (; i < len - 3; i += 4) {
-      _mm256_store_ps((float *) &dst[i], _mm256_load_ps((float *) &src[i]));
-    }
-#endif /* LV_HAVE_AVX */
-#ifdef LV_HAVE_SSE
-    for (; i < len - 1; i += 2) {
-      _mm_store_ps((float *) &dst[i], _mm_load_ps((float *) &src[i]));
-    }
-  for (; i < len; i++) {
-    ((__m64*) dst)[i] = ((__m64*) src)[i];
-  }
-#else
-  for (; i < len; i++) {
-    dst[i] = src[i];
-  }
-#endif /* LV_HAVE_SSE */
+  srslte_vec_cp_simd(dst, src, len);
 }
diff --git a/lib/src/phy/utils/vector_simd.c b/lib/src/phy/utils/vector_simd.c
index d38373d80..21132390f 100644
--- a/lib/src/phy/utils/vector_simd.c
+++ b/lib/src/phy/utils/vector_simd.c
@@ -25,310 +25,148 @@
  */
 
 
-#include <float.h>
 #include <complex.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
-
-#include "srslte/phy/utils/vector_simd.h"
-
 #include <inttypes.h>
 #include <stdio.h>
 
-#ifdef LV_HAVE_SSE
-#include <smmintrin.h>
-#endif
-
-#ifdef LV_HAVE_AVX
-#include <immintrin.h>
-#endif
-
-
-int srslte_vec_dot_prod_sss_sse(short *x, short *y, uint32_t len)
-{
-  int result = 0; 
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 8;
+#include <srslte/config.h>
+#include "srslte/phy/utils/vector_simd.h"
+#include "srslte/phy/utils/simd.h"
 
-  const __m128i* xPtr = (const __m128i*) x;
-  const __m128i* yPtr = (const __m128i*) y;
-  
-  __m128i dotProdVal = _mm_setzero_si128();
 
-  __m128i xVal, yVal, zVal;
-  for(;number < points; number++){
+int srslte_vec_dot_prod_sss_simd(int16_t *x, int16_t *y, int len) {
+  int i = 0;
+  int result = 0;
+#if SRSLTE_SIMD_S_SIZE
+  simd_s_t simd_dotProdVal = srslte_simd_s_zero();
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y)) {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_load(&x[i]);
+      simd_s_t b = srslte_simd_s_load(&y[i]);
 
-    xVal = _mm_load_si128(xPtr);
-    yVal = _mm_loadu_si128(yPtr);
+      simd_s_t z = srslte_simd_s_mul(a, b);
 
-    zVal = _mm_mullo_epi16(xVal, yVal);
+      simd_dotProdVal = srslte_simd_s_add(simd_dotProdVal, z);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_loadu(&x[i]);
+      simd_s_t b = srslte_simd_s_loadu(&y[i]);
 
-    dotProdVal = _mm_add_epi16(dotProdVal, zVal);
+      simd_s_t z = srslte_simd_s_mul(a, b);
 
-    xPtr ++;
-    yPtr ++;
+      simd_dotProdVal = srslte_simd_s_add(simd_dotProdVal, z);
+    }
   }
-  
-  short dotProdVector[8];
-  _mm_store_si128((__m128i*) dotProdVector, dotProdVal);
-  for (int i=0;i<8;i++) {
-    result += dotProdVector[i]; 
+  __attribute__ ((aligned (SRSLTE_SIMD_S_SIZE*2))) short dotProdVector[SRSLTE_SIMD_S_SIZE];
+  srslte_simd_s_store(dotProdVector, simd_dotProdVal);
+  for (int k = 0; k < SRSLTE_SIMD_S_SIZE; k++) {
+    result += dotProdVector[k];
   }
+#endif /* SRSLTE_SIMD_S_SIZE */
 
-  number = points * 8;
-  for(;number < len; number++){
-    result += (x[number] * y[number]);
+  for(; i < len; i++){
+    result += (x[i] * y[i]);
   }
-  
-#endif
-  return result; 
-}
 
-
-int srslte_vec_dot_prod_sss_avx2(short *x, short *y, uint32_t len)
-{
-  int result = 0; 
-#ifdef LV_HAVE_AVX2
-  unsigned int number = 0;
-  const unsigned int points = len / 16;
-
-  const __m256i* xPtr = (const __m256i*) x;
-  const __m256i* yPtr = (const __m256i*) y;
-  
-  __m256i dotProdVal = _mm256_setzero_si256();
-
-  __m256i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm256_load_si256(xPtr);
-    yVal = _mm256_loadu_si256(yPtr);
-    zVal = _mm256_mullo_epi16(xVal, yVal);
-    dotProdVal = _mm256_add_epi16(dotProdVal, zVal);
-    xPtr ++;
-    yPtr ++;
-  }
-  
-  __attribute__ ((aligned (256))) short dotProdVector[16];
-  _mm256_store_si256((__m256i*) dotProdVector, dotProdVal);
-  for (int i=0;i<16;i++) {
-    result += dotProdVector[i]; 
-  }
-
-  number = points * 16;
-  for(;number < len; number++){
-    result += (x[number] * y[number]);
-  }
-  
-#endif
   return result; 
 }
 
+void srslte_vec_sum_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len) {
+  int i = 0;
+#ifdef SRSLTE_SIMD_S_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_load(&x[i]);
+      simd_s_t b = srslte_simd_s_load(&y[i]);
 
+      simd_s_t r = srslte_simd_s_add(a, b);
 
-void srslte_vec_sum_sss_sse(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 8;
-
-  const __m128i* xPtr = (const __m128i*) x;
-  const __m128i* yPtr = (const __m128i*) y;
-  __m128i* zPtr = (__m128i*) z;
-
-  __m128i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm_load_si128(xPtr);
-    yVal = _mm_load_si128(yPtr);
-
-    zVal = _mm_add_epi16(xVal, yVal);
-
-    _mm_store_si128(zPtr, zVal); 
-
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
-  }
-
-  number = points * 8;
-  for(;number < len; number++){
-    z[number] = x[number] + y[number];
-  }
-#endif
-
-}
-
-void srslte_vec_sum_sss_avx2(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_AVX2
-  unsigned int number = 0;
-  const unsigned int points = len / 16;
-
-  const __m256i* xPtr = (const __m256i*) x;
-  const __m256i* yPtr = (const __m256i*) y;
-  __m256i* zPtr = (__m256i*) z;
-
-  __m256i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm256_load_si256(xPtr);
-    yVal = _mm256_loadu_si256(yPtr);
-
-    zVal = _mm256_add_epi16(xVal, yVal);
-    _mm256_store_si256(zPtr, zVal); 
-
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
-  }
-
-  number = points * 16;
-  for(;number < len; number++){
-    z[number] = x[number] + y[number];
-  }
-#endif
-
-}
-
-
-void srslte_vec_sub_sss_sse(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 8;
-
-  const __m128i* xPtr = (const __m128i*) x;
-  const __m128i* yPtr = (const __m128i*) y;
-  __m128i* zPtr = (__m128i*) z;
-
-  __m128i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm_load_si128(xPtr);
-    yVal = _mm_load_si128(yPtr);
-
-    zVal = _mm_sub_epi16(xVal, yVal);
-
-    _mm_store_si128(zPtr, zVal);
-
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
-  }
-
-  number = points * 8;
-  for(;number < len; number++){
-    z[number] = x[number] - y[number];
-  }
-#endif
-}
-
-void srslte_vec_sub_sss_avx2(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_AVX2
-  unsigned int number = 0;
-  const unsigned int points = len / 16;
-
-  const __m256i* xPtr = (const __m256i*) x;
-  const __m256i* yPtr = (const __m256i*) y;
-  __m256i* zPtr = (__m256i*) z;
-
-  __m256i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm256_load_si256(xPtr);
-    yVal = _mm256_loadu_si256(yPtr);
-
-    zVal = _mm256_sub_epi16(xVal, yVal);
+      srslte_simd_s_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_loadu(&x[i]);
+      simd_s_t b = srslte_simd_s_loadu(&y[i]);
 
-    _mm256_store_si256(zPtr, zVal); 
+      simd_s_t r = srslte_simd_s_add(a, b);
 
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
+      srslte_simd_s_storeu(&z[i], r);
+    }
   }
+#endif /* SRSLTE_SIMD_S_SIZE */
 
-  number = points * 16;
-  for(;number < len; number++){
-    z[number] = x[number] - y[number];
+  for(; i < len; i++){
+    z[i] = x[i] + y[i];
   }
-  #endif
 }
 
+void srslte_vec_sub_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len) {
+  int i = 0;
+#ifdef SRSLTE_SIMD_S_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_load(&x[i]);
+      simd_s_t b = srslte_simd_s_load(&y[i]);
 
+      simd_s_t r = srslte_simd_s_sub(a, b);
 
+      srslte_simd_s_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_loadu(&x[i]);
+      simd_s_t b = srslte_simd_s_loadu(&y[i]);
 
-void srslte_vec_prod_sss_sse(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 8;
-
-  const __m128i* xPtr = (const __m128i*) x;
-  const __m128i* yPtr = (const __m128i*) y;
-  __m128i* zPtr = (__m128i*) z;
-
-  __m128i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm_load_si128(xPtr);
-    yVal = _mm_load_si128(yPtr);
-
-    zVal = _mm_mullo_epi16(xVal, yVal);
-
-    _mm_store_si128(zPtr, zVal);
+      simd_s_t r = srslte_simd_s_sub(a, b);
 
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
+      srslte_simd_s_storeu(&z[i], r);
+    }
   }
+#endif /* SRSLTE_SIMD_S_SIZE */
 
-  number = points * 8;
-  for(;number < len; number++){
-    z[number] = x[number] * y[number];
+  for(; i < len; i++){
+    z[i] = x[i] - y[i];
   }
-#endif
 }
 
-void srslte_vec_prod_sss_avx2(short *x, short *y, short *z, uint32_t len)
-{
-#ifdef LV_HAVE_AVX2
-  unsigned int number = 0;
-  const unsigned int points = len / 16;
-
-  const __m256i* xPtr = (const __m256i*) x;
-  const __m256i* yPtr = (const __m256i*) y;
-  __m256i* zPtr = (__m256i*) z;
+void srslte_vec_prod_sss_simd(int16_t *x, int16_t *y, int16_t *z, int len) {
+  int i = 0;
+#ifdef SRSLTE_SIMD_S_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_load(&x[i]);
+      simd_s_t b = srslte_simd_s_load(&y[i]);
 
-  __m256i xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm256_loadu_si256(xPtr);
-    yVal = _mm256_loadu_si256(yPtr);
+      simd_s_t r = srslte_simd_s_mul(a, b);
 
-    zVal = _mm256_mullo_epi16(xVal, yVal);
+      srslte_simd_s_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_S_SIZE + 1; i += SRSLTE_SIMD_S_SIZE) {
+      simd_s_t a = srslte_simd_s_loadu(&x[i]);
+      simd_s_t b = srslte_simd_s_loadu(&y[i]);
 
-    _mm256_storeu_si256(zPtr, zVal); 
+      simd_s_t r = srslte_simd_s_mul(a, b);
 
-    xPtr ++;
-    yPtr ++;
-    zPtr ++;
+      srslte_simd_s_storeu(&z[i], r);
+    }
   }
+#endif /* SRSLTE_SIMD_S_SIZE */
 
-  number = points * 16;
-  for(;number < len; number++){
-    z[number] = x[number] * y[number];
+  for(; i < len; i++){
+    z[i] = x[i] * y[i];
   }
-#endif
 }
 
 
 
 
-
-
+#warning remove function if it is not used
+/*
 void srslte_vec_sc_div2_sss_sse(short *x, int k, short *z, uint32_t len)
 {
 #ifdef LV_HAVE_SSE
@@ -357,8 +195,10 @@ void srslte_vec_sc_div2_sss_sse(short *x, int k, short *z, uint32_t len)
     z[number] = x[number] / divn;
   }
 #endif
-}
+}*/
 
+#warning remove function if it is not used
+/*
 void srslte_vec_sc_div2_sss_avx2(short *x, int k, short *z, uint32_t len)
 {
 #ifdef LV_HAVE_AVX2
@@ -387,7 +227,7 @@ void srslte_vec_sc_div2_sss_avx2(short *x, int k, short *z, uint32_t len)
     z[number] = x[number] / divn;
   }
 #endif
-}
+}*/
 
 
 
@@ -531,379 +371,527 @@ void srslte_vec_sum_fff_avx(float *x, float *y, float *z, uint32_t len) {
 #endif
 }
 
-void srslte_vec_sub_fff_sse(float *x, float *y, float *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 4;
+cf_t srslte_vec_acc_cc_simd(cf_t *x, int len) {
+  int i = 0;
+  cf_t acc_sum = 0.0f;
 
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
-  float* zPtr = (float*) z;
+#if SRSLTE_SIMD_F_SIZE
+  simd_f_t simd_sum = srslte_simd_f_zero();
 
-  __m128 xVal, yVal, zVal;
-  for(;number < points; number++){
+  if (SRSLTE_IS_ALIGNED(x)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t a = srslte_simd_f_load((float *) &x[i]);
 
-    xVal = _mm_loadu_ps(xPtr);
-    yVal = _mm_loadu_ps(yPtr);
+      simd_sum = srslte_simd_f_add(simd_sum, a);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t a = srslte_simd_f_loadu((float *) &x[i]);
 
-    zVal = _mm_sub_ps(xVal, yVal);
+      simd_sum = srslte_simd_f_add(simd_sum, a);
+    }
+  }
 
-    _mm_storeu_ps(zPtr, zVal);
+  __attribute__((aligned(64))) cf_t sum[SRSLTE_SIMD_F_SIZE/2];
+  srslte_simd_f_store((float*)&sum, simd_sum);
+  for (int k = 0; k < SRSLTE_SIMD_F_SIZE/2; k++) {
+    acc_sum += sum[k];
+  }
+#endif
 
-    xPtr += 4;
-    yPtr += 4;
-    zPtr += 4;
+  for (; i<len; i++) {
+    acc_sum += x[i];
   }
+  return acc_sum;
+}
+
+void srslte_vec_add_fff_simd(float *x, float *y, float *z, int len) {
+  int i = 0;
 
-  for(number = points * 4;number < len; number++){
-    z[number] = x[number] - y[number];
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_load(&x[i]);
+      simd_f_t b = srslte_simd_f_load(&y[i]);
+
+      simd_f_t r = srslte_simd_f_add(a, b);
+
+      srslte_simd_f_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_loadu(&x[i]);
+      simd_f_t b = srslte_simd_f_loadu(&y[i]);
+
+      simd_f_t r = srslte_simd_f_add(a, b);
+
+      srslte_simd_f_storeu(&z[i], r);
+    }
   }
 #endif
+
+  for (; i<len; i++) {
+    z[i] = x[i] + y[i];
+  }
 }
 
+void srslte_vec_sub_fff_simd(float *x, float *y, float *z, int len) {
+  int i = 0;
 
-void srslte_vec_sub_fff_avx(float *x, float *y, float *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 8;
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_load(&x[i]);
+      simd_f_t b = srslte_simd_f_load(&y[i]);
 
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
-  float* zPtr = (float*) z;
+      simd_f_t r = srslte_simd_f_sub(a, b);
 
-  __m256 xVal, yVal, zVal;
-  for(;number < points; number++){
+      srslte_simd_f_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_loadu(&x[i]);
+      simd_f_t b = srslte_simd_f_loadu(&y[i]);
 
-    xVal = _mm256_loadu_ps(xPtr);
-    yVal = _mm256_loadu_ps(yPtr);
+      simd_f_t r = srslte_simd_f_sub(a, b);
 
-    zVal = _mm256_sub_ps(xVal, yVal);
+      srslte_simd_f_storeu(&z[i], r);
+    }
+  }
+#endif
 
-    _mm256_storeu_ps(zPtr, zVal);
+  for (; i < len; i++) {
+    z[i] = x[i] - y[i];
+  }
+}
 
-    xPtr += 8;
-    yPtr += 8;
-    zPtr += 8;
+cf_t srslte_vec_dot_prod_ccc_simd(cf_t *x, cf_t *y, int len) {
+  int i = 0;
+  cf_t result = 0;
+
+#if SRSLTE_SIMD_CF_SIZE
+  __attribute__((aligned(64))) cf_t simd_dotProdVector[SRSLTE_SIMD_CF_SIZE];
+
+  simd_cf_t avx_result = srslte_simd_cf_zero();
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y)) {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t xVal = srslte_simd_cfi_load(&x[i]);
+      simd_cf_t yVal = srslte_simd_cfi_load(&y[i]);
+
+      avx_result = srslte_simd_cf_add(srslte_simd_cf_prod(xVal, yVal), avx_result);
+      srslte_simd_cfi_store(simd_dotProdVector, avx_result);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t xVal = srslte_simd_cfi_loadu(&x[i]);
+      simd_cf_t yVal = srslte_simd_cfi_loadu(&y[i]);
+
+      avx_result = srslte_simd_cf_add(srslte_simd_cf_prod(xVal, yVal), avx_result);
+      srslte_simd_cfi_storeu(simd_dotProdVector, avx_result);
+    }
   }
 
-  for(number = points * 8;number < len; number++){
-    z[number] = x[number] - y[number];
+  srslte_simd_cfi_store(simd_dotProdVector, avx_result);
+  for (int k = 0; k < SRSLTE_SIMD_CF_SIZE; k++) {
+    result += simd_dotProdVector[k];
   }
 #endif
-}
 
-#ifdef LV_HAVE_SSE
-static inline __m128 _mm_complexmul_ps(__m128 x, __m128 y) {
-  __m128 yl, yh, tmp1, tmp2;
-  yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
-  yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
-  tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-  x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
-  tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-  return _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+  for (; i < len; i++) {
+    result += (x[i] * y[i]);
+  }
+
+  return result;
 }
+
+c16_t srslte_vec_dot_prod_ccc_c16i_simd(c16_t *x, c16_t *y, int len) {
+  int i = 0;
+  c16_t result = 0;
+
+#if SRSLTE_SIMD_C16_SIZE
+  simd_c16_t avx_result = srslte_simd_c16_zero();
+
+  for (; i < len - SRSLTE_SIMD_C16_SIZE + 1; i += SRSLTE_SIMD_C16_SIZE) {
+    simd_c16_t xVal = srslte_simd_c16i_load(&x[i]);
+    simd_c16_t yVal = srslte_simd_c16i_load(&y[i]);
+
+    avx_result = srslte_simd_c16_add(srslte_simd_c16_prod(xVal, yVal), avx_result);
+  }
+
+  __attribute__((aligned(256))) c16_t avx_dotProdVector[16] = {0};
+  srslte_simd_c16i_store(avx_dotProdVector, avx_result);
+  for (int k = 0; k < 16; k++) {
+    result += avx_dotProdVector[k];
+  }
 #endif
 
+  for(;i < len; i++){
+    result += (x[i] * y[i])/(1<<14);
+  }
 
-#ifdef LV_HAVE_SSE
-static inline __m128 _mm_complexmulconj_ps(__m128 x, __m128 y) {
-  const __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
-  y = _mm_xor_ps(y, conjugator); 
-  return _mm_complexmul_ps(x, y);
+  return result;
 }
-#endif
 
-cf_t srslte_vec_dot_prod_ccc_sse(cf_t *x, cf_t *y, uint32_t len)
+cf_t srslte_vec_dot_prod_conj_ccc_simd(cf_t *x, cf_t *y, int len)
 {
-  cf_t result = 0; 
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 2;
+  int i = 0;
+  cf_t result = 0;
 
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
-  
-  __m128 dotProdVal = _mm_setzero_ps();
+#if SRSLTE_SIMD_CF_SIZE
+  __attribute__((aligned(256))) cf_t simd_dotProdVector[SRSLTE_SIMD_CF_SIZE];
 
-  __m128 xVal, yVal, zVal;
-  for(;number < points; number++){
-
-    xVal = _mm_loadu_ps(xPtr);
-    yVal = _mm_loadu_ps(yPtr);
+  simd_cf_t simd_result = srslte_simd_cf_zero();
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y)) {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t xVal = srslte_simd_cfi_load(&x[i]);
+      simd_cf_t yVal = srslte_simd_cfi_load(&y[i]);
 
-    zVal = _mm_complexmul_ps(xVal, yVal);
+      simd_result = srslte_simd_cf_add(srslte_simd_cf_conjprod(xVal, yVal), simd_result);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t xVal = srslte_simd_cfi_loadu(&x[i]);
+      simd_cf_t yVal = srslte_simd_cfi_loadu(&y[i]);
 
-    dotProdVal = _mm_add_ps(dotProdVal, zVal);
+      simd_result = srslte_simd_cf_add(srslte_simd_cf_conjprod(xVal, yVal), simd_result);
+    }
+  }
 
-    xPtr += 4;
-    yPtr += 4;
+  srslte_simd_cfi_store(simd_dotProdVector, simd_result);
+  for (int k = 0; k < SRSLTE_SIMD_CF_SIZE; k++) {
+    result += simd_dotProdVector[k];
   }
-  
-  cf_t dotProdVector[2];
-  _mm_storeu_ps((float*) dotProdVector, dotProdVal);
-  for (int i=0;i<2;i++) {
-    result += dotProdVector[i]; 
+#endif
+
+  for (; i < len; i++) {
+    result += x[i] * conjf(y[i]);
   }
 
-  number = points * 2;
-  for(;number < len; number++){
-    result += (x[number] * y[number]);
+  return result;
+}
+
+void srslte_vec_prod_fff_simd(float *x, float *y, float *z, int len) {
+  int i = 0;
+
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_load(&x[i]);
+      simd_f_t b = srslte_simd_f_load(&y[i]);
+
+      simd_f_t r = srslte_simd_f_mul(a, b);
+
+      srslte_simd_f_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t a = srslte_simd_f_loadu(&x[i]);
+      simd_f_t b = srslte_simd_f_loadu(&y[i]);
+
+      simd_f_t r = srslte_simd_f_mul(a, b);
+
+      srslte_simd_f_storeu(&z[i], r);
+    }
   }
-  
 #endif
-  return result; 
-}
 
-cf_t srslte_vec_dot_prod_conj_ccc_sse(cf_t *x, cf_t *y, uint32_t len)
-{
-  cf_t result = 0; 
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int points = len / 2;
+  for (; i<len; i++) {
+    z[i] = x[i] * y[i];
+  }
+}
 
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
-  
-  __m128 dotProdVal = _mm_setzero_ps();
+void srslte_vec_prod_ccc_simd(cf_t *x,cf_t *y, cf_t *z, int len) {
+  int i = 0;
 
-  __m128 xVal, yVal, zVal;
-  for(;number < points; number++){
+#if SRSLTE_SIMD_CF_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t a = srslte_simd_cfi_load(&x[i]);
+      simd_cf_t b = srslte_simd_cfi_load(&y[i]);
 
-    xVal = _mm_loadu_ps(xPtr);
-    yVal = _mm_loadu_ps(yPtr);
+      simd_cf_t r = srslte_simd_cf_prod(a, b);
 
-    zVal = _mm_complexmulconj_ps(xVal, yVal);
+      srslte_simd_cfi_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t a = srslte_simd_cfi_loadu(&x[i]);
+      simd_cf_t b = srslte_simd_cfi_loadu(&y[i]);
 
-    dotProdVal = _mm_add_ps(dotProdVal, zVal);
+      simd_cf_t r = srslte_simd_cf_prod(a, b);
 
-    xPtr += 4;
-    yPtr += 4;
+      srslte_simd_cfi_storeu(&z[i], r);
+    }
   }
-  
-  cf_t dotProdVector[2];
-  _mm_storeu_ps((float*) dotProdVector, dotProdVal);
-  for (int i=0;i<2;i++) {
-    result += dotProdVector[i]; 
+#endif
+
+  for (; i<len; i++) {
+    z[i] = x[i] * y[i];
   }
+}
 
-  number = points * 2;
-  for(;number < len; number++){
-    result += (x[number] * y[number]);
+void srslte_vec_prod_ccc_cf_simd(float *a_re, float *a_im, float *b_re, float *b_im, float *r_re, float *r_im, int len) {
+  int i = 0;
+
+#if SRSLTE_SIMD_F_SIZE
+  for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+    simd_cf_t a = srslte_simd_cf_load(&a_re[i], &a_im[i]);
+    simd_cf_t b = srslte_simd_cf_load(&b_re[i], &b_im[i]);
+
+    simd_cf_t r = srslte_simd_cf_prod(a, b);
+
+    srslte_simd_cf_store(&r_re[i], &r_im[i], r);
   }
-  
 #endif
-  return result; 
+
+  for (; i<len; i++) {
+    r_re[i] = a_re[i]*b_re[i] - a_im[i]*b_im[i];
+    r_im[i] = a_re[i]*b_im[i] + a_im[i]*b_re[i];
+  }
 }
 
-void srslte_vec_prod_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len)
-{
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int halfPoints = len / 2;
+void srslte_vec_prod_ccc_c16_simd(int16_t *a_re, int16_t *a_im, int16_t *b_re, int16_t *b_im, int16_t *r_re,
+                                  int16_t *r_im, int len) {
+  int i = 0;
 
-  __m128 xVal, yVal, zVal;
-  float* zPtr = (float*) z;
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
+#if SRSLTE_SIMD_C16_SIZE
+  for (; i < len - SRSLTE_SIMD_C16_SIZE + 1; i += SRSLTE_SIMD_C16_SIZE) {
+    simd_c16_t a = srslte_simd_c16_load(&a_re[i], &a_im[i]);
+    simd_c16_t b = srslte_simd_c16_load(&b_re[i], &b_im[i]);
 
-  for(; number < halfPoints; number++){
-    xVal = _mm_loadu_ps(xPtr); 
-    yVal = _mm_loadu_ps(yPtr); 
-    zVal = _mm_complexmul_ps(xVal, yVal);
-    _mm_storeu_ps(zPtr, zVal); 
+    simd_c16_t r = srslte_simd_c16_prod(a, b);
 
-    xPtr += 4;
-    yPtr += 4;
-    zPtr += 4;
+    srslte_simd_c16_store(&r_re[i], &r_im[i], r);
   }
+#endif
 
-  number = halfPoints * 2;
-  for(;number < len; number++){
-    z[number] = x[number] * y[number];
+  for (; i<len; i++) {
+    r_re[i] = a_re[i]*b_re[i] - a_im[i]*b_im[i];
+    r_im[i] = a_re[i]*b_im[i] + a_im[i]*b_re[i];
   }
-#endif
 }
 
+void srslte_vec_prod_conj_ccc_simd(cf_t *x,cf_t *y, cf_t *z, int len) {
+  int i = 0;
 
-void srslte_vec_prod_conj_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int halfPoints = len / 2;
+#if SRSLTE_SIMD_CF_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(y) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t a = srslte_simd_cfi_load(&x[i]);
+      simd_cf_t b = srslte_simd_cfi_load(&y[i]);
 
-  __m128 xVal, yVal, zVal;
-  float* zPtr = (float*) z;
-  const float* xPtr = (const float*) x;
-  const float* yPtr = (const float*) y;
+      simd_cf_t r = srslte_simd_cf_conjprod(a, b);
 
-  for(; number < halfPoints; number++){
-    xVal = _mm_loadu_ps(xPtr); 
-    yVal = _mm_loadu_ps(yPtr); 
-    zVal = _mm_complexmulconj_ps(xVal, yVal);
-    _mm_storeu_ps(zPtr, zVal); 
+      srslte_simd_cfi_store(&z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_CF_SIZE + 1; i += SRSLTE_SIMD_CF_SIZE) {
+      simd_cf_t a = srslte_simd_cfi_loadu(&x[i]);
+      simd_cf_t b = srslte_simd_cfi_loadu(&y[i]);
 
-    xPtr += 4;
-    yPtr += 4;
-    zPtr += 4;
-  }
+      simd_cf_t r = srslte_simd_cf_conjprod(a, b);
 
-  number = halfPoints * 2;
-  for(;number < len; number++){
-    z[number] = x[number] * conjf(y[number]);
+      srslte_simd_cfi_storeu(&z[i], r);
+    }
   }
 #endif
+
+  for (; i<len; i++) {
+    z[i] = x[i] * conjf(y[i]);
+  }
 }
 
-void srslte_vec_sc_prod_ccc_sse(cf_t *x, cf_t h, cf_t *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int halfPoints = len / 2;
+void srslte_vec_sc_prod_ccc_simd(cf_t *x, cf_t h, cf_t *z, int len) {
+  int i = 0;
 
-  __m128 xVal, yl, yh, zVal, tmp1, tmp2;
-  float* zPtr = (float*) z;
-  const float* xPtr = (const float*) x;
+#if SRSLTE_SIMD_F_SIZE
+  const simd_f_t hre = srslte_simd_f_set1(__real__ h);
+  const simd_f_t him = srslte_simd_f_set1(__imag__ h);
 
-  // Set up constant scalar vector
-  yl = _mm_set_ps1(creal(h));
-  yh = _mm_set_ps1(cimag(h));
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_load((float *) &x[i]);
 
-  for(;number < halfPoints; number++){
+      simd_f_t m1 = srslte_simd_f_mul(hre, temp);
+      simd_f_t sw = srslte_simd_f_swap(temp);
+      simd_f_t m2 = srslte_simd_f_mul(him, sw);
+      simd_f_t r = srslte_simd_f_addsub(m1, m2);
 
-    xVal = _mm_loadu_ps(xPtr); 
-    tmp1 = _mm_mul_ps(xVal,yl); 
-    xVal = _mm_shuffle_ps(xVal,xVal,0xB1); 
-    tmp2 = _mm_mul_ps(xVal,yh); 
-    zVal = _mm_addsub_ps(tmp1,tmp2); 
-    _mm_storeu_ps(zPtr,zVal); 
+      srslte_simd_f_store((float *) &z[i], r);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_load((float *) &x[i]);
 
-    xPtr += 4;
-    zPtr += 4;
-  }
+      simd_f_t m1 = srslte_simd_f_mul(hre, temp);
+      simd_f_t sw = srslte_simd_f_swap(temp);
+      simd_f_t m2 = srslte_simd_f_mul(him, sw);
+      simd_f_t r = srslte_simd_f_addsub(m1, m2);
 
-  number = halfPoints * 2;
-  for(;number < len; number++){
-    z[number] = x[number] * h;
+      srslte_simd_f_store((float *) &z[i], r);
+    }
   }
 #endif
+
+  for (; i < len; i++) {
+    z[i] = x[i] * h;
+  }
 }
 
+void srslte_vec_sc_prod_fff_simd(float *x, float h, float *z, int len) {
+  int i = 0;
 
-void srslte_vec_sc_prod_cfc_sse(cf_t *x, float h, cf_t *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int halfPoints = len / 2;
+#if SRSLTE_SIMD_F_SIZE
+  const simd_f_t hh = srslte_simd_f_set1(h);
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t xx = srslte_simd_f_load(&x[i]);
 
-  __m128 xVal, hVal, zVal;
-  float* zPtr = (float*) z;
-  const float* xPtr = (const float*) x;
+      simd_f_t zz = srslte_simd_f_mul(xx, hh);
 
-  // Set up constant scalar vector
-  hVal = _mm_set_ps1(h);
-  
-  for(;number < halfPoints; number++){
+      srslte_simd_f_store(&z[i], zz);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t xx = srslte_simd_f_loadu(&x[i]);
 
-    xVal = _mm_loadu_ps(xPtr); 
-    zVal = _mm_mul_ps(xVal,hVal); 
-    _mm_storeu_ps(zPtr,zVal); 
+      simd_f_t zz = srslte_simd_f_mul(xx, hh);
 
-    xPtr += 4;
-    zPtr += 4;
+      srslte_simd_f_storeu(&z[i], zz);
+    }
   }
+#endif
 
-  number = halfPoints * 2;
-  for(;number < len; number++){
-    z[number] = x[number] * h;
+  for (; i < len; i++) {
+    z[i] = x[i] * h;
   }
-
-#endif
 }
 
+void srslte_vec_abs_cf_simd(cf_t *x, float *z, int len) {
+  int i = 0;
 
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t x1 = srslte_simd_f_load((float *) &x[i]);
+      simd_f_t x2 = srslte_simd_f_load((float *) &x[i + SRSLTE_SIMD_F_SIZE / 2]);
 
-void srslte_vec_sc_prod_fff_sse(float *x, float h, float *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int quarterPoints = len / 4;
+      simd_f_t mul1 = srslte_simd_f_mul(x1, x1);
+      simd_f_t mul2 = srslte_simd_f_mul(x2, x2);
 
-  __m128 xVal, hVal, zVal;
-  float* zPtr = (float*) z;
-  const float* xPtr = (const float*) x;
+      simd_f_t z1 = srslte_simd_f_hadd(mul1, mul2);
+      z1 = srslte_simd_f_sqrt(z1);
 
-  // Set up constant scalar vector
-  hVal = _mm_set_ps1(h);
-  
-  for(;number < quarterPoints; number++){
+      srslte_simd_f_store(&z[i], z1);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t x1 = srslte_simd_f_loadu((float *) &x[i]);
+      simd_f_t x2 = srslte_simd_f_loadu((float *) &x[i + SRSLTE_SIMD_F_SIZE / 2]);
 
-    xVal = _mm_loadu_ps(xPtr); 
-    zVal = _mm_mul_ps(xVal,hVal); 
-    _mm_storeu_ps(zPtr,zVal); 
+      simd_f_t mul1 = srslte_simd_f_mul(x1, x1);
+      simd_f_t mul2 = srslte_simd_f_mul(x2, x2);
 
-    xPtr += 4;
-    zPtr += 4;
+      simd_f_t z1 = srslte_simd_f_hadd(mul1, mul2);
+      z1 = srslte_simd_f_sqrt(z1);
+
+      srslte_simd_f_storeu(&z[i], z1);
+    }
   }
+#endif
 
-  number = quarterPoints * 4;
-  for(;number < len; number++){
-    z[number] = x[number] * h;
+  for (; i < len; i++) {
+    z[i] = sqrtf(__real__(x[i]) * __real__(x[i]) + __imag__(x[i]) * __imag__(x[i]));
   }
+}
 
+void srslte_vec_abs_square_cf_simd(cf_t *x, float *z, int len) {
+  int i = 0;
+
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t x1 = srslte_simd_f_load((float *) &x[i]);
+      simd_f_t x2 = srslte_simd_f_load((float *) &x[i + SRSLTE_SIMD_F_SIZE / 2]);
+
+      simd_f_t mul1 = srslte_simd_f_mul(x1, x1);
+      simd_f_t mul2 = srslte_simd_f_mul(x2, x2);
+
+      simd_f_t z1 = srslte_simd_f_hadd(mul1, mul2);
+
+      srslte_simd_f_store(&z[i], z1);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE + 1; i += SRSLTE_SIMD_F_SIZE) {
+      simd_f_t x1 = srslte_simd_f_loadu((float *) &x[i]);
+      simd_f_t x2 = srslte_simd_f_loadu((float *) &x[i + SRSLTE_SIMD_F_SIZE / 2]);
+
+      simd_f_t mul1 = srslte_simd_f_mul(x1, x1);
+      simd_f_t mul2 = srslte_simd_f_mul(x2, x2);
+
+      simd_f_t z1 = srslte_simd_f_hadd(mul1, mul2);
+
+      srslte_simd_f_storeu(&z[i], z1);
+    }
+  }
 #endif
+
+  for (; i < len; i++) {
+    z[i] = __real__(x[i]) * __real__(x[i]) + __imag__(x[i]) * __imag__(x[i]);
+  }
 }
 
-void srslte_vec_abs_square_cf_sse(cf_t *x, float *z, uint32_t len) {
-#ifdef LV_HAVE_SSE
-  unsigned int number = 0;
-  const unsigned int quarterPoints = len / 4;
 
-  const float* xPtr = (const float*) x;
-  float* zPtr = z;
+void srslte_vec_sc_prod_cfc_simd(const cf_t *x, const float h, cf_t *z, const int len) {
+  int i = 0;
 
-  __m128 xVal1, xVal2, zVal;
-  for(; number < quarterPoints; number++){
-    xVal1 = _mm_loadu_ps(xPtr);
-    xPtr += 4;
-    xVal2 = _mm_loadu_ps(xPtr);
-    xPtr += 4;
-    xVal1 = _mm_mul_ps(xVal1, xVal1); 
-    xVal2 = _mm_mul_ps(xVal2, xVal2); 
-    zVal = _mm_hadd_ps(xVal1, xVal2);
-    _mm_storeu_ps(zPtr, zVal);
-    zPtr += 4;
-  }
+#if SRSLTE_SIMD_F_SIZE
+  const simd_f_t tap = srslte_simd_f_set1(h);
 
-  number = quarterPoints * 4;
-  for(;number < len; number++){
-    z[number] = creal(x[number]) * creal(x[number]) + cimag(x[number])*cimag(x[number]);
+  if (SRSLTE_IS_ALIGNED(x) && SRSLTE_IS_ALIGNED(z)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_load((float *) &x[i]);
+
+      temp = srslte_simd_f_mul(tap, temp);
+
+      srslte_simd_f_store((float *) &z[i], temp);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_loadu((float *) &x[i]);
+
+      temp = srslte_simd_f_mul(tap, temp);
+
+      srslte_simd_f_storeu((float *) &z[i], temp);
+    }
   }
 #endif
+
+  for (; i < len; i++) {
+    z[i] = x[i] * h;
+  }
 }
 
+void srslte_vec_cp_simd(cf_t *src, cf_t *dst, int len) {
+  uint32_t i = 0;
 
-//srslte_32fc_s32f_multiply_32fc_avx
- void srslte_vec_sc_prod_cfc_avx( const cf_t *x,const float h,cf_t *z,const uint32_t len)
-{
-#ifdef LV_HAVE_AVX
-   
-  unsigned int i = 0;
-  const unsigned int loops = len/4;
-  //__m256 outputVec;
-    cf_t *xPtr = (cf_t*) x;
-    cf_t *zPtr = (cf_t*) z;
-  
-  __m256 inputVec, outputVec;
-    const __m256 tapsVec  = _mm256_set1_ps(h);
-  for(;i < loops;i++)
-  {
-      inputVec  = _mm256_loadu_ps((float*)xPtr);
-      //__builtin_prefetch(xPtr+4);
-      outputVec = _mm256_mul_ps(inputVec,tapsVec);
-      _mm256_storeu_ps((float*)zPtr,outputVec);
-      xPtr += 4;
-      zPtr += 4;
-  }
-  
-  for(i = loops * 4;i < len;i++)
-  {
-      *zPtr++ = (*xPtr++) * h;
+#if SRSLTE_SIMD_F_SIZE
+  if (SRSLTE_IS_ALIGNED(src) && SRSLTE_IS_ALIGNED(dst)) {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_load((float *) &src[i]);
+
+      srslte_simd_f_store((float *) &dst[i], temp);
+    }
+  } else {
+    for (; i < len - SRSLTE_SIMD_F_SIZE / 2 + 1; i += SRSLTE_SIMD_F_SIZE / 2) {
+      simd_f_t temp = srslte_simd_f_loadu((float *) &src[i]);
+
+      srslte_simd_f_storeu((float *) &dst[i], temp);
+    }
   }
 #endif
+
+  for (; i < len; i++) {
+    dst[i] = src[i];
+  }
 }