Avoid use of FAPI message buffers in msgDataTx

Note: after this commit, monolithic works but nFAPI operation is broken
and fixed in the next commit, to keep the changes small(er). All
simulators work.

This commit removes the use of msgDataTx's intermediate buffers for FAPI
messages and the call of the "Schedule response". The latter incurs an
additional copy of FAPI messages for the TX chain (for the RX chain, it
is and will remain there) which we can avoid.

Instead, it uses an NR_Sched_Rsp_t-typed variable sched_response to
store the results of the scheduler when called from tx_func(). Thus, the
scheduler remains unchanged (it gets a pointer to where to put FAPI
messages), but we don't call nr_schedule_response() to then copy FAPI
messages into the L1, but have them in a local variable sched_response.
sched_response on on the data segment, as it is big and would overflow
the stack; at the same time, this is ok because only one tx_func() runs
at a time.

Since we don't use allocate_sched_response() anymore, we don't need
deref_sched_response().

clear_slot_beamid() is moved to tx_func(), as it was called in
nr_schedule_response().

Since the "intermediate" NR_gNB_DLSCH_t structure groups both the
DL_tti_pdsch and TX_data.req structures, a pointer has been created to
point to pdsch_pdu. This affects a number of simulators, as they have to
put some messages on the stack:

- nr_dlschsim: put the corresponding variable on the stack
- nr_pbchsim: a new array for the SSB PDUs has been introduced

Further, these changes are now necessary:

- nr_dlsim:  there were variables "rel15" and "pdsch_pdu_rel15" that
  point to the same PDSCH PDU. At least "rel15" would not exist, as the
  corresponding pointer is now populated in phy_procedures_gNB_TX(), and
  we therefore refer to the single PDSCH PDU variable with
  "pdsch_pdu_rel15", but at the place where "rel15" used to be
  initialized.
- nr_ulsim: use nr_save_ul_tti_req() to load PDUs into the RX chain
  instead of nr_schedule_response(), which does not exist anymore.

executables/nr-gnb.c

@@ -82,8 +82,6 @@ static void tx_func(processingData_L1tx_t *info)
   int slot_rx = info->slot_rx;
   LOG_D(NR_PHY, "%d.%d running tx_func\n", frame_tx, slot_tx);
   PHY_VARS_gNB *gNB = info->gNB;
-  module_id_t module_id = gNB->Mod_id;
-  uint8_t CC_id = gNB->CC_id;
   NR_IF_Module_t *ifi = gNB->if_inst;
   nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
 
@@ -94,15 +92,22 @@ static void tx_func(processingData_L1tx_t *info)
     reset_active_ulsch(gNB, frame_rx);
   }
 
+  clear_slot_beamid(gNB, slot_tx);
+
+  nfapi_nr_slot_indication_scf_t ind = {.sfn = frame_tx, .slot = slot_tx};
   start_meas(&gNB->slot_indication_stats);
-  ifi->NR_slot_indication(module_id, CC_id, frame_tx, slot_tx);
+  // this variable is very big (multiple MB), so we put it into static storage
+  // to not overflow the stack while still having it in local (function) scope
+  // also, tx_func() is only executed by one thread, serially
+  static NR_Sched_Rsp_t sched_response;
+  ifi->NR_slot_indication(&ind, &sched_response);
   stop_meas(&gNB->slot_indication_stats);
-  gNB->msgDataTx->timestamp_tx = info->timestamp_tx;
-  info = gNB->msgDataTx;
+
   info->gNB = gNB;
 
   // At this point, MAC scheduler just ran, including scheduling
   // PRACH/PUCCH/PUSCH, so trigger RX chain processing
+  nr_save_ul_tti_req(gNB, &sched_response.UL_tti_req);
   LOG_D(NR_PHY, "Trigger RX for %d.%d\n", frame_rx, slot_rx);
   notifiedFIFO_elt_t *res = newNotifiedFIFO_elt(sizeof(processingData_L1_t), 0, &gNB->resp_L1, NULL);
   processingData_L1_t *syncMsg = NotifiedFifoData(res);
@@ -119,7 +124,13 @@ static void tx_func(processingData_L1tx_t *info)
   if (tx_slot_type == NR_DOWNLINK_SLOT || tx_slot_type == NR_MIXED_SLOT || get_softmodem_params()->continuous_tx || IS_SOFTMODEM_RFSIM 
     || cfg->analog_beamforming_ve.analog_beam_list) {
     start_meas(&info->gNB->phy_proc_tx);
-    phy_procedures_gNB_TX(info, frame_tx, slot_tx, 1);
+    phy_procedures_gNB_TX(info->gNB,
+                          &sched_response.DL_req,
+                          &sched_response.TX_req,
+                          &sched_response.UL_dci_req,
+                          frame_tx,
+                          slot_tx,
+                          1);
 
     PHY_VARS_gNB *gNB = info->gNB;
     processingData_RU_t syncMsgRU;
@@ -131,14 +142,6 @@ static void tx_func(processingData_L1tx_t *info)
     ru_tx_func((void *)&syncMsgRU);
     stop_meas(&info->gNB->phy_proc_tx);
   }
-
-  if (NFAPI_MODE == NFAPI_MONOLITHIC) {
-    /* this thread is done with the sched_info, decrease the reference counter.
-     * This only applies for monolithic; in the PNF, the memory is allocated in
-     * a ring buffer that should never be overwritten (one frame duration). */
-    LOG_D(NR_PHY, "Calling deref_sched_response for id %d (tx_func) in %d.%d\n", info->sched_response_id, frame_tx, slot_tx);
-    deref_sched_response(info->sched_response_id);
-  }
 }
 
 void *L1_rx_thread(void *arg) 

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -555,7 +555,7 @@ static int do_one_dlsch(unsigned char *input_ptr, PHY_VARS_gNB *gNB, NR_gNB_DLSC
 
   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 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;
   const int dmrs_Type = rel15->dmrsConfigType;
@@ -789,7 +789,7 @@ void nr_generate_pdsch(PHY_VARS_gNB *gNB, int n_dlsch, NR_gNB_DLSCH_t *dlsch_arr
 
   for (int i = 0; i < n_dlsch; i++) {
     NR_gNB_DLSCH_t *dlsch = &dlsch_array[i];
-    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu.pdsch_pdu_rel15;
+    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
 
     LOG_D(PHY,
           "pdsch: BWPStart %d, BWPSize %d, rbStart %d, rbsize %d\n",

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -138,7 +138,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
     NR_gNB_DLSCH_t *dlsch = &dlsch_array[i];
 
     unsigned int crc = 1;
-    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu.pdsch_pdu_rel15;
+    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
     uint32_t A = rel15->TBSize[0] << 3;
     unsigned char *a = dlsch->pdu;
     if (rel15->rnti != SI_RNTI) {
@@ -224,7 +224,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
 
   for (int i = 0; i < n_dlsch; i++) {
     NR_gNB_DLSCH_t *dlsch = &dlsch_array[i];
-    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu.pdsch_pdu_rel15;
+    const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
 
     nrLDPC_TB_encoding_parameters_t *TB_parameters = &TBs[i];
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_tools.c

@@ -54,7 +54,7 @@ void nr_fill_dlsch_tx_req(processingData_L1tx_t *msgTx, int idx, uint8_t *sdu)
   /* not sure if FAPI could transmit DL_TTI_req and TX_req in different orders.
    * for the moment, assume they are in the same order (and check!) */
   NR_gNB_DLSCH_t *dlsch = &msgTx->gNB->dlsch[idx];
-  nfapi_nr_dl_tti_pdsch_pdu *pdsch = &dlsch->pdsch_pdu;
+  const nfapi_nr_dl_tti_pdsch_pdu *pdsch = dlsch->pdsch_pdu;
   AssertFatal(pdsch->pdsch_pdu_rel15.pduIndex == idx, "PDSCH PDU index %d does not match %d\n", pdsch->pdsch_pdu_rel15.pduIndex, idx);
   dlsch->pdu = sdu;
 }

openair1/PHY/defs_gNB.h

@@ -98,7 +98,7 @@ typedef struct {
 
 typedef struct {
   /// Nfapi DLSCH PDU
-  nfapi_nr_dl_tti_pdsch_pdu pdsch_pdu;
+  const nfapi_nr_dl_tti_pdsch_pdu *pdsch_pdu;
   /// pointer to pdu from MAC interface (this is "a" in 36.212)
   uint8_t *pdu;
   /// Pointer to the payload

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -243,12 +243,14 @@ static void nr_generate_csi_rs_gNB(PHY_VARS_gNB *gNB,
                      gNB->common_vars.txdataF[beam_nb]);
 }
 
-void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
+void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
+                           const nfapi_nr_dl_tti_request_t *DL_req,
+                           const nfapi_nr_tx_data_request_t *TX_req,
+                           const nfapi_nr_ul_dci_request_t *UL_dci_req,
                            int frame,
                            int slot,
                            int do_meas)
 {
-  PHY_VARS_gNB *gNB = msgTx->gNB;
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
   int slot_prs = 0;
@@ -282,44 +284,41 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
     }
   }
 
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_COMMON_TX,1);
-  for (int i = 0; i < msgTx->n_ssb_pdu; i++)
-    nr_common_signal_procedures(gNB, frame, slot, &msgTx->ssb_pdu[i]);
-  msgTx->n_ssb_pdu = 0;
+  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);
 
-  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_COMMON_TX,0);
-
-  int num_pdcch_pdus = msgTx->num_ul_pdcch + msgTx->num_dl_pdcch;
-
-  if (num_pdcch_pdus > 0) {
-    LOG_D(PHY, "[gNB %d] Frame %d slot %d Calling nr_generate_dci() (number of UL/DL PDCCH PDUs %d/%d)\n",
-	  gNB->Mod_id, frame, slot, msgTx->num_ul_pdcch, msgTx->num_dl_pdcch);
-  
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_PDCCH_TX,1);
-
-    start_meas(&gNB->dci_generation_stats);
-    for (int i = 0; i < msgTx->num_dl_pdcch; ++i)
-      nr_generate_dci(gNB, &msgTx->pdcch_pdu[i].pdcch_pdu_rel15, txdataF_offset, &gNB->frame_parms, slot);
-    for (int i = 0; i < msgTx->num_ul_pdcch; ++i)
-      nr_generate_dci(gNB, &msgTx->ul_pdcch_pdu[i].pdcch_pdu_rel15, txdataF_offset, &gNB->frame_parms, slot);
-    stop_meas(&gNB->dci_generation_stats);
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_PDCCH_TX,0);
+  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);
+        break;
+      case NFAPI_NR_DL_TTI_CSI_RS_PDU_TYPE:
+        nr_generate_csi_rs_gNB(gNB, slot, cfg, &dl_tti_pdu->csi_rs_pdu);
+        break;
+      case NFAPI_NR_DL_TTI_PDSCH_PDU_TYPE: {
+        int tx_data_idx = dl_tti_pdu->pdsch_pdu.pdsch_pdu_rel15.pduIndex;
+        DevAssert(tx_data_idx < TX_req->Number_of_PDUs);
+        // reuse dlsch variables, as there are multiple very large memory
+        // buffers
+        gNB->dlsch[num_pdsch].pdsch_pdu = &dl_tti_pdu->pdsch_pdu;
+        gNB->dlsch[num_pdsch].pdu = (uint8_t *)TX_req->pdu_list[tx_data_idx].TLVs[0].value.direct;
+        DevAssert(num_pdsch < gNB->max_nb_pdsch);
+        num_pdsch++;
+        } break;
+    }
   }
-  msgTx->num_dl_pdcch = 0;
-  msgTx->num_ul_pdcch = 0;
  
-  if (msgTx->num_pdsch_slot > 0) {
+  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", msgTx->num_pdsch_slot,frame,slot);
-    nr_generate_pdsch(gNB, msgTx->num_pdsch_slot, gNB->dlsch, frame, slot);
+    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);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DLSCH,0);
   }
-  msgTx->num_pdsch_slot = 0;
-
-  for (int i = 0; i < msgTx->n_csirs_pdu; i++)
-    nr_generate_csi_rs_gNB(gNB, slot, cfg, &msgTx->csirs_pdu[i]);
-  msgTx->n_csirs_pdu = 0;
 
   //apply the OFDM symbol rotation here
   start_meas(&gNB->phase_comp_stats);
@@ -1293,3 +1292,40 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,0);
   return pusch_DTX;
 }
+
+void nr_save_ul_tti_req(PHY_VARS_gNB *gNB, nfapi_nr_ul_tti_request_t *UL_tti_req)
+{
+  DevAssert(gNB != NULL);
+  DevAssert(UL_tti_req != NULL);
+
+  int frame = UL_tti_req->SFN;
+  int slot = UL_tti_req->Slot;
+
+  for (int i = 0; i < UL_tti_req->n_pdus; i++) {
+    int type = UL_tti_req->pdus_list[i].pdu_type;
+    LOG_D(NR_PHY,
+          "frame %d, slot %d got %s for %d.%d\n",
+          frame,
+          slot,
+          txt_nfapi_nr_ul_config_pdu_type[type],
+          UL_tti_req->SFN,
+          UL_tti_req->Slot);
+    switch (type) {
+      case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE:
+        nr_fill_ulsch(gNB, UL_tti_req->SFN, UL_tti_req->Slot, &UL_tti_req->pdus_list[i].pusch_pdu);
+        break;
+      case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE:
+        nr_fill_pucch(gNB, UL_tti_req->SFN, UL_tti_req->Slot, &UL_tti_req->pdus_list[i].pucch_pdu);
+        break;
+      case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: {
+        nfapi_nr_prach_pdu_t *prach_pdu = &UL_tti_req->pdus_list[i].prach_pdu;
+        prach_item_t *prach = nr_schedule_rx_prach(gNB, UL_tti_req->SFN, UL_tti_req->Slot, prach_pdu);
+        if (!prach)
+          LOG_W(NR_PHY_RACH, "Error in scheduling rach\n");
+      } break;
+      case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE:
+        nr_fill_srs(gNB, UL_tti_req->SFN, UL_tti_req->Slot, &UL_tti_req->pdus_list[i].srs_pdu);
+        break;
+    }
+  }
+}

openair1/SCHED_NR/sched_nr.h

@@ -33,7 +33,14 @@
 #include "phy_frame_config_nr.h"
 
 void nr_set_ssb_first_subcarrier(nfapi_nr_config_request_scf_t *cfg, NR_DL_FRAME_PARMS *fp);
-void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx, int frame_tx, int slot_tx, int do_meas);
+void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
+                           const nfapi_nr_dl_tti_request_t *DL_req,
+                           const nfapi_nr_tx_data_request_t *TX_req,
+                           const nfapi_nr_ul_dci_request_t *UL_dci_req,
+                           int frame,
+                           int slot,
+                           int do_meas);
+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);

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -439,10 +439,7 @@ int main(int argc, char **argv)
   nr_init_dl_harq_processes(UE->dl_harq_processes, 8, nb_rb);
 
 	unsigned char harq_pid = 0; //dlsch->harq_ids[subframe];
-  processingData_L1tx_t msgDataTx = {0};
-  msgDataTx.gNB = gNB;
-  NR_gNB_DLSCH_t *dlsch = &msgDataTx.gNB->dlsch[0];
-  nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu.pdsch_pdu_rel15;
+  NR_gNB_DLSCH_t *dlsch = &gNB->dlsch[0];
 	//time_stats_t *rm_stats, *te_stats, *i_stats;
 	unsigned int TBS = 8424;
 	uint8_t nb_re_dmrs = 6;  // No data in dmrs symbol
@@ -459,19 +456,24 @@ int main(int argc, char **argv)
 	TBS = nr_compute_tbs(mod_order,rate, nb_rb, nb_symb_sch, nb_re_dmrs*length_dmrs, 0, 0, Nl);
 	printf("available bits %u TBS %u mod_order %d\n", available_bits, TBS, mod_order);
 	//dlsch->harq_ids[subframe]= 0;
-	rel15->rbSize         = nb_rb;
-	rel15->NrOfSymbols    = nb_symb_sch;
-	rel15->qamModOrder[0] = mod_order;
-	rel15->nrOfLayers     = Nl;
-	rel15->TBSize[0]      = TBS>>3;
-  rel15->targetCodeRate[0] = rate;
-  rel15->NrOfCodewords = 1;
-  rel15->dmrsConfigType = NFAPI_NR_DMRS_TYPE1;
-	rel15->dlDmrsSymbPos = 4;
-	rel15->mcsIndex[0] = Imcs;
-  rel15->numDmrsCdmGrpsNoData = 1;
-  rel15->maintenance_parms_v3.tbSizeLbrmBytes = Tbslbrm;
-  rel15->maintenance_parms_v3.ldpcBaseGraph = get_BG(TBS, rate);
+  nfapi_nr_dl_tti_pdsch_pdu pdsch_pdu = {
+      .pdsch_pdu_rel15 = {
+        .rbSize = nb_rb,
+        .NrOfSymbols = nb_symb_sch,
+        .qamModOrder[0] = mod_order,
+        .nrOfLayers = Nl,
+        .TBSize[0] = TBS >> 3,
+        .targetCodeRate[0] = rate,
+        .NrOfCodewords = 1,
+        .dmrsConfigType = NFAPI_NR_DMRS_TYPE1,
+        .dlDmrsSymbPos = 4,
+        .mcsIndex[0] = Imcs,
+        .numDmrsCdmGrpsNoData = 1,
+        .maintenance_parms_v3.tbSizeLbrmBytes = Tbslbrm,
+        .maintenance_parms_v3.ldpcBaseGraph = get_BG(TBS, rate),
+      },
+  };
+  dlsch->pdsch_pdu = &pdsch_pdu;
 	double modulated_input[16 * 68 * 384]; // [hna] 16 segments, 68*Zc
 	short channel_output_fixed[16 * 68 * 384];
 	//unsigned char *estimated_output;
@@ -512,7 +514,7 @@ int main(int argc, char **argv)
 
 	//printf("crc32: [0]->0x%08x\n",crc24c(test_input, 32));
 	// generate signal
-        unsigned char output[rel15->rbSize * NR_SYMBOLS_PER_SLOT * NR_NB_SC_PER_RB * NR_MAX_NB_LAYERS] __attribute__((aligned(64)));
+        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);

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -519,10 +519,10 @@ int main(int argc, char **argv)
     exit(-1);
   }
 
-  processingData_L1tx_t msgDataTx;
   // generate signal
   const uint32_t rxdataF_sz = UE->frame_parms.samples_per_slot_wCP;
   __attribute__ ((aligned(32))) c16_t rxdataF[UE->frame_parms.nb_antennas_rx][rxdataF_sz];
+  nfapi_nr_dl_tti_ssb_pdu ssb_pdu[64] = {0};
   if (input_fd==NULL) {
 
     for (i=0; i<frame_parms->Lmax; i++) {
@@ -530,10 +530,10 @@ int main(int argc, char **argv)
 
         const int sc_offset = frame_parms->freq_range == FR1 ? ssb_subcarrier_offset<<mu : ssb_subcarrier_offset;
         const int prb_offset = frame_parms->freq_range == FR1 ? gNB->gNB_config.ssb_table.ssb_offset_point_a.value<<mu : gNB->gNB_config.ssb_table.ssb_offset_point_a.value << (mu - 2);
-        msgDataTx.ssb_pdu[i].ssb_pdu_rel15.bchPayload = 0x55dd33;
-        msgDataTx.ssb_pdu[i].ssb_pdu_rel15.SsbBlockIndex = i;
-        msgDataTx.ssb_pdu[i].ssb_pdu_rel15.SsbSubcarrierOffset = sc_offset;
-        msgDataTx.ssb_pdu[i].ssb_pdu_rel15.ssbOffsetPointA = prb_offset;
+        ssb_pdu[i].ssb_pdu_rel15.bchPayload = 0x55dd33;
+        ssb_pdu[i].ssb_pdu_rel15.SsbBlockIndex = i;
+        ssb_pdu[i].ssb_pdu_rel15.SsbSubcarrierOffset = sc_offset;
+        ssb_pdu[i].ssb_pdu_rel15.ssbOffsetPointA = prb_offset;
 
         start_symbol = nr_get_ssb_start_symbol(frame_parms,i);
         int slot = start_symbol/14;
@@ -541,7 +541,7 @@ 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, &msgDataTx.ssb_pdu[i]);
+        nr_common_signal_procedures (gNB,frame,slot, &ssb_pdu[i]);
 
         int samp = frame_parms->get_samples_slot_timestamp(slot, frame_parms, 0);
         for (aa=0; aa<gNB->frame_parms.nb_antennas_tx; aa++) {
@@ -744,7 +744,7 @@ int main(int argc, char **argv)
                                                              gNB->gNB_config.ssb_table.ssb_subcarrier_offset.value,
                                                              frame_parms->Lmax);
           int payload_ret = (result.xtra_byte == xtra_byte);
-          nfapi_nr_dl_tti_ssb_pdu_rel15_t *pdu = &msgDataTx.ssb_pdu[ssb_index].ssb_pdu_rel15;
+          nfapi_nr_dl_tti_ssb_pdu_rel15_t *pdu = &ssb_pdu[ssb_index].ssb_pdu_rel15;
           for (int i = 0; i < 3; i++)
             payload_ret += (result.decoded_output[i] == ((pdu->bchPayload >> (8 * i)) & 0xff));
           // printf("ret %d\n", payload_ret);

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -60,7 +60,6 @@
 #include "PHY/defs_nr_common.h"
 #include "PHY/impl_defs_nr.h"
 #include "PHY/phy_vars_nr_ue.h"
-#include "SCHED_NR/fapi_nr_l1.h"
 #include "SCHED_NR/sched_nr.h"
 #include "SCHED_NR_UE/defs.h"
 #include "SCHED_NR_UE/fapi_nr_ue_l1.h"
@@ -727,11 +726,6 @@ int main(int argc, char *argv[])
   else
     initNamedTpool(gNBthreads, &gNB->threadPool, true, "gNB-tpool");
 
-  processingData_L1tx_t *msgDataTx = malloc(sizeof(processingData_L1tx_t));
-  msgDataTx->slot = -1;
-  gNB->msgDataTx = msgDataTx;
-  //gNB_config = &gNB->gNB_config;
-
   NR_UL_IND_t UL_INFO = {0};
   UL_INFO.crc_ind.crc_list = UL_INFO.crc_pdu_list;
   UL_INFO.rx_ind.pdu_list = UL_INFO.rx_pdu_list;
@@ -1284,6 +1278,9 @@ int main(int argc, char *argv[])
           srs_pdu->beamforming.prg_size = 1;
         }
 
+        /* load FAPI into RX of L1 */
+        nr_save_ul_tti_req(gNB, &Sched_INFO->UL_tti_req);
+
         /// UE UL PDUs
 
         UE->ul_harq_processes[harq_pid].round = round;
@@ -1291,9 +1288,6 @@ int main(int argc, char *argv[])
         UE_proc.frame_tx = frame;
         UE_proc.gNB_id = 0;
 
-        // prepare ULSCH/PUSCH reception
-        nr_schedule_response(Sched_INFO);
-
         // --------- setting parameters for UE --------
         nr_scheduled_response_t scheduled_response = {.ul_config = &ul_config, .phy_data = (void *)&phy_data};
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -59,13 +59,7 @@ uint8_t nr_get_rv(int rel_round)
   return nr_rv_round_map[rel_round];
 }
 
-void clear_nr_nfapi_information(gNB_MAC_INST *gNB,
-                                int CC_idP,
-                                frame_t frameP,
-                                slot_t slotP,
-                                nfapi_nr_dl_tti_request_t *DL_req,
-                                nfapi_nr_tx_data_request_t *TX_req,
-                                nfapi_nr_ul_dci_request_t *UL_dci_req)
+void clear_nr_nfapi_information(gNB_MAC_INST *gNB, int CC_idP, frame_t frameP, slot_t slotP)
 {
   /* called below and in simulators, so we assume a lock but don't require it */
   const int num_slots = gNB->frame_structure.numb_slots_frame;
@@ -75,16 +69,8 @@ void clear_nr_nfapi_information(gNB_MAC_INST *gNB,
 
   gNB->pdu_index[CC_idP] = 0;
 
-  DL_req[CC_idP].SFN = frameP;
-  DL_req[CC_idP].Slot = slotP;
-  DL_req[CC_idP].dl_tti_request_body.nPDUs             = 0;
-  DL_req[CC_idP].dl_tti_request_body.nGroup = 0;
   memset(pdcch, 0, sizeof(*pdcch) * MAX_NUM_CORESET);
 
-  UL_dci_req[CC_idP].SFN = frameP;
-  UL_dci_req[CC_idP].Slot = slotP;
-  UL_dci_req[CC_idP].numPdus = 0;
-
   /* advance last round's future UL_tti_req to be ahead of current frame/slot */
   const int size = gNB->UL_tti_req_ahead_size;
   const int prev_slot = frameP * num_slots + slotP + size - 1;
@@ -100,8 +86,6 @@ void clear_nr_nfapi_information(gNB_MAC_INST *gNB,
   future_ul_tti_req->n_ulsch = 0;
   future_ul_tti_req->n_ulcch = 0;
   future_ul_tti_req->n_group = 0;
-
-  TX_req[CC_idP].Number_of_PDUs = 0;
 }
 
 static void clear_beam_information(NR_beam_info_t *beam_info, int frame, int slot, int slots_per_frame)
@@ -191,7 +175,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP, frame_t frame, slot_t slo
       uint16_t *vrb_map_UL = cc[CC_id].vrb_map_UL[i];
       memcpy(&vrb_map_UL[prev_slot % size * MAX_BWP_SIZE], &gNB->ulprbbl, sizeof(uint16_t) * MAX_BWP_SIZE);
     }
-    clear_nr_nfapi_information(gNB, CC_id, frame, slot, &sched_info->DL_req, &sched_info->TX_req, &sched_info->UL_dci_req);
+    clear_nr_nfapi_information(gNB, CC_id, frame, slot);
   }
 
   bool wait_prach_completed = gNB->num_scheduled_prach_rx >= NUM_PRACH_RX_FOR_NOISE_ESTIMATE;

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -68,13 +68,7 @@ int nr_mac_get_reconfig_delay_slots(NR_SubcarrierSpacing_t scs);
 int nr_mac_interrupt_ue_transmission(gNB_MAC_INST *mac, NR_UE_info_t *UE, int slots);
 int nr_transmission_action_indicator_stop(gNB_MAC_INST *mac, NR_UE_info_t *UE_info);
 
-void clear_nr_nfapi_information(gNB_MAC_INST *gNB,
-                                int CC_idP,
-                                frame_t frameP,
-                                slot_t slotP,
-                                nfapi_nr_dl_tti_request_t *DL_req,
-                                nfapi_nr_tx_data_request_t *TX_req,
-                                nfapi_nr_ul_dci_request_t *UL_dci_req);
+void clear_nr_nfapi_information(gNB_MAC_INST *gNB, int CC_idP, frame_t frameP, slot_t slotP);
 
 void nr_mac_update_timers(module_id_t module_id, frame_t frame, slot_t slot);
 

openair2/NR_PHY_INTERFACE/NR_IF_Module.c

@@ -380,48 +380,22 @@ static void match_crc_rx_pdu(nfapi_nr_rx_data_indication_t *rx_ind, nfapi_nr_crc
 }
 
 extern void handle_nr_slot_ind(uint16_t sfn, uint16_t slot);
-static void pnf_send_slot_ind(module_id_t module_id, int CC_id, int frame, int slot)
+static void pnf_send_slot_ind(const nfapi_nr_slot_indication_scf_t *ind, NR_Sched_Rsp_t *rsp)
 {
-  (void)module_id;
-  (void)CC_id;
-  handle_nr_slot_ind(frame, slot);
+  module_id_t module_id = 0;
+  int CC_id = 0;
+  reset_sched_response(rsp, ind->sfn, ind->slot, module_id, CC_id);
+  handle_nr_slot_ind(ind->sfn, ind->slot);
+
+  // TODO copy messages from FAPI buffers
 }
 
-static void run_scheduler_monolithic(module_id_t module_id, int CC_id, int frame, int slot)
+static void run_scheduler_monolithic(const nfapi_nr_slot_indication_scf_t *ind, NR_Sched_Rsp_t *rsp)
 {
-  NR_IF_Module_t *ifi = nr_if_inst[module_id];
-
-  LOG_D(NR_MAC, "Calling scheduler for %d.%d\n", frame, slot);
-  NR_Sched_Rsp_t *sched_info = allocate_sched_response();
-
-  // clear UL DCI prior to handling ULSCH
-  sched_info->UL_dci_req.numPdus = 0;
-  gNB_dlsch_ulsch_scheduler(module_id, frame, slot, sched_info);
-  ifi->CC_mask = 0;
-  sched_info->module_id = module_id;
-  sched_info->CC_id = CC_id;
-  sched_info->frame = frame;
-  sched_info->slot = slot;
-  /*
-  sched_info->DL_req      = &mac->DL_req[CC_id];
-  sched_info->UL_dci_req  = &mac->UL_dci_req[CC_id];
-
-  sched_info->UL_tti_req  = mac->UL_tti_req[CC_id];
-
-  sched_info->TX_req      = &mac->TX_req[CC_id];
-  */
-#ifdef DUMP_FAPI
-  dump_dl(sched_info);
-#endif
-
-  AssertFatal(ifi->NR_Schedule_response != NULL, "nr_schedule_response is null (mod %d, cc %d)\n", module_id, CC_id);
-  ifi->NR_Schedule_response(sched_info);
-
-  LOG_D(NR_PHY,
-        "NR_Schedule_response: SFN SLOT:%d %d dl_pdus:%d\n",
-        sched_info->frame,
-        sched_info->slot,
-        sched_info->DL_req.dl_tti_request_body.nPDUs);
+  module_id_t module_id = 0;
+  int CC_id = 0;
+  reset_sched_response(rsp, ind->sfn, ind->slot, module_id, CC_id);
+  gNB_dlsch_ulsch_scheduler(rsp->module_id, ind->sfn, ind->slot, rsp);
 }
 
 void NR_UL_indication(NR_UL_IND_t *UL_info) {
@@ -515,3 +489,33 @@ NR_IF_Module_t *NR_IF_Module_init(int Mod_id) {
 
   return nr_if_inst[Mod_id];
 }
+
+void reset_sched_response(NR_Sched_Rsp_t *sched_response, int frame, int slot, int module_id, int CC_id)
+{
+  sched_response->module_id = module_id;
+  sched_response->CC_id = CC_id;
+  sched_response->frame = frame;
+  sched_response->slot = slot;
+
+
+  nfapi_nr_dl_tti_request_t *DL_req = &sched_response->DL_req;
+  DL_req->SFN = frame;
+  DL_req->Slot = slot;
+  DL_req->dl_tti_request_body.nPDUs = 0;
+  DL_req->dl_tti_request_body.nGroup = 0;
+
+  nfapi_nr_ul_dci_request_t *UL_dci_req = &sched_response->UL_dci_req;
+  UL_dci_req->SFN = frame;
+  UL_dci_req->Slot = slot;
+  UL_dci_req->numPdus = 0;
+
+  nfapi_nr_ul_tti_request_t *UL_tti_req = &sched_response->UL_tti_req;
+  UL_tti_req->SFN = frame;
+  UL_tti_req->Slot = slot;
+  UL_tti_req->n_pdus = 0;
+
+  nfapi_nr_tx_data_request_t *TX_req = &sched_response->TX_req;
+  TX_req->SFN = frame;
+  TX_req->Slot = slot;
+  TX_req->Number_of_PDUs = 0;
+}

openair2/NR_PHY_INTERFACE/NR_IF_Module.h

@@ -111,6 +111,7 @@ typedef struct {
   /// Pointers to DL SDUs
   nfapi_nr_tx_data_request_t TX_req;
 } NR_Sched_Rsp_t;
+void reset_sched_response(NR_Sched_Rsp_t *sched_response, int frame, int slot, int module_id, int CC_id);
 
 typedef struct {
   uint8_t Mod_id;
@@ -122,7 +123,7 @@ typedef struct NR_IF_Module_s {
   //define the function pointer
   void (*NR_UL_indication)(NR_UL_IND_t *UL_INFO);
   void (*NR_Schedule_response)(NR_Sched_Rsp_t *Sched_INFO);
-  void (*NR_slot_indication)(module_id_t module_idP, int CC_id, int frame, int slot);
+  void (*NR_slot_indication)(const nfapi_nr_slot_indication_scf_t *ind, NR_Sched_Rsp_t *rsp);
   void (*NR_PHY_config_req)(NR_PHY_Config_t *config_INFO);
   uint32_t CC_mask;
   uint16_t current_frame;