fix(nrLDPC_coding_interface): Move the encoding output to the TB

Since this branch aims to bring all the encoded segments packed and contiguous,
it doesn't make anymore sense to have one output array per segment.
Therefore this commit moves the output array to the TB instead of the segment and adapts its size.

TODO: Adapt the size of f where it is relevant.

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_interface.h

@@ -140,7 +140,6 @@ typedef struct nrLDPC_slot_decoding_parameters_s{
  * \struct nrLDPC_segment_encoding_parameters_s
  * \brief encoding parameter of segments
  * \var E input llr segment size
- * \var output input llr segment array
  * \var c Pointers to code blocks before LDPC encoding (38.212 V15.4.0 section 5.2.2)
  * flag indicating that the decoding of the segment was successful
  * IT MUST BE FILLED BY THE IMPLEMENTATION
@@ -150,7 +149,6 @@ typedef struct nrLDPC_slot_decoding_parameters_s{
  */
 typedef struct nrLDPC_segment_encoding_parameters_s{
   int E;
-  unsigned char *output;
   uint8_t *c;
   time_stats_t ts_interleave;
   time_stats_t ts_rate_match;
@@ -179,6 +177,7 @@ typedef struct nrLDPC_segment_encoding_parameters_s{
  * \var F filler bits size
  * \var C number of segments 
  * \var segments array of segments parameters
+ * \var output input llr TB array
  */
 typedef struct nrLDPC_TB_encoding_parameters_s{
 
@@ -202,6 +201,7 @@ typedef struct nrLDPC_TB_encoding_parameters_s{
 
   uint32_t C;
   nrLDPC_segment_encoding_parameters_t *segments;
+  unsigned char *output;
 } nrLDPC_TB_encoding_parameters_t;
 
 /**

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_segment/nrLDPC_coding_segment_encoder.c

@@ -520,7 +520,7 @@ static int nrLDPC_prepare_TB_encoding(nrLDPC_slot_encoding_parameters_t *nrLDPC_
   impp.Kb = nrLDPC_TB_encoding_parameters->Kb;
   impp.Zc = nrLDPC_TB_encoding_parameters->Z;
   impp.BG = nrLDPC_TB_encoding_parameters->BG;
-  impp.output = nrLDPC_TB_encoding_parameters->segments->output; 
+  impp.output = nrLDPC_TB_encoding_parameters->output; 
   impp.K = nrLDPC_TB_encoding_parameters->K;
   impp.F = nrLDPC_TB_encoding_parameters->F;
 

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_t2/nrLDPC_coding_t2.c

@@ -656,7 +656,7 @@ retrieve_ldpc_enc_op(struct rte_bbdev_enc_op **ops,
       struct rte_bbdev_op_data *output = &ops[j]->ldpc_enc.output;
       struct rte_mbuf *m = output->data;
       uint16_t data_len = rte_pktmbuf_data_len(m) - output->offset;
-      uint8_t *out = nrLDPC_slot_encoding_parameters->TBs[h].segments[i].output;
+      uint8_t *out = nrLDPC_slot_encoding_parameters->TBs[h].output;
       const char *data = m->buf_addr + m->data_off;
       const char *end = data + data_len;
       while (data < end) {

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -600,14 +600,14 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
   printf("\nEncoded payload:\n");
   for (int i = 0; i < encoded_length; i += 8) {
     for (int j = 0; j < 8; j++)
-      printf("%d", input_ptr[i + j]);
+      printf("%d", (input_ptr[i >> 3] >> j) & 1);
     printf("\t");
   }
   printf("\n");
 #endif
 
   if (IS_SOFTMODEM_DLSIM)
-    memcpy(harq->f, input_ptr, encoded_length);
+    memcpy(harq->f, input_ptr, (encoded_length + 7) >> 3);
 
   c16_t mod_symbs[rel15->NrOfCodewords][encoded_length] __attribute__((aligned(64)));
   for (int codeWord = 0; codeWord < rel15->NrOfCodewords; codeWord++) {
@@ -763,11 +763,11 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
   }
 
   stop_meas(&gNB->dlsch_precoding_stats);
-  /* output and its parts for each dlsch should be aligned on 64 bytes
-   * should remain a multiple of 64 with enough offset to fit each dlsch
+  /* output and its parts for each dlsch should be aligned on 64 bytes (or 8 * 64 bits)
+   * should remain a multiple of 8 * 64 with enough offset to fit each dlsch
    */
   uint32_t size_output_tb = rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers;
-  return ceil_mod(size_output_tb,64);
+  return ((size_output_tb + 511) >> 9) << 6;
 }
 
 void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
@@ -817,15 +817,15 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
     /// CRC, coding, interleaving and rate matching
     AssertFatal(harq->pdu != NULL, "%4d.%2d no HARQ PDU for PDSCH generation\n", msgTx->frame, msgTx->slot);
 
-    /* output and its parts for each dlsch should be aligned on 64 bytes
-     * => size_output is a sum of parts sizes rounded up to a multiple of 64
+    /* output and its parts for each dlsch should be aligned on 64 bytes (or 8 * 64 bits)
+     * => size_output is a sum of parts sizes rounded up to a multiple of 8 * 64
      */
     size_t size_output_tb = rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * Qm * rel15->nrOfLayers;
-    size_output += ceil_mod(size_output_tb, 64);
+    size_output += ceil_mod(size_output_tb, 8 * 64);
   }
 
-  unsigned char output[size_output] __attribute__((aligned(64)));
-  bzero(output, size_output);
+  unsigned char output[size_output >> 3] __attribute__((aligned(64)));
+  bzero(output, sizeof(output));
 
   start_meas(dlsch_encoding_stats);
   if (nr_dlsch_encoding(gNB,

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -265,15 +265,13 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
 
     TB_parameters->tbslbrm = rel15->maintenance_parms_v3.tbSizeLbrmBytes;
 
+    TB_parameters->output = &output[dlsch_offset >> 3];
     TB_parameters->segments = &segments[segments_offset];
 
-    size_t r_offset = 0;
     for (int r = 0; r < TB_parameters->C; r++) {
       nrLDPC_segment_encoding_parameters_t *segment_parameters = &TB_parameters->segments[r];
       segment_parameters->c = harq->c[r];
       segment_parameters->E = nr_get_E(TB_parameters->G, TB_parameters->C, TB_parameters->Qm, rel15->nrOfLayers, r);
-      segment_parameters->output = &output[dlsch_offset + r_offset];
-      r_offset += segment_parameters->E;
 
       reset_meas(&segment_parameters->ts_interleave);
       reset_meas(&segment_parameters->ts_rate_match);
@@ -282,11 +280,11 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
 
     segments_offset += TB_parameters->C;
 
-    /* output and its parts for each dlsch should be aligned on 64 bytes
-     * => dlsch_offset should remain a multiple of 64 with enough offset to fit each dlsch
+    /* output and its parts for each dlsch should be aligned on 64 bytes (or 8 * 64 bits)
+     * => dlsch_offset should remain a multiple of 8 * 64 with enough offset to fit each dlsch
      */
     const size_t dlsch_size = rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * rel15->qamModOrder[0] * rel15->nrOfLayers;
-    dlsch_offset += ceil_mod(dlsch_size, 64);
+    dlsch_offset += ceil_mod(dlsch_size, 8 * 64);
   }
 
   gNB->nrLDPC_coding_interface.nrLDPC_coding_encoder(&slot_parameters);

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -159,8 +159,8 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     const nfapi_nr_ue_pusch_pdu_t *pusch_pdu = &ulsch->pusch_pdu;
     uint16_t nb_rb = pusch_pdu->rb_size;
     memset(harq_process->f, 0, 14 * nb_rb * 12 * 16);
+    TB_parameters->output = harq_process->f;
 
-    int r_offset = 0;
     for (int r = 0; r < TB_parameters->C; r++) {
       nrLDPC_segment_encoding_parameters_t *segment_parameters = &TB_parameters->segments[r];
       segment_parameters->c = harq_process->c[r];
@@ -169,8 +169,6 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
                                             TB_parameters->Qm,
                                             TB_parameters->nb_layers,
                                             r);
-      segment_parameters->output = harq_process->f + r_offset;
-      r_offset += segment_parameters->E;
 
       reset_meas(&segment_parameters->ts_interleave);
       reset_meas(&segment_parameters->ts_rate_match);