Implement on the fly sequence generation

lib/include/srslte/phy/common/sequence.h

@@ -52,6 +52,12 @@ SRSLTE_API int srslte_sequence_LTE_pr(srslte_sequence_t* q, uint32_t len, uint32
 
 SRSLTE_API int srslte_sequence_set_LTE_pr(srslte_sequence_t* q, uint32_t len, uint32_t seed);
 
+SRSLTE_API void srslte_sequence_apply_f(const float* in, float* out, uint32_t length, uint32_t seed);
+
+SRSLTE_API void srslte_sequence_apply_s(const int16_t* in, int16_t* out, uint32_t length, uint32_t seed);
+
+SRSLTE_API void srslte_sequence_apply_c(const int8_t* in, int8_t* out, uint32_t length, uint32_t seed);
+
 SRSLTE_API int srslte_sequence_pbch(srslte_sequence_t* seq, srslte_cp_t cp, uint32_t cell_id);
 
 SRSLTE_API int srslte_sequence_pcfich(srslte_sequence_t* seq, uint32_t nslot, uint32_t cell_id);

lib/src/phy/common/sequence.c

@@ -168,19 +168,25 @@ __attribute__((constructor)) __attribute__((unused)) static void srslte_lte_pr_p
   }
 }
 
-static void sequence_gen_LTE_pr(uint8_t* pr, uint32_t len, uint32_t seed)
+static uint32_t sequence_get_x2_init(uint32_t seed)
 {
-  int      n  = 0;
-  uint32_t x1 = sequence_x1_init; // X1 initial state is fix
   uint32_t x2 = 0;
 
-  // Load X2 state
   for (uint32_t i = 0; i < SEQUENCE_SEED_LEN; i++) {
     if ((seed >> i) & 1U) {
       x2 ^= sequence_x2_init[i];
     }
   }
 
+  return x2;
+}
+
+static void sequence_gen_LTE_pr(uint8_t* pr, uint32_t len, uint32_t seed)
+{
+  int      n  = 0;
+  uint32_t x1 = sequence_x1_init;           // X1 initial state is fix
+  uint32_t x2 = sequence_get_x2_init(seed); // loads x2 initial state
+
   // Parallel stage
   if (len >= SEQUENCE_PAR_BITS) {
     for (; n < len - (SEQUENCE_PAR_BITS - 1); n += SEQUENCE_PAR_BITS) {
@@ -355,3 +361,173 @@ void srslte_sequence_free(srslte_sequence_t* q)
   }
   bzero(q, sizeof(srslte_sequence_t));
 }
+
+void srslte_sequence_apply_f(const float* in, float* out, uint32_t length, uint32_t seed)
+{
+  uint32_t x1 = sequence_x1_init;           // X1 initial state is fix
+  uint32_t x2 = sequence_get_x2_init(seed); // loads x2 initial state
+
+  uint32_t i = 0;
+
+  if (length >= SEQUENCE_PAR_BITS) {
+    for (; i < length - (SEQUENCE_PAR_BITS - 1); i += SEQUENCE_PAR_BITS) {
+      uint32_t c = (uint32_t)(x1 ^ x2);
+
+      uint32_t j = 0;
+#ifdef LV_HAVE_SSE
+      for (; j < SEQUENCE_PAR_BITS - 3; j += 4) {
+        // Preloads bits of interest in the 4 LSB
+        __m128i mask = _mm_set1_epi32(c >> j);
+
+        // Masks each bit
+        mask = _mm_and_si128(mask, _mm_setr_epi32(1, 2, 4, 8));
+
+        // Get non zero mask
+        mask = _mm_cmpgt_epi32(mask, _mm_set1_epi32(0));
+
+        // And with MSB
+        mask = _mm_and_si128(mask, (__m128i)_mm_set1_ps(-0.0F));
+
+        // Load input
+        __m128 v = _mm_loadu_ps(in + i + j);
+
+        // Loads input and perform sign XOR
+        v = _mm_xor_ps((__m128)mask, v);
+
+        _mm_storeu_ps(out + i + j, v);
+      }
+#endif
+      for (; j < SEQUENCE_PAR_BITS; j++) {
+        ((uint32_t*)out)[i + j] = ((uint32_t*)in)[i] ^ (((c >> j) & 1U) << 31U);
+      }
+
+      // Step sequences
+      x1 = sequence_gen_LTE_pr_memless_step_par_x1(x1);
+      x2 = sequence_gen_LTE_pr_memless_step_par_x2(x2);
+    }
+  }
+
+  for (; i < length; i++) {
+
+    ((uint32_t*)out)[i] = ((uint32_t*)in)[i] ^ (((x1 ^ x2) & 1U) << 31U);
+
+    // Step sequences
+    x1 = sequence_gen_LTE_pr_memless_step_x1(x1);
+    x2 = sequence_gen_LTE_pr_memless_step_x2(x2);
+  }
+}
+
+void srslte_sequence_apply_s(const int16_t* in, int16_t* out, uint32_t length, uint32_t seed)
+{
+  uint32_t x1 = sequence_x1_init;           // X1 initial state is fix
+  uint32_t x2 = sequence_get_x2_init(seed); // loads x2 initial state
+
+  uint32_t i = 0;
+
+  if (length >= SEQUENCE_PAR_BITS) {
+    for (; i < length - (SEQUENCE_PAR_BITS - 1); i += SEQUENCE_PAR_BITS) {
+      uint32_t c = (uint32_t)(x1 ^ x2);
+
+      uint32_t j = 0;
+#ifdef LV_HAVE_SSE
+      for (; j < SEQUENCE_PAR_BITS - 7; j += 8) {
+        // Preloads bits of interest in the 8 LSB
+        __m128i mask = _mm_set1_epi16((c >> j) & 0xff);
+
+        // Masks each bit
+        mask = _mm_and_si128(mask, _mm_setr_epi16(0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80));
+
+        // Get non zero mask
+        mask = _mm_cmpgt_epi16(mask, _mm_set1_epi16(0));
+
+        // Load input
+        __m128i v = _mm_loadu_si128((__m128i*)(in + i + j));
+
+        // Negate
+        v = _mm_xor_si128(v, mask);
+
+        // Add one
+        mask = _mm_and_si128(mask, _mm_set1_epi16(1));
+        v    = _mm_add_epi16(v, mask);
+
+        _mm_storeu_si128((__m128i*)(out + i + j), v);
+      }
+#endif
+      for (; j < SEQUENCE_PAR_BITS; j++) {
+        out[i + j] = in[i + j] * (((c >> j) & 1U) ? -1 : +1);
+      }
+
+      // Step sequences
+      x1 = sequence_gen_LTE_pr_memless_step_par_x1(x1);
+      x2 = sequence_gen_LTE_pr_memless_step_par_x2(x2);
+    }
+  }
+
+  for (; i < length; i++) {
+    out[i] = in[i] * (((x1 ^ x2) & 1U) ? -1 : +1);
+
+    // Step sequences
+    x1 = sequence_gen_LTE_pr_memless_step_x1(x1);
+    x2 = sequence_gen_LTE_pr_memless_step_x2(x2);
+  }
+}
+
+void srslte_sequence_apply_c(const int8_t* in, int8_t* out, uint32_t length, uint32_t seed)
+{
+  uint32_t x1 = sequence_x1_init;           // X1 initial state is fix
+  uint32_t x2 = sequence_get_x2_init(seed); // loads x2 initial state
+
+  uint32_t i = 0;
+
+  if (length >= SEQUENCE_PAR_BITS) {
+    for (; i < length - (SEQUENCE_PAR_BITS - 1); i += SEQUENCE_PAR_BITS) {
+      uint32_t c = (uint32_t)(x1 ^ x2);
+
+      uint32_t j = 0;
+#ifdef LV_HAVE_SSE
+      if (SEQUENCE_PAR_BITS >= 16) {
+        // Preloads bits of interest in the 16 LSB
+        __m128i mask = _mm_set1_epi32(c);
+        mask         = _mm_shuffle_epi8(mask, _mm_setr_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1));
+
+        // Masks each bit
+        // mask = _mm_and_si128( mask, _mm_set_epi64x(0x0102040810204080, 0x0102040810204080));
+        mask = _mm_and_si128(mask, _mm_set_epi64x(0x8040201008040201, 0x8040201008040201));
+
+        // Get non zero mask
+        mask = _mm_cmpeq_epi8(mask, _mm_set_epi64x(0x8040201008040201, 0x8040201008040201));
+
+        // Load input
+        __m128i v = _mm_loadu_si128((__m128i*)(in + i + j));
+
+        // Negate
+        v = _mm_xor_si128(mask, v);
+
+        // Add one
+        mask = _mm_and_si128(mask, _mm_set1_epi8(1));
+        v    = _mm_add_epi8(v, mask);
+
+        _mm_storeu_si128((__m128i*)(out + i + j), v);
+
+        // Increment bit counter `j`
+        j += 16;
+      }
+#endif
+      for (; j < SEQUENCE_PAR_BITS; j++) {
+        out[i + j] = in[i + j] * (((c >> j) & 1U) ? -1 : +1);
+      }
+
+      // Step sequences
+      x1 = sequence_gen_LTE_pr_memless_step_par_x1(x1);
+      x2 = sequence_gen_LTE_pr_memless_step_par_x2(x2);
+    }
+  }
+
+  for (; i < length; i++) {
+    out[i] = in[i] * (((x1 ^ x2) & 1U) ? -1 : +1);
+
+    // Step sequences
+    x1 = sequence_gen_LTE_pr_memless_step_x1(x1);
+    x2 = sequence_gen_LTE_pr_memless_step_x2(x2);
+  }
+}

lib/src/phy/common/test/sequence_test.c

@@ -35,10 +35,20 @@ static int16_t c_short[Nc + MAX_SEQ_LEN + 31];
 static int8_t  c_char[Nc + MAX_SEQ_LEN + 31];
 static uint8_t c_packed[MAX_SEQ_LEN / 8];
 
+static float   ones_float[Nc + MAX_SEQ_LEN + 31];
+static int16_t ones_short[Nc + MAX_SEQ_LEN + 31];
+static int8_t  ones_char[Nc + MAX_SEQ_LEN + 31];
+static uint8_t ones_packed[MAX_SEQ_LEN / 8];
+
 static int test_sequence(srslte_sequence_t* sequence, uint32_t seed, uint32_t length, uint32_t repetitions)
 {
-  int            ret  = SRSLTE_SUCCESS;
+  int            ret                   = SRSLTE_SUCCESS;
-  struct timeval t[3] = {};
+  struct timeval t[3]                  = {};
+  uint64_t       interval_gen_us       = 0;
+  uint64_t       interval_xor_float_us = 0;
+  uint64_t       interval_xor_short_us = 0;
+  uint64_t       interval_xor_char_us  = 0;
+
   gettimeofday(&t[1], NULL);
 
   // Generate sequence
@@ -48,6 +58,7 @@ static int test_sequence(srslte_sequence_t* sequence, uint32_t seed, uint32_t le
 
   gettimeofday(&t[2], NULL);
   get_time_interval(t);
+  interval_gen_us = t->tv_sec * 1000000UL + t->tv_usec;
 
   // Generate gold sequence
   for (uint32_t n = 0; n < 31; n++) {
@@ -70,35 +81,77 @@ static int test_sequence(srslte_sequence_t* sequence, uint32_t seed, uint32_t le
   srslte_bit_pack_vector(c, c_packed, length);
 
   if (memcmp(c, sequence->c, length) != 0) {
-    ERROR("Unmatched c\n");
+    ERROR("Unmatched c");
     ret = SRSLTE_ERROR;
   }
 
+  // Check Float sequence
   if (memcmp(c_float, sequence->c_float, length * sizeof(float)) != 0) {
-    ERROR("Unmatched c_float\n");
+    ERROR("Unmatched c_float");
     ret = SRSLTE_ERROR;
   }
 
+  // Test in-place Float XOR
+  gettimeofday(&t[1], NULL);
+  for (uint32_t r = 0; r < repetitions; r++) {
+    srslte_sequence_apply_f(ones_float, sequence->c_float, length, seed);
+  }
+  gettimeofday(&t[2], NULL);
+  get_time_interval(t);
+  interval_xor_float_us = t->tv_sec * 1000000UL + t->tv_usec;
+
+  // Check Short Sequence
+  if (memcmp(c_short, sequence->c_short, length * sizeof(int16_t)) != 0) {
+    ERROR("Unmatched XOR c_short");
+    ret = SRSLTE_ERROR;
+  }
+
+  // Test in-place Short XOR
+  gettimeofday(&t[1], NULL);
+  for (uint32_t r = 0; r < repetitions; r++) {
+    srslte_sequence_apply_s(ones_short, sequence->c_short, length, seed);
+  }
+  gettimeofday(&t[2], NULL);
+  get_time_interval(t);
+  interval_xor_short_us = t->tv_sec * 1000000UL + t->tv_usec;
+
   if (memcmp(c_short, sequence->c_short, length * sizeof(int16_t)) != 0) {
-    ERROR("Unmatched c_short\n");
+    ERROR("Unmatched XOR c_short");
     ret = SRSLTE_ERROR;
   }
 
+  // Check Char Sequence
   if (memcmp(c_char, sequence->c_char, length * sizeof(int8_t)) != 0) {
-    ERROR("Unmatched c_char\n");
+    ERROR("Unmatched c_char");
+    ret = SRSLTE_ERROR;
+  }
+
+  // Test in-place Char XOR
+  gettimeofday(&t[1], NULL);
+  for (uint32_t r = 0; r < repetitions; r++) {
+    srslte_sequence_apply_c(ones_char, sequence->c_char, length, seed);
+  }
+  gettimeofday(&t[2], NULL);
+  get_time_interval(t);
+  interval_xor_char_us = t->tv_sec * 1000000UL + t->tv_usec;
+
+  if (memcmp(c_char, sequence->c_char, length * sizeof(int8_t)) != 0) {
+    ERROR("Unmatched XOR c_char");
     ret = SRSLTE_ERROR;
   }
 
   if (memcmp(c_packed, sequence->c_bytes, length / 8) != 0) {
-    ERROR("Unmatched c_packed\n");
+    ERROR("Unmatched c_packed");
     ret = SRSLTE_ERROR;
   }
 
-  uint64_t elapsed_us = t->tv_usec + t->tv_sec * 1000000UL;
+  printf("%08x; %8d; %8.1f; %8.1f; %8.1f; %8.1f; %8c\n",
-  printf("%08x; %8d; %8.1f; %8c\n",
          seed,
          length,
-         (double)(length * repetitions) / (double)elapsed_us,
+         (double)(length * repetitions) / (double)interval_gen_us,
+         (double)(length * repetitions) / (double)interval_xor_float_us,
+         (double)(length * repetitions) / (double)interval_xor_short_us,
+         (double)(length * repetitions) / (double)interval_xor_char_us,
          ret == SRSLTE_SUCCESS ? 'y' : 'n');
 
   return SRSLTE_SUCCESS;
@@ -113,10 +166,20 @@ int main(int argc, char** argv)
   srslte_sequence_t sequence   = {};
   srslte_random_t   random_gen = srslte_random_init(0);
 
+  // Initialise vectors with ones
+  for (uint32_t i = 0; i < MAX_SEQ_LEN; i++) {
+    ones_float[i] = 1.0F;
+    ones_short[i] = 1;
+    ones_char[i]  = 1;
+    if (i < MAX_SEQ_LEN / 8) {
+      ones_packed[i] = UINT8_MAX;
+    }
+  }
+
   // Initialise sequence object
   srslte_sequence_init(&sequence, max_length);
 
-  printf("%8s; %8s; %8s; %8s\n", "seed", "length", "Rate M/s", "Passed");
+  printf("%8s; %8s; %8s; %8s; %8s; %8s; %8s\n", "seed", "length", "GEN", "XOR PS", "XOR 16", "XOR 8", "Passed");
 
   for (uint32_t length = min_length; length <= max_length; length = (length * 5) / 4) {
     test_sequence(&sequence, (uint32_t)srslte_random_uniform_int_dist(random_gen, 1, INT32_MAX), length, repetitions);
@@ -127,4 +190,4 @@ int main(int argc, char** argv)
   srslte_random_free(random_gen);
 
   return SRSLTE_SUCCESS;
-}
+}