T2 - offload TB for encoding, decoding - on gNB side only, do CRC check on the T2

- modifs in nr_ulsch_decoding - count processed segments, proper crc check
- create NR_LDPC_MAX_NUM_CB constant for max number of codeblocks

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h

@@ -90,10 +90,13 @@ typedef struct nrLDPC_dec_params {
     uint8_t rv;
     uint8_t numMaxIter; /**< Maximum number of iterations */
     int E;
+    uint32_t E_cb[NR_LDPC_MAX_NUM_CB];
     e_nrLDPC_outMode outMode; /**< Output format */
     int crc_type;
     int (*check_crc)(uint8_t* decoded_bytes, uint32_t n, uint8_t crc_type);
     uint8_t setCombIn;
+    uint8_t setCombIn_cb[NR_LDPC_MAX_NUM_CB];
+    uint8_t status_cb[NR_LDPC_MAX_NUM_CB];
 } t_nrLDPC_dec_params;
 
 typedef struct nrLDPCoffload_params {
@@ -102,10 +105,15 @@ typedef struct nrLDPCoffload_params {
     uint16_t Kr;
     uint8_t rv;
     uint32_t E;
+    uint32_t E_cb[NR_LDPC_MAX_NUM_CB];
     uint16_t n_cb;
     uint16_t F; /**< Filler bits */
     uint8_t Qm; /**< Modulation */
+    uint8_t C;
+    uint8_t numMaxIter;
     uint8_t setCombIn;
+    uint8_t setCombIn_cb[NR_LDPC_MAX_NUM_CB];
+    uint8_t *status_cb[NR_LDPC_MAX_NUM_CB];
 } t_nrLDPCoffload_params;
 
 /**

openair1/PHY/CODING/nrLDPC_decoder/nrLDPCdecoder_defs.h

@@ -99,6 +99,8 @@
 /** Maximum number of possible input LLR = NR_LDPC_NCOL_BG1*NR_LDPC_ZMAX */
 #define NR_LDPC_MAX_NUM_LLR 27000
 
+#define NR_LDPC_MAX_NUM_CB 72
+
 // ==============================================================================
 // GLOBAL CONSTANT VARIABLES
 

openair1/PHY/CODING/nrLDPC_defs.h

@@ -60,6 +60,9 @@ typedef struct {
   /// Modulation order
   uint8_t Qm;
   uint32_t E;
+  uint32_t E_cb[NR_LDPC_MAX_NUM_CB];
+  uint32_t Tbslbrm;
+  uint8_t status_cb[NR_LDPC_MAX_NUM_CB];
   unsigned int G;
   // Redundancy version index
   uint8_t rv;

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -360,6 +360,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   impp.harq = harq;
   if (gNB->ldpc_offload_flag) {
     impp.Qm = rel15->qamModOrder[0];
+    impp.Tbslbrm = rel15->maintenance_parms_v3.tbSizeLbrmBytes;
     impp.rv = rel15->rvIndex[0];
     int nb_re_dmrs =
         (rel15->dmrsConfigType == NFAPI_NR_DMRS_TYPE1) ? (6 * rel15->numDmrsCdmGrpsNoData) : (4 * rel15->numDmrsCdmGrpsNoData);
@@ -372,11 +373,9 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
                       rel15->nrOfLayers);
     int r_offset = 0;
     for (int r = 0; r < impp.n_segments; r++) {
-      impp.E = nr_get_E(impp.G, impp.n_segments, impp.Qm, rel15->nrOfLayers, r);
-      uint8_t *f = impp.output + r_offset;
-      ldpc_interface_offload.LDPCencoder(&harq->c[r], &f, &impp);
-      r_offset += impp.E;
+      impp.E_cb[r] = nr_get_E(impp.G, impp.n_segments, impp.Qm, rel15->nrOfLayers, r);
     }
+    ldpc_interface_offload.LDPCencoder(harq->c, &impp.output, &impp);
   } else {
     notifiedFIFO_t nf;
     initNotifiedFIFO(&nf);

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -232,64 +232,58 @@ int decode_offload(PHY_VARS_gNB *phy_vars_gNB,
 {
   NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
   NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
-  int16_t z_ol[LDPC_MAX_CB_SIZE] __attribute__((aligned(16)));
-  int8_t l_ol[LDPC_MAX_CB_SIZE] __attribute__((aligned(16)));
-  uint8_t Qm = pusch_pdu->qam_mod_order;
-  uint8_t n_layers = pusch_pdu->nrOfLayers;
+  int16_t z_ol[NR_LDPC_MAX_NUM_CB * LDPC_MAX_CB_SIZE] __attribute__((aligned(16)));
+  int8_t l_ol[NR_LDPC_MAX_NUM_CB * LDPC_MAX_CB_SIZE] __attribute__((aligned(16)));
+  const int kc = decParams->BG == 2 ? 52 : 68;
+  uint32_t A = (harq_process->TBS) << 3;
   const int Kr = harq_process->K;
   const int Kr_bytes = Kr >> 3;
-  uint32_t A = (harq_process->TBS) << 3;
-  const int kc = decParams->BG == 2 ? 52 : 68;
-  ulsch->max_ldpc_iterations = 20;
-  int decodeIterations = 2;
-  int r_offset = 0, offset = 0;
+  int8_t decodeIterations = 0;
+  int r_offset = 0;
+  int offset = 0;
+  // new data received, set processedSegments to 0
+  if (!decParams->setCombIn)
+    harq_process->processedSegments = 0;
+
   for (int r = 0; r < harq_process->C; r++) {
-    int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
-    memset(harq_process->c[r], 0, Kr_bytes);
-    decParams->R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index,
-                                         E,
-                                         decParams->BG,
-                                         decParams->Z,
-                                         &harq_process->llrLen,
-                                         harq_process->round);
-
-    memcpy(z_ol, ulsch_llr + r_offset, E * sizeof(short));
-    simde__m128i *pv_ol128 = (simde__m128i *)&z_ol;
-    simde__m128i *pl_ol128 = (simde__m128i *)&l_ol;
+    decParams->E_cb[r] = nr_get_E(G, harq_process->C, decParams->Qm, pusch_pdu->nrOfLayers, r);
+    memcpy(&z_ol[offset], ulsch_llr + r_offset, decParams->E_cb[r] * sizeof(short));
+    simde__m128i *pv_ol128 = (simde__m128i *)&z_ol[offset];
+    simde__m128i *pl_ol128 = (simde__m128i *)&l_ol[offset];
     for (int i = 0, j = 0; j < ((kc * harq_process->Z) >> 4) + 1; i += 2, j++) {
       pl_ol128[j] = simde_mm_packs_epi16(pv_ol128[i], pv_ol128[i + 1]);
     }
-    decParams->E = E;
-    decParams->rv = pusch_pdu->pusch_data.rv_index;
     decParams->F = harq_process->F;
-    decParams->Qm = Qm;
-    decodeIterations =
-        ldpc_interface_offload
-            .LDPCdecoder(decParams, harq_pid, ULSCH_id, r, (int8_t *)&pl_ol128[0], (int8_t *)harq_process->c[r], NULL, NULL);
-    if (decodeIterations < 0) {
-      LOG_E(PHY, "ulsch_decoding.c: Problem in LDPC decoder offload\n");
-      return -1;
-    }
-    bool decodeSuccess = check_crc((uint8_t *)harq_process->c[r], lenWithCrc(harq_process->C, A), crcType(harq_process->C, A));
-    if (decodeSuccess) {
-      memcpy(harq_process->b + offset, harq_process->c[r], Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
-      offset += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+    r_offset += decParams->E_cb[r];
+    offset += LDPC_MAX_CB_SIZE;
+  }
+
+  int8_t *p_outDec = calloc(harq_process->C * Kr_bytes, sizeof(int8_t));
+  decodeIterations = ldpc_interface_offload.LDPCdecoder(decParams, harq_pid, ULSCH_id, harq_process->C, (int8_t *)l_ol, p_outDec, NULL, NULL);
+
+  if (decodeIterations < 0) {
+    LOG_E(PHY, "ulsch_decoding.c: Problem in LDPC decoder offload\n");
+    return -1;
+  }
+
+  int offset_b = 0;
+  for (int r = 0; r < harq_process->C; r++) {
+    if (decParams->status_cb[r] == 0 || harq_process->C == 1) {
+      memcpy(harq_process->b + offset_b, &p_outDec[offset_b], Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
       harq_process->processedSegments++;
-    } else {
-      LOG_D(PHY, "uplink segment error %d/%d\n", r, harq_process->C);
-      LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
     }
-    r_offset += E;
+    offset_b += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
   }
+
   bool crc_valid = false;
+  //CRC check made by the T2, no need to perform CRC check for a single code block twice
   if (harq_process->processedSegments == harq_process->C) {
-    // When the number of code blocks is 1 (C = 1) and ulsch_harq->processedSegments = 1, we can assume a good TB because of the
-    // CRC check made by the LDPC for early termination, so, no need to perform CRC check twice for a single code block
-    crc_valid = true;
-    if (harq_process->C > 1) {
-      crc_valid = check_crc(harq_process->b, lenWithCrc(1, A), crcType(1, A));
+    crc_valid = check_crc(harq_process->b, lenWithCrc(1, A), crcType(1, A));
+    if (harq_process->C == 1 && !crc_valid) {
+      harq_process->processedSegments--;
     }
   }
+
   if (crc_valid) {
     LOG_D(PHY, "ULSCH: Setting ACK for slot %d TBS %d\n", ulsch->slot, harq_process->TBS);
     nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 0, 0);
@@ -312,6 +306,7 @@ int decode_offload(PHY_VARS_gNB *phy_vars_gNB,
   }
 
   ulsch->last_iteration_cnt = decodeIterations;
+  free(p_outDec);
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING,0);
   return 0;
 }
@@ -349,7 +344,6 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
   const uint8_t n_layers = pusch_pdu->nrOfLayers;
   // ------------------------------------------------------------------
 
-  harq_process->processedSegments = 0;
   harq_process->TBS = pusch_pdu->pusch_data.tb_size;
 
   t_nrLDPC_dec_params decParams = {.check_crc = check_crc};
@@ -418,6 +412,8 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 
   decParams.Z = harq_process->Z;
   decParams.numMaxIter = ulsch->max_ldpc_iterations;
+  decParams.Qm = Qm;
+  decParams.rv = pusch_pdu->pusch_data.rv_index;
   decParams.outMode = 0;
   decParams.setCombIn = !harq_process->harq_to_be_cleared;
   if (harq_process->harq_to_be_cleared) {
@@ -428,7 +424,7 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
 
   if (phy_vars_gNB->ldpc_offload_flag)
     return decode_offload(phy_vars_gNB, ULSCH_id, ulsch_llr, pusch_pdu, &decParams, harq_pid, G);
-
+  harq_process->processedSegments = 0;
   uint32_t offset = 0, r_offset = 0;
   set_abort(&harq_process->abort_decode, false);
   for (int r = 0; r < harq_process->C; r++) {

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -149,7 +149,7 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_IN);
   }
   start_meas(&ue->ulsch_ldpc_encoding_stats);
-  if (ldpc_interface_offload.LDPCencoder) {
+  if (0) {
     for (int j = 0; j < impp.n_segments; j++) {
       impp.E = nr_get_E(G, impp.n_segments, impp.Qm, ulsch->pusch_pdu.nrOfLayers, j);
       uint8_t *f = harq_process->f + r_offset;