Harmonize DLSCH/ULSCH unscrambling in gNB/nrUE

Uses optimized scrambling if not UCI on PUSCH, or unoptimized to put
placeholder bits otherwise.

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -47,70 +47,11 @@ void nr_pdsch_codeword_scrambling(uint8_t *in,
                                   uint8_t q,
                                   uint32_t Nid,
                                   uint32_t n_RNTI,
-                                  uint32_t* out) {
-
-  uint8_t reset, b_idx;
-  uint32_t x1, x2, s=0;
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 1);
-  reset = 1;
-  x2 = (n_RNTI<<15) + (q<<14) + Nid;
-
-  for (int i=0; i<size; i++) {
-    b_idx = i&0x1f;
-    if (b_idx==0) {
-      s = lte_gold_generic(&x1, &x2, reset);
-      reset = 0;
-      if (i)
-        out++;
-    }
-    *out ^= (((in[i])&1) ^ ((s>>b_idx)&1))<<b_idx;
-    //printf("i %d b_idx %d in %d s 0x%08x out 0x%08x\n", i, b_idx, in[i], s, *out);
-  }
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 0);
+                                  uint32_t* out)
+{
+  nr_codeword_scrambling(in, size, q, Nid, n_RNTI, out);
 }
 
-void nr_pdsch_codeword_scrambling_optim(uint8_t *in,
-					uint32_t size,
-					uint8_t q,
-					uint32_t Nid,
-					uint32_t n_RNTI,
-					uint32_t* out) {
-  
-  uint32_t x1, x2, s=0,in32;
-
-  x2 = (n_RNTI<<15) + (q<<14) + Nid;
-
-  s=lte_gold_generic(&x1, &x2, 1);
-
-#if defined(__AVX2__)
-  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
-    in32=_mm256_movemask_epi8(_mm256_slli_epi16(((__m256i*)in)[i],7));
-    out[i]=(in32^s);
-    //printf("in[%d] %x => %x\n",i,in32,out[i]);
-    s=lte_gold_generic(&x1, &x2, 0);
-  }
-#elif defined(__SSE4__)
-  _m128i *in128;
-  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
-    in128=&((__m128i*)in)[i<<1];
-    ((uint16_t*)&in32)[0] = _mm128_movemask_epi8(_mm256_slli_epi16(in128[0],7));
-    ((uint16_t*)&in32)[1] = _mm128_movemask_epi8(_mm256_slli_epi16(in128[1],7));
-    out[i]=(in32^s);
-    s=lte_gold_generic(&x1, &x2, 0);
-  }
-  //#elsif defined(__arm__) || defined(__aarch64)
-  
-#else 
-  nr_pdsch_codeword_scrambling(in,
-			       size,
-			       q,
-			       Nid,
-			       n_RNTI,
-			       out);
-#endif
-}
-
-
 void nr_generate_pdsch(processingData_L1tx_t *msgTx,
                        int frame,
                        int slot) {
@@ -213,12 +154,12 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx,
     for (int q=0; q<rel15->NrOfCodewords; q++)
       memset((void*)scrambled_output[q], 0, (encoded_length>>5)*sizeof(uint32_t));
     for (int q=0; q<rel15->NrOfCodewords; q++)
-      nr_pdsch_codeword_scrambling_optim(output,
-					 encoded_length,
-					 q,
-					 rel15->dataScramblingId,
-					 rel15->rnti,
-					 scrambled_output[q]);
+      nr_pdsch_codeword_scrambling(output,
+                                   encoded_length,
+                                   q,
+                                   rel15->dataScramblingId,
+                                   rel15->rnti,
+                                   scrambled_output[q]);
     
     stop_meas(dlsch_scrambling_stats);
 #ifdef DEBUG_DLSCH

openair1/PHY/NR_TRANSPORT/nr_scrambling.c

@@ -21,6 +21,58 @@
 
 #include "nr_transport_common_proto.h"
 #include "PHY/NR_REFSIG/nr_refsig.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+void nr_codeword_scrambling(uint8_t *in,
+                            uint32_t size,
+                            uint8_t q,
+                            uint32_t Nid,
+                            uint32_t n_RNTI,
+                            uint32_t* out)
+{
+  uint32_t x1;
+  uint32_t x2 = (n_RNTI<<15) + (q<<14) + Nid;
+  uint32_t s = 0;
+
+#if defined(__AVX2__)
+  s=lte_gold_generic(&x1, &x2, 1);
+  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
+    __m256i c = ((__m256i*)in)[i];
+    uint32_t in32 = _mm256_movemask_epi8(_mm256_slli_epi16(c,7));
+    out[i]=(in32^s);
+    //printf("in[%d] %x => %x\n",i,in32,out[i]);
+    s=lte_gold_generic(&x1, &x2, 0);
+  }
+#elif defined(__SSE4__)
+  s=lte_gold_generic(&x1, &x2, 1);
+  __m128i *in128;
+  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
+    in128=&((__m128i*)in)[i<<1];
+    uint32_t in32;
+    ((uint16_t*)&in32)[0] = _mm_movemask_epi8(_mm_slli_epi16(in128[0],7));
+    ((uint16_t*)&in32)[1] = _mm_movemask_epi8(_mm_slli_epi16(in128[1],7));
+    out[i]=(in32^s);
+    s=lte_gold_generic(&x1, &x2, 0);
+  }
+//#elsif defined(__arm__) || defined(__aarch64)
+#else
+  uint8_t reset = 1;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 1);
+  for (int i = 0; i < size; i++) {
+    const uint8_t b_idx = i&0x1f;
+    if (b_idx==0) {
+      s = lte_gold_generic(&x1, &x2, reset);
+      reset = 0;
+      if (i)
+        out++;
+    }
+    *out ^= (((in[i])&1) ^ ((s>>b_idx)&1))<<b_idx;
+    //printf("i %d b_idx %d in %d s 0x%08x out 0x%08x\n", i, b_idx, in[i], s, *out);
+  }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 0);
+#endif
+}
 
 void nr_codeword_unscrambling(int16_t* llr, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI)
 {

openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h

@@ -77,6 +77,13 @@ void nr_fill_du(uint16_t N_ZC,uint16_t *prach_root_sequence_map);
 
 void init_nr_prach_tables(int N_ZC);
 
+void nr_codeword_scrambling(uint8_t *in,
+                            uint32_t size,
+                            uint8_t q,
+                            uint32_t Nid,
+                            uint32_t n_RNTI,
+                            uint32_t* out);
+
 void nr_codeword_unscrambling(int16_t* llr, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI);
 
 /**@}*/

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1055,14 +1055,15 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
   @param[in] size, of input bits
   @param[in] Nid, cell id
   @param[in] n_RNTI, CRNTI
+  @param[in] uci_on_pusch whether UCI placeholder bits need to be scrambled (true -> no optimized scrambling)
   @param[out] out, the scrambled bits
 */
-
 void nr_pusch_codeword_scrambling(uint8_t *in,
-                         uint32_t size,
-                         uint32_t Nid,
-                         uint32_t n_RNTI,
-                         uint32_t* out);
+                                  uint32_t size,
+                                  uint32_t Nid,
+                                  uint32_t n_RNTI,
+                                  bool uci_on_pusch,
+                                  uint32_t* out);
 
 /** \brief Perform the following functionalities:
     - encoding

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -149,7 +149,7 @@ typedef struct {
   /// ACK/NAK Bundling flag
   uint8_t bundling;
   /// Concatenated "g"-sequences (for definition see 36-212 V15.4.0 2018-12, p.31)
-  uint8_t g[MAX_NUM_NR_CHANNEL_BITS];
+  uint8_t g[MAX_NUM_NR_CHANNEL_BITS] __attribute__ ((aligned(32)));
   /// Interleaved "h"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
   uint8_t h[MAX_NUM_NR_CHANNEL_BITS];
   /// Scrambled "b"-sequences (for definition see 36-211 V8.6 2009-03, p.14)

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -53,12 +53,12 @@
 
 //extern int32_t uplink_counter;
 
-void nr_pusch_codeword_scrambling(uint8_t *in,
-                         uint32_t size,
-                         uint32_t Nid,
-                         uint32_t n_RNTI,
-                         uint32_t* out) {
-
+void nr_pusch_codeword_scrambling_uci(uint8_t *in,
+                                      uint32_t size,
+                                      uint32_t Nid,
+                                      uint32_t n_RNTI,
+                                      uint32_t* out)
+{
   uint8_t reset, b_idx;
   uint32_t x1, x2, s=0, temp_out;
 
@@ -89,7 +89,19 @@ void nr_pusch_codeword_scrambling(uint8_t *in,
       *out ^= (((in[i])&1) ^ ((s>>b_idx)&1))<<b_idx;
     //printf("i %d b_idx %d in %d s 0x%08x out 0x%08x\n", i, b_idx, in[i], s, *out);
   }
+}
 
+void nr_pusch_codeword_scrambling(uint8_t *in,
+                                  uint32_t size,
+                                  uint32_t Nid,
+                                  uint32_t n_RNTI,
+                                  bool uci_on_pusch,
+                                  uint32_t* out)
+{
+  if (uci_on_pusch)
+    nr_pusch_codeword_scrambling_uci(in, size, Nid, n_RNTI, out);
+  else
+    nr_codeword_scrambling(in, size, 0, Nid, n_RNTI, out);
 }
 
 void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
@@ -187,6 +199,7 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
                                  available_bits,
                                  ulsch_ue->Nid_cell,
                                  rnti,
+                                 false,
                                  scrambled_output[cwd_index]); // assume one codeword for the moment