TODO address

doc/analog_beamforming.md

@@ -60,7 +60,7 @@ Therefore, in case of analog beamforming, L2 provides in each channel FAPI messa
 ## L1 implementation
 
 To handle multiple concurrent beams, the buffers containing Tx and Rx data in frequency domain (`txdataF` and `rxdataF`) have been extended by one dimension to contain multiple concurrent beams to be transmitted/received.
-The function `beam_index_allocation`, called by every L1 channel, is responsible to match the FAPI analog beam index to the RU beam index and to store the latter `beam_id` structure, which allocates the beams per symbol, despite L2 only supporting beam change at slot level. At the same time, the function returns the concurrent beam index, to be used to store data in frequency domain buffers. While doing so, the function also checks if there is room for current beam in the list of concurrent beams, which should always be the case, if L2 properly allocated the channels.
+The function `beam_index_allocation` TODO is responsible to match the FAPI analog beam index to the RU beam index and to store the latter `beam_id` structure, which allocates the beams per symbol, despite L2 only supporting beam change at slot level. At the same time, the function returns the concurrent beam index, to be used to store data in frequency domain buffers. While doing so, the function also checks if there is room for current beam in the list of concurrent beams, which should always be the case, if L2 properly allocated the channels.
 
 In case of DAS, since each beam corresponds to a specific antenna port, the `beam_index_allocation` function is simplified in the sense that the beam index corresponds to the antenna port index of the frequency domain buffers.
 

executables/nr-gnb.c

@@ -236,11 +236,11 @@ static size_t dump_L1_meas_stats(PHY_VARS_gNB *gNB, RU_t *ru, char *output, size
   output += print_meas_log(&gNB->l1_tx_proc, "L1 Tx job", NULL, NULL, output, end - output);
   output += print_meas_log(&gNB->l1_rx_proc, "L1 Rx job", NULL, NULL, output, end - output);
   output += print_meas_log(&gNB->phy_proc_tx, "L1 Tx processing", NULL, NULL, output, end - output);
-  output += print_meas_log(&gNB->dlsch_encoding_stats, "DLSCH encoding", NULL, NULL, output, end - output);
-  output += print_meas_log(&gNB->dlsch_scrambling_stats, "DLSCH scrambling", NULL, NULL, output, end-output);
-  output += print_meas_log(&gNB->dlsch_modulation_stats, "DLSCH modulation", NULL, NULL, output, end - output);
-  output += print_meas_log(&gNB->dlsch_resource_mapping_stats, "DLSCH resource mapping", NULL, NULL, output,end-output);
-  output += print_meas_log(&gNB->dlsch_precoding_stats, "DLSCH precoding", NULL, NULL, output,end-output);
+  output += print_meas_log(&gNB->dlsch_stats.encoding, "DLSCH encoding", NULL, NULL, output, end - output);
+  output += print_meas_log(&gNB->dlsch_stats.scrambling, "DLSCH scrambling", NULL, NULL, output, end-output);
+  output += print_meas_log(&gNB->dlsch_stats.modulation, "DLSCH modulation", NULL, NULL, output, end - output);
+  output += print_meas_log(&gNB->dlsch_stats.resource_mapping, "DLSCH resource mapping", NULL, NULL, output,end-output);
+  output += print_meas_log(&gNB->dlsch_stats.precoding, "DLSCH precoding", NULL, NULL, output,end-output);
   output += print_meas_log(&gNB->phy_proc_rx, "L1 Rx processing", NULL, NULL, output, end - output);
   output += print_meas_log(&gNB->ts_deinterleave, "UL segment deinterleaving", NULL, NULL, output, end - output);
   output += print_meas_log(&gNB->ts_rate_unmatch, "UL segment rate recovery", NULL, NULL, output, end - output);
@@ -301,7 +301,7 @@ void *nrL1_stats_thread(void *param) {
   reset_meas(&gNB->l1_tx_proc);
   reset_meas(&gNB->l1_rx_proc);
   reset_meas(&gNB->phy_proc_tx);
-  reset_meas(&gNB->dlsch_encoding_stats);
+  reset_meas(&gNB->dlsch_stats.encoding);
   reset_meas(&gNB->phy_proc_rx);
   reset_meas(&gNB->ts_deinterleave);
   reset_meas(&gNB->ts_rate_unmatch);
@@ -309,10 +309,10 @@ void *nrL1_stats_thread(void *param) {
   reset_meas(&gNB->ul_indication_stats);
   reset_meas(&gNB->slot_indication_stats);
   reset_meas(&gNB->rx_pusch_stats);
-  reset_meas(&gNB->dlsch_scrambling_stats);
-  reset_meas(&gNB->dlsch_modulation_stats);
-  reset_meas(&gNB->dlsch_resource_mapping_stats);
-  reset_meas(&gNB->dlsch_precoding_stats);
+  reset_meas(&gNB->dlsch_stats.scrambling);
+  reset_meas(&gNB->dlsch_stats.modulation);
+  reset_meas(&gNB->dlsch_stats.resource_mapping);
+  reset_meas(&gNB->dlsch_stats.precoding);
   while (!oai_exit) {
     sleep(1);
     if (ftruncate(fileno(fd), 0) != 0 || fseek(fd, 0, SEEK_SET) != 0) {

openair1/PHY/NR_TRANSPORT/nr_dci.c

@@ -51,11 +51,11 @@ static void nr_pdcch_scrambling(uint32_t *in, uint32_t size, uint32_t Nid, uint3
     out[i] = in[i] ^ seq[i];
 }
 
-void nr_generate_dci(PHY_VARS_gNB *gNB,
-                     const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15,
-                     int txdataF_offset,
-                     NR_DL_FRAME_PARMS *frame_parms,
-                     int slot)
+void nr_generate_dci(const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15,
+                     const NR_DL_FRAME_PARMS *frame_parms,
+                     int slot,
+                     uint16_t amp,
+                     c16_t *txdataF)
 {
   // fill reg list per symbol
   int reg_list[MAX_DCI_CORESET][NR_MAX_PDCCH_AGG_LEVEL * NR_NB_REG_PER_CCE];
@@ -83,14 +83,6 @@ void nr_generate_dci(PHY_VARS_gNB *gNB,
     uint32_t cset_start_symb = pdcch_pdu_rel15->StartSymbolIndex;
     uint32_t cset_nsymb = pdcch_pdu_rel15->DurationSymbols;
     int dci_idx = 0;
-    // multi-beam number (for concurrent beams)
-    int bitmap = SL_to_bitmap(cset_start_symb, pdcch_pdu_rel15->DurationSymbols);
-    int beam_nb = beam_index_allocation(gNB->enable_analog_das,
-                                        dci_pdu->precodingAndBeamforming.prgs_list[0].dig_bf_interface_list[0].beam_idx,
-                                        &gNB->common_vars,
-                                        slot,
-                                        frame_parms->symbols_per_slot,
-                                        bitmap);
 
     LOG_D(NR_PHY_DCI, "pdcch: Coreset rb_offset %d, nb_rb %d BWP Start %d\n", rb_offset, n_rb, pdcch_pdu_rel15->BWPStart);
     LOG_D(NR_PHY_DCI,
@@ -178,8 +170,6 @@ void nr_generate_dci(PHY_VARS_gNB *gNB,
 #endif
 
     /// Resource mapping
-    uint16_t amp = gNB->TX_AMP;
-    c16_t *txdataF = gNB->common_vars.txdataF[beam_nb][0] + txdataF_offset;
     if (cset_start_sc >= frame_parms->ofdm_symbol_size)
       cset_start_sc -= frame_parms->ofdm_symbol_size;
 

openair1/PHY/NR_TRANSPORT/nr_dci.h

@@ -26,11 +26,11 @@
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h"
 
-void nr_generate_dci(PHY_VARS_gNB *gNB,
-                     const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15,
-                     int txdataF_offset,
-                     NR_DL_FRAME_PARMS *frame_parms,
-                     int slot);
+void nr_generate_dci(const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15,
+                     const NR_DL_FRAME_PARMS *frame_parms,
+                     int slot,
+                     uint16_t amp,
+                     c16_t *txdataF);
 
 int16_t find_nr_pdcch(int frame,int slot, PHY_VARS_gNB *gNB,find_type_t type);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -46,7 +46,7 @@
 #include <simde/x86/avx512.h>
 #define USE128BIT
 
-static void nr_pdsch_codeword_scrambling(uint8_t *in, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI, uint32_t *out)
+static void nr_pdsch_codeword_scrambling(const uint8_t *in, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI, uint32_t *out)
 {
   nr_codeword_scrambling(in, size, q, Nid, n_RNTI, out);
 }
@@ -337,7 +337,7 @@ static inline void neg_dmrs(c16_t *in, c16_t *out, int sz)
     *out++ = i % 2 ? (c16_t){-in[i].r, -in[i].i} : in[i];
 }
 
-static inline int do_onelayer(NR_DL_FRAME_PARMS *frame_parms,
+static inline int do_onelayer(const NR_DL_FRAME_PARMS *frame_parms,
                               int slot,
                               const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15,
                               int layer,
@@ -453,16 +453,15 @@ static inline int do_onelayer(NR_DL_FRAME_PARMS *frame_parms,
   return txl - txl_start;
 }
 
-static inline void do_txdataF(c16_t **txdataF,
+static inline void do_txdataF(const nfapi_nr_config_request_scf_t *cfg,
+                              c16_t **txdataF,
                               int symbol_sz,
                               c16_t txdataF_precoding[][symbol_sz],
-                              PHY_VARS_gNB *gNB,
                               const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15,
                               int ant,
                               int start_sc,
                               int txdataF_offset_per_symbol)
 {
-  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
   int rb = 0;
   uint16_t subCarrier = start_sc;
   const nfapi_nr_tx_precoding_and_beamforming_t *pb = &rel15->precodingAndBeamforming;
@@ -504,9 +503,8 @@ static inline void do_txdataF(c16_t **txdataF,
         subCarrier -= symbol_sz;
       }
     } else { // non-unitary Precoding
-      AssertFatal(frame_parms->nb_antennas_tx > 1, "No precoding can be done with a single antenna port\n");
       // get the precoding matrix weights:
-      nfapi_nr_pm_pdu_t *pmi_pdu = &gNB->gNB_config.pmi_list.pmi_pdu[pmi - 1]; // pmi 0 is identity matrix
+      nfapi_nr_pm_pdu_t *pmi_pdu = &cfg->pmi_list.pmi_pdu[pmi - 1]; // pmi 0 is identity matrix
       AssertFatal(pmi == pmi_pdu->pm_idx, "PMI %d doesn't match to the one in precoding matrix %d\n", pmi, pmi_pdu->pm_idx);
       AssertFatal(ant < pmi_pdu->num_ant_ports,
                   "Antenna port index %d exceeds precoding matrix AP size %d\n",
@@ -548,13 +546,16 @@ static inline void do_txdataF(c16_t **txdataF,
     rb += rb_step;
   } // RB loop: while(rb < rel15->rbSize)
 }
-static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSCH_t *dlsch, int slot)
+static int do_one_dlsch(const NR_DL_FRAME_PARMS *frame_parms,
+                        const nfapi_nr_config_request_scf_t *cfg,
+                        const unsigned char *input_ptr,
+                        int amp,
+                        NR_gNB_DLSCH_t *dlsch,
+                        int slot,
+                        c16_t **txdataF,
+                        nr_dlsch_stats_t *stats)
 {
-  const int16_t amp = gNB->TX_AMP;
-  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
 
-  time_stats_t *dlsch_scrambling_stats = &gNB->dlsch_scrambling_stats;
-  time_stats_t *dlsch_modulation_stats = &gNB->dlsch_modulation_stats;
   const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
   const int layerSz = frame_parms->N_RB_DL * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB;
   const int symbol_sz=frame_parms->ofdm_symbol_size;
@@ -610,7 +611,7 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
   c16_t mod_symbs[rel15->NrOfCodewords][encoded_length] __attribute__((aligned(64)));
   for (int codeWord = 0; codeWord < rel15->NrOfCodewords; codeWord++) {
     /// scrambling
-    start_meas(dlsch_scrambling_stats);
+    start_meas(&stats->scrambling);
     uint32_t scrambled_output[(encoded_length >> 5) + 4]; // modulator acces by 4 bytes in some cases
     memset(scrambled_output, 0, sizeof(scrambled_output));
     nr_pdsch_codeword_scrambling(input_ptr, encoded_length, codeWord, rel15->dataScramblingId, rel15->rnti, scrambled_output);
@@ -624,12 +625,12 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
     }
 #endif
 
-    stop_meas(dlsch_scrambling_stats);
+    stop_meas(&stats->scrambling);
     /// Modulation
-    start_meas(dlsch_modulation_stats);
+    start_meas(&stats->modulation);
     nr_modulation(scrambled_output, encoded_length, Qm, (int16_t *)mod_symbs[codeWord]);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_MODULATION, 0);
-    stop_meas(dlsch_modulation_stats);
+    stop_meas(&stats->modulation);
 #ifdef DEBUG_DLSCH
     printf("PDSCH Modulation: Qm %d(%d)\n", Qm, nb_re);
     for (int i = 0; i < nb_re; i += 8) {
@@ -641,7 +642,7 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
 #endif
   }
 
-  start_meas(&gNB->dlsch_pdsch_generation_stats);
+  start_meas(&stats->pdsch_generation);
   /// Resource mapping
   // Non interleaved VRB to PRB mapping
   uint16_t start_sc = frame_parms->first_carrier_offset + (rel15->rbStart + rel15->BWPStart) * NR_NB_SC_PER_RB;
@@ -663,34 +664,16 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
   c16_t mod_dmrs[(n_dmrs+63)&~63] __attribute__((aligned(64)));
   unsigned int re_beginning_of_symbol = 0;
 
-  start_meas(&gNB->dlsch_layer_mapping_stats);
+  start_meas(&stats->layer_mapping);
   int layerSz2 = (layerSz + 63) & ~63;
   c16_t tx_layers[rel15->nrOfLayers][layerSz2] __attribute__((aligned(64)));
   memset(tx_layers, 0, sizeof(tx_layers));
   nr_layer_mapping(rel15->NrOfCodewords, encoded_length, mod_symbs, rel15->nrOfLayers, layerSz2, nb_re, tx_layers);
 
-  /// Layer Precoding and Antenna port mapping
-  // tx_layers 1-8 are mapped on antenna ports 1000-1007
-  // The precoding info is supported by nfapi such as num_prgs, prg_size, prgs_list and pm_idx
-  // The same precoding matrix is applied on prg_size RBs, Thus
-  //        pmi = prgs_list[rbidx/prg_size].pm_idx, rbidx =0,...,rbSize-1
-  // The Precoding matrix:
-  // The Codebook Type I
-  const nfapi_nr_tx_precoding_and_beamforming_t *pb = &rel15->precodingAndBeamforming;
-  // beam number in multi-beam scenario (concurrent beams)
-  int bitmap = SL_to_bitmap(rel15->StartSymbolIndex, rel15->NrOfSymbols);
-  int beam_nb = beam_index_allocation(gNB->enable_analog_das,
-                                      pb->prgs_list[0].dig_bf_interface_list[0].beam_idx,
-                                      &gNB->common_vars,
-                                      slot,
-                                      frame_parms->symbols_per_slot,
-                                      bitmap);
-
-  c16_t **txdataF = gNB->common_vars.txdataF[beam_nb];
-  stop_meas(&gNB->dlsch_layer_mapping_stats);
+  stop_meas(&stats->layer_mapping);
   // Loop Over OFDM symbols:
   for (int l_symbol = rel15->StartSymbolIndex; l_symbol < rel15->StartSymbolIndex + rel15->NrOfSymbols; l_symbol++) {
-    start_meas(&gNB->dlsch_resource_mapping_stats);
+    start_meas(&stats->resource_mapping);
     int l_prime = 0; // single symbol layer 0
     int l_overline = get_l0(rel15->dlDmrsSymbPos);
 
@@ -755,16 +738,16 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
                              mod_dmrs + dmrs_idx);
     } // layer loop
     re_beginning_of_symbol += layer_sz;
-    stop_meas(&gNB->dlsch_resource_mapping_stats);
+    stop_meas(&stats->resource_mapping);
 
-    start_meas(&gNB->dlsch_precoding_stats);
+    start_meas(&stats->precoding);
     for (int ant = 0; ant < frame_parms->nb_antennas_tx; ant++) {
       const size_t txdataF_offset_per_symbol = l_symbol * symbol_sz + txdataF_offset;
-      do_txdataF(txdataF, symbol_sz, txdataF_precoding, gNB, rel15, ant, start_sc, txdataF_offset_per_symbol);
+      do_txdataF(cfg, txdataF, symbol_sz, txdataF_precoding, rel15, ant, start_sc, txdataF_offset_per_symbol);
     }
-    stop_meas(&gNB->dlsch_precoding_stats);
+    stop_meas(&stats->precoding);
   }
-  stop_meas(&gNB->dlsch_pdsch_generation_stats);
+  stop_meas(&stats->pdsch_generation);
   /* 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
    */
@@ -774,15 +757,9 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
 
 void nr_generate_pdsch(PHY_VARS_gNB *gNB, int n_dlsch, NR_gNB_DLSCH_t *dlsch_array, int frame, int slot)
 {
-  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
-  time_stats_t *dlsch_encoding_stats = &gNB->dlsch_encoding_stats;
-  time_stats_t *tinput = &gNB->tinput;
-  time_stats_t *tprep = &gNB->tprep;
-  time_stats_t *tparity = &gNB->tparity;
-  time_stats_t *toutput = &gNB->toutput;
-  time_stats_t *dlsch_rate_matching_stats = &gNB->dlsch_rate_matching_stats;
-  time_stats_t *dlsch_interleaving_stats = &gNB->dlsch_interleaving_stats;
-  time_stats_t *dlsch_segmentation_stats = &gNB->dlsch_segmentation_stats;
+  const NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
+  const nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
+  nr_dlsch_stats_t *stats = &gNB->dlsch_stats;
 
   size_t size_output = 0;
 
@@ -827,29 +804,18 @@ void nr_generate_pdsch(PHY_VARS_gNB *gNB, int n_dlsch, NR_gNB_DLSCH_t *dlsch_arr
   unsigned char output[size_output >> 3] __attribute__((aligned(64)));
   bzero(output, sizeof(output));
 
-  start_meas(dlsch_encoding_stats);
-  if (nr_dlsch_encoding(gNB,
-                        n_dlsch,
-                        dlsch_array,
-                        frame,
-                        slot,
-                        frame_parms,
-                        output,
-                        tinput,
-                        tprep,
-                        tparity,
-                        toutput,
-                        dlsch_rate_matching_stats,
-                        dlsch_interleaving_stats,
-                        dlsch_segmentation_stats)
-      == -1) {
+  start_meas(&stats->encoding);
+  nrLDPC_coding_encoder_t *enc = gNB->nrLDPC_coding_interface.nrLDPC_coding_encoder;
+  if (nr_dlsch_encoding(enc, &gNB->threadPool, n_dlsch, dlsch_array, frame, slot, frame_parms, output, stats) == -1) {
     return;
   }
-  stop_meas(dlsch_encoding_stats);
+  stop_meas(&stats->encoding);
 
   unsigned char *output_ptr = output;
+  int beam_nb = 0; // TODO
+  c16_t **txdataF = gNB->common_vars.txdataF[beam_nb];
   for (int i = 0; i < n_dlsch; i++) {
-    output_ptr += do_one_dlsch(output_ptr, gNB, &dlsch_array[i], slot);
+    output_ptr += do_one_dlsch(frame_parms, cfg, output_ptr, gNB->TX_AMP, &dlsch_array[i], slot, txdataF, stats);
   }
 }
 

openair1/PHY/NR_TRANSPORT/nr_dlsch.h

@@ -37,20 +37,15 @@
 
 void nr_generate_pdsch(PHY_VARS_gNB *gNB, int n_dlsch, NR_gNB_DLSCH_t *dlsch_array, int frame, int slot);
 
-int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
+int nr_dlsch_encoding(nrLDPC_coding_encoder_t *encoder,
+                      tpool_t *threadPool,
                       int n_dlsch,
                       NR_gNB_DLSCH_t *dlsch_array,
                       int frame,
                       uint8_t slot,
-                      NR_DL_FRAME_PARMS *frame_parms,
+                      const NR_DL_FRAME_PARMS *frame_parms,
                       unsigned char *output,
-                      time_stats_t *tinput,
-                      time_stats_t *tprep,
-                      time_stats_t *tparity,
-                      time_stats_t *toutput,
-                      time_stats_t *dlsch_rate_matching_stats,
-                      time_stats_t *dlsch_interleaving_stats,
-                      time_stats_t *dlsch_segmentation_stats);
+                      nr_dlsch_stats_t *stats);
 
 void dump_pdsch_stats(FILE *fd,PHY_VARS_gNB *gNB);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -103,20 +103,15 @@ NR_gNB_DLSCH_t new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms, uint16_t N_RB)
   return (dlsch);
 }
 
-int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
+int nr_dlsch_encoding(nrLDPC_coding_encoder_t encoder,
+                      tpool_t *threadPool,
                       int n_dlsch,
                       NR_gNB_DLSCH_t *dlsch_array,
                       int frame,
                       uint8_t slot,
-                      NR_DL_FRAME_PARMS *frame_parms,
+                      const NR_DL_FRAME_PARMS *frame_parms,
                       unsigned char *output,
-                      time_stats_t *tinput,
-                      time_stats_t *tprep,
-                      time_stats_t *tparity,
-                      time_stats_t *toutput,
-                      time_stats_t *dlsch_rate_matching_stats,
-                      time_stats_t *dlsch_interleaving_stats,
-                      time_stats_t *dlsch_segmentation_stats)
+                      nr_dlsch_stats_t *stats)
 {
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_IN);
 
@@ -149,8 +144,10 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     }
 
     NR_gNB_PHY_STATS_t *phy_stats = NULL;
+    /* TODO
     if (rel15->rnti != 0xFFFF)
       phy_stats = get_phy_stats(gNB, rel15->rnti);
+      */
 
     if (phy_stats) {
       phy_stats->frame = frame;
@@ -190,7 +187,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     TB_parameters->harq_unique_pid = i;
     TB_parameters->BG = rel15->maintenance_parms_v3.ldpcBaseGraph;
     TB_parameters->A = A;
-    start_meas(dlsch_segmentation_stats);
+    start_meas(&stats->segmentation);
     TB_parameters->Kb = nr_segmentation(dlsch->b,
                                         dlsch->c,
                                         B,
@@ -199,7 +196,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
                                         &TB_parameters->Z,
                                         &TB_parameters->F,
                                         TB_parameters->BG);
-    stop_meas(dlsch_segmentation_stats);
+    stop_meas(&stats->segmentation);
 
     if (TB_parameters->C > MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER * rel15->nrOfLayers) {
       LOG_E(PHY, "nr_segmentation.c: too many segments %d, B %d\n", TB_parameters->C, B);
@@ -274,20 +271,20 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   nrLDPC_slot_encoding_parameters_t slot_parameters = {.frame = frame,
                                                        .slot = slot,
                                                        .nb_TBs = n_dlsch,
-                                                       .threadPool = &gNB->threadPool,
-                                                       .tinput = tinput,
-                                                       .tprep = tprep,
-                                                       .tparity = tparity,
-                                                       .toutput = toutput,
+                                                       .threadPool = threadPool,
+                                                       .tinput = &stats->tinput,
+                                                       .tprep = &stats->tprep,
+                                                       .tparity = &stats->tparity,
+                                                       .toutput = &stats->toutput,
                                                        .TBs = TBs};
-  gNB->nrLDPC_coding_interface.nrLDPC_coding_encoder(&slot_parameters);
+  encoder(&slot_parameters);
 
   for (int i = 0; i < n_dlsch; i++) {
     nrLDPC_TB_encoding_parameters_t *TB_parameters = &TBs[i];
     for (int r = 0; r < TB_parameters->C; r++) {
       nrLDPC_segment_encoding_parameters_t *segment_parameters = &TB_parameters->segments[r];
-      merge_meas(dlsch_interleaving_stats, &segment_parameters->ts_interleave);
-      merge_meas(dlsch_rate_matching_stats, &segment_parameters->ts_rate_match);
+      merge_meas(&stats->interleaving, &segment_parameters->ts_interleave);
+      merge_meas(&stats->rate_matching, &segment_parameters->ts_rate_match);
       // merge_meas(, &segment_parameters->ts_ldpc_encode);
     }
   }

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -51,8 +51,8 @@ void nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
                            c16_t *txdataF,
                            int16_t amp,
                            uint8_t ssb_start_symbol,
-                           nfapi_nr_config_request_scf_t *config,
-                           NR_DL_FRAME_PARMS *frame_parms)
+                           const nfapi_nr_config_request_scf_t *config,
+                           const NR_DL_FRAME_PARMS *frame_parms)
 {
   int k,l;
   //int16_t a;
@@ -228,14 +228,15 @@ uint32_t nr_pbch_extra_byte_generation(int sfn, int n_hf, int ssb_index, int ssb
   return extra_byte;
 }
 
-void nr_generate_pbch(PHY_VARS_gNB *gNB,
+void nr_generate_pbch(int16_t amp,
+                      const uint8_t *interleaver,
                       const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
                       c16_t *txdataF,
                       uint8_t ssb_start_symbol,
                       uint8_t n_hf,
                       int sfn,
-                      nfapi_nr_config_request_scf_t *config,
-                      NR_DL_FRAME_PARMS *frame_parms)
+                      const nfapi_nr_config_request_scf_t *config,
+                      const NR_DL_FRAME_PARMS *frame_parms)
 {
   LOG_D(PHY, "PBCH generation started\n");
   ///Payload generation
@@ -261,7 +262,6 @@ void nr_generate_pbch(PHY_VARS_gNB *gNB,
 
   // Payload interleaving
   uint32_t pbch_a_interleaved = 0;
-  uint8_t *interleaver = gNB->nr_pbch_interleaver;
   for (int i = 0; i < NR_POLAR_PBCH_PAYLOAD_BITS; i++) {
     pbch_a_interleaved |= ((pbch_a >> i) & 1) << (*(interleaver + i));
   }
@@ -336,7 +336,6 @@ void nr_generate_pbch(PHY_VARS_gNB *gNB,
   int k = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier;
   int l = ssb_start_symbol + 1;
   int m = 0;
-  int16_t amp = gNB->TX_AMP;
 
   for (int ssb_sc_idx = 0; ssb_sc_idx < 240; ssb_sc_idx++) {
     if ((ssb_sc_idx&3) == nushift) {  //skip DMRS

openair1/PHY/NR_TRANSPORT/nr_pss.c

@@ -27,8 +27,8 @@
 int nr_generate_pss(  c16_t *txdataF,
                       int16_t amp,
                       uint8_t ssb_start_symbol,
-                      nfapi_nr_config_request_scf_t* config,
-                      NR_DL_FRAME_PARMS *frame_parms)
+                      const nfapi_nr_config_request_scf_t* config,
+                      const NR_DL_FRAME_PARMS *frame_parms)
 {
   int16_t x[NR_PSS_LENGTH];
   const int x_initial[7] = {0, 1, 1 , 0, 1, 1, 1};

openair1/PHY/NR_TRANSPORT/nr_scrambling.c

@@ -24,7 +24,7 @@
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #define DEBUG_SCRAMBLING(a)
 //#define DEBUG_SCRAMBLING(a) a
-void nr_codeword_scrambling(uint8_t *in,
+void nr_codeword_scrambling(const uint8_t *in,
                             uint32_t size,
                             uint8_t q,
                             uint32_t Nid,

openair1/PHY/NR_TRANSPORT/nr_sss.c

@@ -26,8 +26,8 @@
 int nr_generate_sss(  c16_t *txdataF,
                       int16_t amp,
                       uint8_t ssb_start_symbol,
-                      nfapi_nr_config_request_scf_t* config,
-                      NR_DL_FRAME_PARMS *frame_parms)
+                      const nfapi_nr_config_request_scf_t* config,
+                      const NR_DL_FRAME_PARMS *frame_parms)
 {
   int16_t x0[NR_SSS_LENGTH];
   int16_t x1[NR_SSS_LENGTH];

openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h

@@ -69,7 +69,7 @@ void compute_nr_prach_seq(uint8_t short_sequence, uint8_t num_sequences, uint8_t
 
 void nr_fill_du(uint16_t N_ZC, const uint16_t *prach_root_sequence_map, uint16_t nr_du[NR_PRACH_SEQ_LEN_L - 1]);
 
-void nr_codeword_scrambling(uint8_t *in,
+void nr_codeword_scrambling(const uint8_t *in,
                             uint32_t size,
                             uint8_t q,
                             uint32_t Nid,

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -56,8 +56,8 @@ int nr_generate_prs(int slot,
 int nr_generate_pss(c16_t *txdataF,
                     int16_t amp,
                     uint8_t ssb_start_symbol,
-                    nfapi_nr_config_request_scf_t *config,
-                    NR_DL_FRAME_PARMS *frame_parms);
+                    const nfapi_nr_config_request_scf_t *config,
+                    const NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn int nr_generate_sss
@@ -68,8 +68,8 @@ int nr_generate_pss(c16_t *txdataF,
 int nr_generate_sss(c16_t *txdataF,
                     int16_t amp,
                     uint8_t ssb_start_symbol,
-                    nfapi_nr_config_request_scf_t *config,
-                    NR_DL_FRAME_PARMS *frame_parms);
+                    const nfapi_nr_config_request_scf_t *config,
+                    const NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn void nr_generate_pbch_dmrs
@@ -80,22 +80,23 @@ void nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
                            c16_t *txdataF,
                            int16_t amp,
                            uint8_t ssb_start_symbol,
-                           nfapi_nr_config_request_scf_t *config,
-                           NR_DL_FRAME_PARMS *frame_parms);
+                           const nfapi_nr_config_request_scf_t *config,
+                           const NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn void nr_generate_pbch
 \brief Generation of the PBCH
 @param
  */
-void nr_generate_pbch(PHY_VARS_gNB *gNB,
+void nr_generate_pbch(int16_t amp,
+                      const uint8_t *interleaver,
                       const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
                       c16_t *txdataF,
                       uint8_t ssb_start_symbol,
                       uint8_t n_hf,
                       int sfn,
-                      nfapi_nr_config_request_scf_t *config,
-                      NR_DL_FRAME_PARMS *frame_parms);
+                      const nfapi_nr_config_request_scf_t *config,
+                      const NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn int nr_generate_pbch

openair1/PHY/defs_gNB.h

@@ -111,6 +111,8 @@ typedef struct {
   uint8_t *f;
   /// REs unavailable for DLSCH (overlapping with PTRS, CSIRS etc.)
   uint32_t unav_res;
+  /// output of freq
+  //c16_t **txdataF; TODO
 } NR_gNB_DLSCH_t;
 
 typedef struct {
@@ -359,6 +361,23 @@ typedef struct {
 // therefore, we can have up to "number of UE" UCI PDUs
 #define MAX_NUM_NR_UCI_PDUS MAX_MOBILES_PER_GNB
 
+typedef struct {
+  time_stats_t encoding;
+  time_stats_t modulation;
+  time_stats_t scrambling;
+  time_stats_t pdsch_generation;
+  time_stats_t layer_mapping;
+  time_stats_t resource_mapping;
+  time_stats_t precoding;
+  time_stats_t rate_matching;
+  time_stats_t interleaving;
+  time_stats_t segmentation;
+  time_stats_t tinput;
+  time_stats_t tprep;
+  time_stats_t tparity;
+  time_stats_t toutput;
+} nr_dlsch_stats_t;
+
 /// Top-level PHY Data Structure for gNB
 typedef struct PHY_VARS_gNB_s {
   /// Module ID indicator for this instance
@@ -452,21 +471,7 @@ typedef struct PHY_VARS_gNB_s {
   time_stats_t phy_proc_rx;
   time_stats_t rx_prach;
 
-  time_stats_t dlsch_encoding_stats;
-  time_stats_t dlsch_modulation_stats;
-  time_stats_t dlsch_scrambling_stats;
-  time_stats_t dlsch_pdsch_generation_stats;
-  time_stats_t dlsch_layer_mapping_stats;
-  time_stats_t dlsch_resource_mapping_stats;
-  time_stats_t dlsch_precoding_stats;
-  time_stats_t tinput;
-  time_stats_t tprep;
-  time_stats_t tparity;
-  time_stats_t toutput;
-  
-  time_stats_t dlsch_rate_matching_stats;
-  time_stats_t dlsch_interleaving_stats;
-  time_stats_t dlsch_segmentation_stats;
+  nr_dlsch_stats_t dlsch_stats;
 
   time_stats_t dci_generation_stats;
   time_stats_t phase_comp_stats;

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -102,9 +102,28 @@ int beam_index_allocation(bool das,
   return idx;
 }
 
-void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame, int slot, const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu)
+static int get_beam(PHY_VARS_gNB *gNB, int slot, uint8_t start_sym, uint8_t len_sym, uint16_t beam_idx)
+{
+  /* TODO is this really necessary? FAPI message should tell us precoding +
+   * digBF weight (indices), and L1 should simply process this. I don't see a
+   * reason to have common_vars->beam_id, or why something should be checked.
+   * Surely, if something does not align, we should not assert(!) */
+  int bitmap = SL_to_bitmap(start_sym, len_sym);
+  int syms = gNB->frame_parms.symbols_per_slot;
+  int beam = beam_index_allocation(gNB->enable_analog_das, beam_idx, &gNB->common_vars, slot, syms, bitmap);
+  DevAssert(beam >= 0);
+  return beam;
+}
+
+void nr_common_signal_procedures(NR_DL_FRAME_PARMS *fp, // TODO: should be const
+                                 const nfapi_nr_config_request_scf_t *cfg,
+                                 int frame,
+                                 int slot,
+                                 const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
+                                 const uint8_t *pbch_interleaver,
+                                 int amp,
+                                 c16_t *txdataF)
 {
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   const nfapi_nr_dl_tti_ssb_pdu_rel15_t *pdu = &ssb_pdu->ssb_pdu_rel15;
   uint8_t ssb_index = pdu->SsbBlockIndex;
   LOG_D(PHY,"common_signal_procedures: frame %d, slot %d ssb index %d\n", frame, slot, ssb_index);
@@ -117,7 +136,6 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame, int slot, const n
   // for FR1 offsetToPointA and k_SSB are expressed in terms of 15 kHz SCS
   // for FR2 offsetToPointA is expressed in terms of 60 kHz SCS and k_SSB expressed in terms of the subcarrier spacing provided
   // by the higher-layer parameter subCarrierSpacingCommon
-  nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
   const int scs = cfg->ssb_config.scs_common.value;
   const int prb_offset = (fp->freq_range == FR1) ? pdu->ssbOffsetPointA >> scs : pdu->ssbOffsetPointA >> (scs - 2);
   const int sc_offset = (fp->freq_range == FR1) ? pdu->SsbSubcarrierOffset >> scs : pdu->SsbSubcarrierOffset;
@@ -153,28 +171,16 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame, int slot, const n
         fp->ssb_start_subcarrier);
 
   LOG_D(PHY,"SS TX: frame %d, slot %d, start_symbol %d\n", frame, slot, ssb_start_symbol);
-  const nfapi_nr_tx_precoding_and_beamforming_t *pb = &pdu->precoding_and_beamforming;
-  c16_t ***txdataF = gNB->common_vars.txdataF;
-  int txdataF_offset = slot * fp->samples_per_slot_wCP;
-  // beam number in a scenario with multiple concurrent beams
-  int bitmap = SL_to_bitmap(ssb_start_symbol, 4); // 4 ssb symbols
-  int beam_nb = beam_index_allocation(gNB->enable_analog_das,
-                                      pb->prgs_list[0].dig_bf_interface_list[0].beam_idx,
-                                      &gNB->common_vars,
-                                      slot,
-                                      fp->symbols_per_slot,
-                                      bitmap);
-
-  nr_generate_pss(&txdataF[beam_nb][0][txdataF_offset], gNB->TX_AMP, ssb_start_symbol, cfg, fp);
-  nr_generate_sss(&txdataF[beam_nb][0][txdataF_offset], gNB->TX_AMP, ssb_start_symbol, cfg, fp);
+  nr_generate_pss(txdataF, amp, ssb_start_symbol, cfg, fp);
+  nr_generate_sss(txdataF, amp, ssb_start_symbol, cfg, fp);
 
   uint16_t slots_per_hf = (fp->slots_per_frame) >> 1;
   int n_hf = slot < slots_per_hf ? 0 : 1;
 
   int hf = fp->Lmax == 4 ? n_hf : 0;
-  nr_generate_pbch_dmrs(nr_gold_pbch(fp->Lmax, gNB->gNB_config.cell_config.phy_cell_id.value, hf, ssb_index & 7),
-                        &txdataF[beam_nb][0][txdataF_offset],
-                        gNB->TX_AMP,
+  nr_generate_pbch_dmrs(nr_gold_pbch(fp->Lmax, cfg->cell_config.phy_cell_id.value, hf, ssb_index & 7),
+                        txdataF,
+                        amp,
                         ssb_start_symbol,
                         cfg,
                         fp);
@@ -189,9 +195,10 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame, int slot, const n
   }
 #endif
 
-  nr_generate_pbch(gNB,
+  nr_generate_pbch(amp,
+                   pbch_interleaver,
                    ssb_pdu,
-                   &txdataF[beam_nb][0][txdataF_offset],
+                   txdataF,
                    ssb_start_symbol,
                    n_hf,
                    frame,
@@ -210,10 +217,12 @@ void clear_slot_beamid(PHY_VARS_gNB *gNB, int slot)
   }
 }
 
-static void nr_generate_csi_rs_gNB(PHY_VARS_gNB *gNB,
+static void nr_generate_csi_rs_gNB(const NR_DL_FRAME_PARMS *frame_parms,
                                    int slot,
                                    const nfapi_nr_config_request_scf_t *cfg,
-                                   const nfapi_nr_dl_tti_csi_rs_pdu *csi_rs_pdu)
+                                   const nfapi_nr_dl_tti_csi_rs_pdu *csi_rs_pdu,
+                                   int amp,
+                                   c16_t **txdataF)
 {
   const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params = &csi_rs_pdu->csi_rs_pdu_rel15;
   if (csi_params->csi_type == 2) // ZP-CSI
@@ -221,21 +230,14 @@ static void nr_generate_csi_rs_gNB(PHY_VARS_gNB *gNB,
 
   csi_mapping_parms_t mapping_parms =
       get_csi_mapping_parms(csi_params->row, csi_params->freq_domain, csi_params->symb_l0, csi_params->symb_l1);
-  const nfapi_nr_tx_precoding_and_beamforming_t *pb = &csi_params->precodingAndBeamforming;
   int csi_bitmap = 0;
   int lprime_num = mapping_parms.lprime + 1;
   for (int j = 0; j < mapping_parms.size; j++)
     csi_bitmap |= ((1 << lprime_num) - 1) << mapping_parms.loverline[j];
-  int beam_nb = beam_index_allocation(gNB->enable_analog_das,
-                                      pb->prgs_list[0].dig_bf_interface_list[0].beam_idx,
-                                      &gNB->common_vars,
-                                      slot,
-                                      gNB->frame_parms.symbols_per_slot,
-                                      csi_bitmap);
 
-  nr_generate_csi_rs(&gNB->frame_parms,
+  nr_generate_csi_rs(frame_parms,
                      &mapping_parms,
-                     gNB->TX_AMP,
+                     amp,
                      slot,
                      csi_params->freq_density,
                      csi_params->start_rb,
@@ -246,7 +248,7 @@ static void nr_generate_csi_rs_gNB(PHY_VARS_gNB *gNB,
                      csi_params->scramb_id,
                      csi_params->power_control_offset_ss,
                      csi_params->cdm_type,
-                     gNB->common_vars.txdataF[beam_nb]);
+                     txdataF);
 }
 
 void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
@@ -288,21 +290,36 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
     }
   }
 
-  for (int i = 0; i < UL_dci_req->numPdus; ++i)
-    nr_generate_dci(gNB, &UL_dci_req->ul_dci_pdu_list[i].pdcch_pdu.pdcch_pdu_rel15, txdataF_offset, &gNB->frame_parms, slot);
+  c16_t ***txdataF = gNB->common_vars.txdataF;
+  for (int i = 0; i < UL_dci_req->numPdus; ++i) {
+    const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdu = &UL_dci_req->ul_dci_pdu_list[i].pdcch_pdu.pdcch_pdu_rel15;
+    uint16_t beam_idx = pdu->precodingAndBeamforming.prgs_list[0].dig_bf_interface_list[0].beam_idx;
+    int beam_nb = get_beam(gNB, slot, pdu->StartSymbolIndex, pdu->DurationSymbols, beam_idx);
+    nr_generate_dci(pdu, &gNB->frame_parms, slot, gNB->TX_AMP, txdataF[beam_nb][0] + txdataF_offset);
+  }
 
   int num_pdsch = 0;
   for (int i = 0; i < DL_req->dl_tti_request_body.nPDUs; ++i) {
     const nfapi_nr_dl_tti_request_pdu_t *dl_tti_pdu = &DL_req->dl_tti_request_body.dl_tti_pdu_list[i];
     switch (dl_tti_pdu->PDUType) {
       case NFAPI_NR_DL_TTI_SSB_PDU_TYPE:
-        nr_common_signal_procedures(gNB, frame, slot, &dl_tti_pdu->ssb_pdu);
-        break;
-      case NFAPI_NR_DL_TTI_PDCCH_PDU_TYPE:
-        nr_generate_dci(gNB, &dl_tti_pdu->pdcch_pdu.pdcch_pdu_rel15, txdataF_offset, &gNB->frame_parms, slot);
+        // TODO: do beam selection
+        nr_common_signal_procedures(&gNB->frame_parms,
+                                    &gNB->gNB_config,
+                                    frame,
+                                    slot,
+                                    &dl_tti_pdu->ssb_pdu,
+                                    gNB->nr_pbch_interleaver,
+                                    gNB->TX_AMP,
+                                    txdataF[0] + txdataF_offset);
         break;
+      case NFAPI_NR_DL_TTI_PDCCH_PDU_TYPE: {
+        const nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdu = &dl_tti_pdu->pdcch_pdu.pdcch_pdu_rel15;
+        nr_generate_dci(pdu, &gNB->frame_parms, slot, gNB->TX_AMP, txdataF[0] + txdataF_offset);
+        } break;
       case NFAPI_NR_DL_TTI_CSI_RS_PDU_TYPE:
-        nr_generate_csi_rs_gNB(gNB, slot, cfg, &dl_tti_pdu->csi_rs_pdu);
+        // TODO: do beam selection
+        nr_generate_csi_rs_gNB(&gNB->frame_parms, slot, cfg, &dl_tti_pdu->csi_rs_pdu, gNB->TX_AMP, txdataF);
         break;
       case NFAPI_NR_DL_TTI_PDSCH_PDU_TYPE: {
         int tx_data_idx = dl_tti_pdu->pdsch_pdu.pdsch_pdu_rel15.pduIndex;
@@ -328,7 +345,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
   if (num_pdsch > 0) {
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DLSCH,1);
     LOG_D(PHY, "PDSCH generation started (%d) in frame %d.%d\n", num_pdsch, frame, slot);
-    nr_generate_pdsch(gNB, num_pdsch, gNB->dlsch, frame, slot);
+    nr_generate_pdsch(gNB, num_pdsch, gNB->dlsch, frame, slot); // TODO
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DLSCH,0);
   }
 

openair1/SCHED_NR/sched_nr.h

@@ -43,7 +43,14 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 void nr_save_ul_tti_req(PHY_VARS_gNB *gNB, nfapi_nr_ul_tti_request_t *UL_tti_req);
 int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, NR_UL_IND_t *UL_INFO);
 void L1_nr_prach_procedures(PHY_VARS_gNB *gNB, int frame, int slot, nfapi_nr_rach_indication_t *rach_ind);
-void nr_common_signal_procedures (PHY_VARS_gNB *gNB,int frame,int slot, const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu);
+void nr_common_signal_procedures(NR_DL_FRAME_PARMS *fp, // TODO: should be const
+                                 const nfapi_nr_config_request_scf_t *cfg,
+                                 int frame,
+                                 int slot,
+                                 const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
+                                 const uint8_t *pbch_interleaver,
+                                 int amp,
+                                 c16_t *txdataF);
 void nr_feptx_ofdm(RU_t *ru,int frame_tx,int tti_tx);
 void nr_feptx0(RU_t *ru,int tti_tx,int first_symbol, int num_symbols, int aa);
 void nr_feptx_prec(RU_t *ru,int frame_tx,int tti_tx);

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -516,7 +516,9 @@ int main(int argc, char **argv)
         unsigned char output[nb_rb * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * NR_MAX_NB_LAYERS] __attribute__((aligned(64)));
         bzero(output, sizeof(output));
 	if (input_fd == NULL) {
-	  nr_dlsch_encoding(gNB, 1, dlsch, frame, slot, frame_parms, output, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+    nr_dlsch_stats_t stats = {0};
+    nrLDPC_coding_encoder_t *enc = gNB->nrLDPC_coding_interface.nrLDPC_coding_encoder;
+	  nr_dlsch_encoding(enc, &gNB->threadPool, 1, dlsch, frame, slot, frame_parms, output, &stats);
 	}
 
 	for (SNR = snr0; SNR < snr1 && !stop; SNR += snr_step) {

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -1022,21 +1022,21 @@ int main(int argc, char **argv)
 
     varArray_t *table_tx=initVarArray(1000,sizeof(double));
     reset_meas(&gNB->phy_proc_tx);
-    reset_meas(&gNB->dlsch_scrambling_stats);
-    reset_meas(&gNB->dlsch_interleaving_stats);
-    reset_meas(&gNB->dlsch_rate_matching_stats);
-    reset_meas(&gNB->dlsch_segmentation_stats);
-    reset_meas(&gNB->dlsch_modulation_stats);
-    reset_meas(&gNB->dlsch_pdsch_generation_stats);
-    reset_meas(&gNB->dlsch_precoding_stats);
-    reset_meas(&gNB->dlsch_layer_mapping_stats);
-    reset_meas(&gNB->dlsch_resource_mapping_stats);
-    reset_meas(&gNB->dlsch_encoding_stats);
+    reset_meas(&gNB->dlsch_stats.scrambling);
+    reset_meas(&gNB->dlsch_stats.interleaving);
+    reset_meas(&gNB->dlsch_stats.rate_matching);
+    reset_meas(&gNB->dlsch_stats.segmentation);
+    reset_meas(&gNB->dlsch_stats.modulation);
+    reset_meas(&gNB->dlsch_stats.pdsch_generation);
+    reset_meas(&gNB->dlsch_stats.precoding);
+    reset_meas(&gNB->dlsch_stats.layer_mapping);
+    reset_meas(&gNB->dlsch_stats.resource_mapping);
+    reset_meas(&gNB->dlsch_stats.encoding);
+    reset_meas(&gNB->dlsch_stats.tinput);
+    reset_meas(&gNB->dlsch_stats.tprep);
+    reset_meas(&gNB->dlsch_stats.tparity);
+    reset_meas(&gNB->dlsch_stats.toutput);
     reset_meas(&gNB->dci_generation_stats);
-    reset_meas(&gNB->tinput);
-    reset_meas(&gNB->tprep);
-    reset_meas(&gNB->tparity);
-    reset_meas(&gNB->toutput);
     reset_meas(&gNB->phase_comp_stats);
 
     uint32_t errors_scrambling[16] = {0};
@@ -1323,22 +1323,22 @@ int main(int argc, char **argv)
              8 * pdsch_pdu_rel15->TBSize[0]);
       printDistribution(&gNB->phy_proc_tx,table_tx,"PHY proc tx");
       printStatIndent2(&gNB->dci_generation_stats, "DCI encoding time");
-      printStatIndent2(&gNB->dlsch_encoding_stats,"DLSCH encoding time");
-      printStatIndent3(&gNB->dlsch_segmentation_stats,"DLSCH segmentation time");
-      printStatIndent3(&gNB->tinput,"DLSCH LDPC input processing time");
-      printStatIndent3(&gNB->tprep,"DLSCH LDPC input preparation time");
-      printStatIndent3(&gNB->tparity,"DLSCH LDPC parity generation time");
-      printStatIndent3(&gNB->toutput,"DLSCH LDPC output generation time");
-      printStatIndent3(&gNB->dlsch_rate_matching_stats,"DLSCH Rate Matching time");
-      printStatIndent3(&gNB->dlsch_interleaving_stats,  "DLSCH Interleaving time");
-      printStatIndent2(&gNB->dlsch_modulation_stats,"DLSCH modulation time");
-      printStatIndent2(&gNB->dlsch_scrambling_stats, "DLSCH scrambling time");
-      printStatIndent2(&gNB->dlsch_pdsch_generation_stats,"DLSCH PDSCH Generation time");
-      printStatIndent3(&gNB->dlsch_layer_mapping_stats,"DLSCH Layer Mapping time");
-      gNB->dlsch_resource_mapping_stats.trials = gNB->dlsch_layer_mapping_stats.trials;
-      printStatIndent3(&gNB->dlsch_resource_mapping_stats,"DLSCH Resource Mapping time");
-      gNB->dlsch_precoding_stats.trials = gNB->dlsch_layer_mapping_stats.trials;
-      printStatIndent3(&gNB->dlsch_precoding_stats,"DLSCH Precoding time");
+      printStatIndent2(&gNB->dlsch_stats.encoding,"DLSCH encoding time");
+      printStatIndent3(&gNB->dlsch_stats.segmentation,"DLSCH segmentation time");
+      printStatIndent3(&gNB->dlsch_stats.tinput,"DLSCH LDPC input processing time");
+      printStatIndent3(&gNB->dlsch_stats.tprep,"DLSCH LDPC input preparation time");
+      printStatIndent3(&gNB->dlsch_stats.tparity,"DLSCH LDPC parity generation time");
+      printStatIndent3(&gNB->dlsch_stats.toutput,"DLSCH LDPC output generation time");
+      printStatIndent3(&gNB->dlsch_stats.rate_matching,"DLSCH Rate Matching time");
+      printStatIndent3(&gNB->dlsch_stats.interleaving,  "DLSCH Interleaving time");
+      printStatIndent2(&gNB->dlsch_stats.modulation,"DLSCH modulation time");
+      printStatIndent2(&gNB->dlsch_stats.scrambling, "DLSCH scrambling time");
+      printStatIndent2(&gNB->dlsch_stats.pdsch_generation,"DLSCH PDSCH Generation time");
+      printStatIndent3(&gNB->dlsch_stats.layer_mapping,"DLSCH Layer Mapping time");
+      gNB->dlsch_stats.resource_mapping.trials = gNB->dlsch_stats.layer_mapping.trials;
+      printStatIndent3(&gNB->dlsch_stats.resource_mapping,"DLSCH Resource Mapping time");
+      gNB->dlsch_stats.precoding.trials = gNB->dlsch_stats.layer_mapping.trials;
+      printStatIndent3(&gNB->dlsch_stats.precoding, "DLSCH Precoding time");
       if (gNB->phase_comp)
         printStatIndent2(&gNB->phase_comp_stats, "Phase Compensation");
 

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -523,7 +523,14 @@ int main(int argc, char **argv)
         for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++)
           memset(gNB->common_vars.txdataF[0][aa], 0, frame_parms->samples_per_slot_wCP * sizeof(int32_t));
 
-        nr_common_signal_procedures (gNB,frame,slot, &ssb_pdu[i]);
+        nr_common_signal_procedures(&gNB->frame_parms,
+                                    &gNB->gNB_config,
+                                    frame,
+                                    slot,
+                                    &ssb_pdu[i],
+                                    gNB->nr_pbch_interleaver,
+                                    gNB->TX_AMP,
+                                    gNB->common_vars.txdataF[0][aa]);
 
         int samp = get_samples_slot_timestamp(frame_parms, slot);
         for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {