Merge remote-tracking branch 'origin/oai-ue-time-meas' into integration_2022_wk06_a

cmake_targets/CMakeLists.txt

@@ -1711,6 +1711,8 @@ set(PHY_SRC_UE
   set(PHY_NR_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_prach_common.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/srs_modulation_nr.c
+  ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_scrambling.c
+  ${OPENAIR1_DIR}/PHY/NR_REFSIG/scrambling_luts.c
   )
 
   set(PHY_NR_SRC
@@ -1736,7 +1738,6 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_dmrs_rx.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_csi_rs.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gold.c
-  ${OPENAIR1_DIR}/PHY/NR_REFSIG/scrambling_luts.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gen_mod_table.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/dmrs_nr.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/ptrs_nr.c

common/utils/telnetsrv/telnetsrv_cpumeasur_def.h

@@ -106,12 +106,13 @@
     {"phy_proc",          &(UE->phy_proc[0]),0,RX_NB_TH},\
     {"phy_proc_rx",       &(UE-> phy_proc_rx[0]),0,RX_NB_TH},\
     {"phy_proc_tx",       &(UE->phy_proc_tx),0,1},\
+    {"ue_ul_indication_stats",       &(UE->ue_ul_indication_stats),0,1},\
     {"ofdm_mod_stats",       &(UE->ofdm_mod_stats),0,1},\
     {"ulsch_encoding_stats",       &(UE->ulsch_encoding_stats),0,1},\
     {"ulsch_modulation_stats",       &(UE->ulsch_modulation_stats),0,1},\
     {"ulsch_segmentation_stats",       &(UE->ulsch_segmentation_stats),0,1},\
     {"ulsch_rate_matching_stats",       &(UE->ulsch_rate_matching_stats),0,1},\
-    {"ulsch_turbo_encoding_stats",       &(UE->ulsch_turbo_encoding_stats),0,1},\
+    {"ulsch_ldpc_encoding_stats",       &(UE->ulsch_ldpc_encoding_stats),0,1},\
     {"ulsch_interleaving_stats",       &(UE->ulsch_interleaving_stats),0,1},\
     {"ulsch_multiplexing_stats",       &(UE->ulsch_multiplexing_stats),0,1},\
     {"generic_stat",       &(UE->generic_stat),0,1},\
@@ -123,12 +124,12 @@
     {"dlsch_f...timation_stats",       &(UE->dlsch_freq_offset_estimation_stats),0,1},\
     {"dlsch_demodulation_stats",       &(UE->dlsch_demodulation_stats),0,1},\
     {"dlsch_rate_unmatching_stats",       &(UE->dlsch_rate_unmatching_stats),0,1},\
-    {"dlsch_turbo_decoding_stats",       &(UE->dlsch_turbo_decoding_stats),0,1},\
+    {"dlsch_ldpc_decoding_stats",       &(UE->dlsch_ldpc_decoding_stats),0,1},\
     {"dlsch_deinterleaving_stats",       &(UE->dlsch_deinterleaving_stats),0,1},\
     {"dlsch_llr_stats",       &(UE->dlsch_llr_stats),0,1},\
     {"dlsch_unscrambling_stats",       &(UE->dlsch_unscrambling_stats),0,1},\
     {"dlsch_rate_matching_stats",       &(UE->dlsch_rate_matching_stats),0,1},\
-    {"dlsch_turbo_encoding_stats",       &(UE->dlsch_turbo_encoding_stats),0,1},\
+    {"dlsch_ldpc_encoding_stats",       &(UE->dlsch_ldpc_encoding_stats),0,1},\
     {"dlsch_interleaving_stats",       &(UE->dlsch_interleaving_stats),0,1},\
     {"dlsch_tc_init_stats",       &(UE->dlsch_tc_init_stats),0,1},\
     {"dlsch_tc_alpha_stats",       &(UE->dlsch_tc_alpha_stats),0,1},\
@@ -146,6 +147,7 @@
     {"ue_front_end_stat",       &(UE->ue_front_end_stat[0]),0,RX_NB_TH},\
     {"ue_front_end_per_slot_stat",      &(UE->ue_front_end_per_slot_stat[0][0]),0,RX_NB_TH,LTE_SLOTS_PER_SUBFRAME},\
     {"pdcch_procedures_stat",       &(UE->pdcch_procedures_stat[0]),0,RX_NB_TH},\
+    {"rx_pdsch_stats",              &(UE->rx_pdsch_stats), 0, 1}, \
     {"pdsch_procedures_stat",       &(UE->pdsch_procedures_stat[0]),0,RX_NB_TH},\
     {"pdsch_procedures_per_slot_stat",  &(UE->pdsch_procedures_per_slot_stat[0][0]),0,RX_NB_TH,LTE_SLOTS_PER_SUBFRAME},\
     {"dlsch_procedures_stat",       &(UE->dlsch_procedures_stat[0]),0,RX_NB_TH},\

executables/nr-ue.c

@@ -104,6 +104,49 @@ queue_t nr_rach_ind_queue;
 
 static void *NRUE_phy_stub_standalone_pnf_task(void *arg);
 
+static int dump_L1_UE_meas_stats(PHY_VARS_NR_UE *ue, char *output, int max_len)
+{
+  int stroff = 0;
+  stroff += print_meas_log(&ue->phy_proc_tx, "L1 TX processing", NULL, NULL, output);
+  stroff += print_meas_log(&ue->ulsch_encoding_stats, "ULSCH encoding", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->phy_proc_rx[0], "L1 RX processing t0", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->phy_proc_rx[1], "L1 RX processing t1", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->ue_ul_indication_stats, "UL Indication", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->rx_pdsch_stats, "PDSCH receiver", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_decoding_stats[0], "PDSCH decoding t0", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_decoding_stats[1], "PDSCH decoding t1", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_deinterleaving_stats, " -> Deinterleive", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_rate_unmatching_stats, " -> Rate Unmatch", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_ldpc_decoding_stats, " ->  LDPC Decode", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_unscrambling_stats, "PDSCH unscrambling", NULL, NULL, output + stroff);
+  stroff += print_meas_log(&ue->dlsch_rx_pdcch_stats, "PDCCH handling", NULL, NULL, output + stroff);
+  return stroff;
+}
+
+static void *nrL1_UE_stats_thread(void *param)
+{
+  PHY_VARS_NR_UE *ue = (PHY_VARS_NR_UE *) param;
+  const int max_len = 16384;
+  char output[max_len];
+  char filename[30];
+  snprintf(filename, 29, "nrL1_UE_stats-%d.log", ue->Mod_id);
+  filename[29] = 0;
+  FILE *fd = fopen(filename, "w");
+  AssertFatal(fd != NULL, "Cannot open %s\n", filename);
+
+  while (!oai_exit) {
+    sleep(1);
+    const int len = dump_L1_UE_meas_stats(ue, output, max_len);
+    AssertFatal(len < max_len, "exceeded length\n");
+    fwrite(output, len + 1, 1, fd); // + 1 for terminating NULL byte
+    fflush(fd);
+    fseek(fd, 0, SEEK_SET);
+  }
+  fclose(fd);
+
+  return NULL;
+}
+
 void init_nr_ue_vars(PHY_VARS_NR_UE *ue,
                      uint8_t UE_id,
                      uint8_t abstraction_flag)
@@ -593,7 +636,7 @@ static void UE_synch(void *arg) {
       uint64_t dl_carrier, ul_carrier;
       nr_get_carrier_frequencies(UE, &dl_carrier, &ul_carrier);
 
-      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa, get_nrUE_params()->nr_dlsch_parallel) == 0) {
+      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa) == 0) {
         freq_offset = UE->common_vars.freq_offset; // frequency offset computed with pss in initial sync
         hw_slot_offset = ((UE->rx_offset<<1) / UE->frame_parms.samples_per_subframe * UE->frame_parms.slots_per_subframe) +
                          round((float)((UE->rx_offset<<1) % UE->frame_parms.samples_per_subframe)/UE->frame_parms.samples_per_slot0);
@@ -666,6 +709,7 @@ void processSlotTX(void *arg) {
     // trigger L2 to run ue_scheduler thru IF module
     // [TODO] mapping right after NR initial sync
     if(UE->if_inst != NULL && UE->if_inst->ul_indication != NULL) {
+      start_meas(&UE->ue_ul_indication_stats);
       nr_uplink_indication_t ul_indication;
       memset((void*)&ul_indication, 0, sizeof(ul_indication));
 
@@ -680,6 +724,7 @@ void processSlotTX(void *arg) {
       ul_indication.ue_sched_mode = rxtxD->ue_sched_mode;
 
       UE->if_inst->ul_indication(&ul_indication);
+      stop_meas(&UE->ue_ul_indication_stats);
     }
 
     if ((UE->mode != loop_through_memory) && (rxtxD->ue_sched_mode != NOT_PUSCH)) {
@@ -1164,6 +1209,8 @@ void init_NR_UE_threads(int nb_inst) {
 
     LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
     threadCreate(&threads[inst], UE_thread, (void *)UE, "UEthread", -1, OAI_PRIORITY_RT_MAX);
+    pthread_t stat_pthread;
+    threadCreate(&stat_pthread, nrL1_UE_stats_thread, UE, "L1_UE_stats", -1, OAI_PRIORITY_RT_LOW);
   }
 }
 

openair1/PHY/INIT/nr_init_ue.c

@@ -542,6 +542,7 @@ void init_N_TA_offset(PHY_VARS_NR_UE *ue){
 void phy_init_nr_top(PHY_VARS_NR_UE *ue) {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   crcTableInit();
+  init_scrambling_luts();
   load_dftslib();
   init_context_synchro_nr(frame_parms);
   generate_ul_reference_signal_sequences(SHRT_MAX);
@@ -553,6 +554,5 @@ void phy_init_nr_top(PHY_VARS_NR_UE *ue) {
   //generate_16qam_table();
   //generate_RIV_tables();
   //init_unscrambling_lut();
-  //init_scrambling_lut();
   //set_taus_seed(1328);
 }

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

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

openair1/PHY/NR_TRANSPORT/nr_scrambling.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "nr_transport_common_proto.h"
+#include "PHY/NR_REFSIG/nr_refsig.h"
+#include "common/utils/LOG/vcd_signal_dumper.h"
+
+void nr_codeword_scrambling(uint8_t *in,
+                            uint32_t size,
+                            uint8_t q,
+                            uint32_t Nid,
+                            uint32_t n_RNTI,
+                            uint32_t* out)
+{
+  uint32_t x1;
+  uint32_t x2 = (n_RNTI<<15) + (q<<14) + Nid;
+  uint32_t s = 0;
+
+#if defined(__AVX2__)
+  s=lte_gold_generic(&x1, &x2, 1);
+  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
+    __m256i c = ((__m256i*)in)[i];
+    uint32_t in32 = _mm256_movemask_epi8(_mm256_slli_epi16(c,7));
+    out[i]=(in32^s);
+    //printf("in[%d] %x => %x\n",i,in32,out[i]);
+    s=lte_gold_generic(&x1, &x2, 0);
+  }
+#elif defined(__SSE4__)
+  s=lte_gold_generic(&x1, &x2, 1);
+  __m128i *in128;
+  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++) {
+    in128=&((__m128i*)in)[i<<1];
+    uint32_t in32;
+    ((uint16_t*)&in32)[0] = _mm_movemask_epi8(_mm_slli_epi16(in128[0],7));
+    ((uint16_t*)&in32)[1] = _mm_movemask_epi8(_mm_slli_epi16(in128[1],7));
+    out[i]=(in32^s);
+    s=lte_gold_generic(&x1, &x2, 0);
+  }
+//#elsif defined(__arm__) || defined(__aarch64)
+#else
+  uint8_t reset = 1;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 1);
+  for (int i = 0; i < size; i++) {
+    const uint8_t b_idx = i&0x1f;
+    if (b_idx==0) {
+      s = lte_gold_generic(&x1, &x2, reset);
+      reset = 0;
+      if (i)
+        out++;
+    }
+    *out ^= (((in[i])&1) ^ ((s>>b_idx)&1))<<b_idx;
+    //printf("i %d b_idx %d in %d s 0x%08x out 0x%08x\n", i, b_idx, in[i], s, *out);
+  }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_PDSCH_CODEWORD_SCRAMBLING, 0);
+#endif
+}
+
+void nr_codeword_unscrambling(int16_t* llr, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI)
+{
+  uint32_t x1;
+  uint32_t x2 = (n_RNTI << 15) + (q << 14) + Nid;
+  uint32_t s = 0;
+
+#if defined(__x86_64__) || defined(__i386__)
+  uint8_t *s8=(uint8_t *)&s;
+  __m128i *llr128 = (__m128i*)llr;
+  s = lte_gold_generic(&x1, &x2, 1);
+
+  for (int i = 0, j = 0; i < ((size >> 5) + ((size & 0x1f) > 0 ? 1 : 0)); i++, j += 4) {
+    llr128[j]   = _mm_mullo_epi16(llr128[j],byte2m128i[s8[0]]);
+    llr128[j+1] = _mm_mullo_epi16(llr128[j+1],byte2m128i[s8[1]]);
+    llr128[j+2] = _mm_mullo_epi16(llr128[j+2],byte2m128i[s8[2]]);
+    llr128[j+3] = _mm_mullo_epi16(llr128[j+3],byte2m128i[s8[3]]);
+    s = lte_gold_generic(&x1, &x2, 0);
+  }
+#else
+  uint8_t reset = 1;
+
+  for (uint32_t i=0; i<size; i++) {
+    if ((i&0x1f)==0) {
+      s = lte_gold_generic(&x1, &x2, reset);
+      reset = 0;
+    }
+    if (((s>>(i&0x1f))&1)==1)
+      llr[i] = -llr[i];
+  }
+#endif
+}

openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h

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

openair1/PHY/NR_TRANSPORT/nr_ulsch.c

@@ -33,7 +33,6 @@
 #include <stdint.h>
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
 #include "PHY/NR_TRANSPORT/nr_ulsch.h"
-#include "PHY/NR_REFSIG/nr_refsig.h"
 
 int16_t find_nr_ulsch(uint16_t rnti, PHY_VARS_gNB *gNB,find_type_t type) {
 
@@ -82,59 +81,9 @@ void nr_fill_ulsch(PHY_VARS_gNB *gNB,
 
 }
 
-void nr_ulsch_unscrambling(int16_t* llr,
-                           uint32_t size,
-                           uint8_t q,
-                           uint32_t Nid,
-                           uint32_t n_RNTI) {
-
-  uint8_t reset;
-  uint32_t x1, x2, s=0;
-
-  reset = 1;
-  x2 = (n_RNTI<<15) + Nid;
-
-  for (uint32_t i=0; i<size; i++) {
-    if ((i&0x1f)==0) {
-      s = lte_gold_generic(&x1, &x2, reset);
-      reset = 0;
-    }
-    if (((s>>(i&0x1f))&1)==1)
-      llr[i] = -llr[i];
-  }
-}
-
-void nr_ulsch_unscrambling_optim(int16_t* llr,
-				 uint32_t size,
-				 uint8_t q,
-				 uint32_t Nid,
-				 uint32_t n_RNTI) {
-  
-#if defined(__x86_64__) || defined(__i386__)
-  uint32_t x1, x2, s=0;
-
-  x2 = (n_RNTI<<15) + Nid;
-
-  uint8_t *s8=(uint8_t *)&s;
-  __m128i *llr128 = (__m128i*)llr;
-  int j=0;
-  s = lte_gold_generic(&x1, &x2, 1);
-
-  for (int i=0; i<((size>>5)+((size&0x1f) > 0 ? 1 : 0)); i++,j+=4) {
-    llr128[j]   = _mm_mullo_epi16(llr128[j],byte2m128i[s8[0]]);
-    llr128[j+1] = _mm_mullo_epi16(llr128[j+1],byte2m128i[s8[1]]);
-    llr128[j+2] = _mm_mullo_epi16(llr128[j+2],byte2m128i[s8[2]]);
-    llr128[j+3] = _mm_mullo_epi16(llr128[j+3],byte2m128i[s8[3]]);
-    s = lte_gold_generic(&x1, &x2, 0);
-  }
-#else
-
-    nr_ulsch_unscrambling(llr,
-                          size,
-                          q,
-                          Nid,
-                          n_RNTI);
-#endif
+void nr_ulsch_unscrambling(int16_t* llr, uint32_t size, uint32_t Nid, uint32_t n_RNTI)
+{
+  nr_codeword_unscrambling(llr, size, 0, Nid, n_RNTI);
 }
 
 void dump_pusch_stats(FILE *fd,PHY_VARS_gNB *gNB) {

openair1/PHY/NR_TRANSPORT/nr_ulsch.h

@@ -69,18 +69,7 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
   @param n_RNTI, CRNTI
 */
 
-void nr_ulsch_unscrambling(int16_t* llr,
-                         uint32_t size,
-                         uint8_t q,
-                         uint32_t Nid,
-                         uint32_t n_RNTI);
-
-
-void nr_ulsch_unscrambling_optim(int16_t* llr,
-				 uint32_t size,
-				 uint8_t q,
-				 uint32_t Nid,
-				 uint32_t n_RNTI);
+void nr_ulsch_unscrambling(int16_t* llr, uint32_t size, uint32_t Nid, uint32_t n_RNTI);
 
 void nr_ulsch_procedures(PHY_VARS_gNB *gNB,
                          int frame_rx,

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -206,25 +206,9 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
   return(NULL);
 }
 
-void nr_dlsch_unscrambling(int16_t *llr,
-                           uint32_t size,
-                           uint8_t q,
-                           uint32_t Nid,
-                           uint32_t n_RNTI) {
-  uint8_t reset;
-  uint32_t x1, x2, s=0;
-  reset = 1;
-  x2 = (n_RNTI<<15) + (q<<14) + Nid;
-
-  for (int i=0; i<size; i++) {
-    if ((i&0x1f)==0) {
-      s = lte_gold_generic(&x1, &x2, reset);
-      reset = 0;
-    }
-
-    if (((s>>(i&0x1f))&1)==1)
-      llr[i] = -llr[i];
-  }
+void nr_dlsch_unscrambling(int16_t *llr, uint32_t size, uint8_t q, uint32_t Nid, uint32_t n_RNTI)
+{
+  nr_codeword_unscrambling(llr, size, q, Nid, n_RNTI);
 }
 
 bool nr_ue_postDecode(PHY_VARS_NR_UE *phy_vars_ue, notifiedFIFO_elt_t *req, bool last, notifiedFIFO_t *nf_p) {
@@ -233,6 +217,10 @@ bool nr_ue_postDecode(PHY_VARS_NR_UE *phy_vars_ue, notifiedFIFO_elt_t *req, bool
   NR_UE_DLSCH_t *dlsch = (NR_UE_DLSCH_t *) rdata->dlsch;
   int r = rdata->segment_r;
 
+  merge_meas(&phy_vars_ue->dlsch_deinterleaving_stats, &rdata->ts_deinterleave);
+  merge_meas(&phy_vars_ue->dlsch_rate_unmatching_stats, &rdata->ts_rate_unmatch);
+  merge_meas(&phy_vars_ue->dlsch_ldpc_decoding_stats, &rdata->ts_ldpc_decode);
+
   bool decodeSuccess = (rdata->decodeIterations < (1+dlsch->max_ldpc_iterations));
 
   if (decodeSuccess) {
@@ -295,12 +283,6 @@ bool nr_ue_postDecode(PHY_VARS_NR_UE *phy_vars_ue, notifiedFIFO_elt_t *req, bool
 void nr_processDLSegment(void* arg) {
   ldpcDecode_ue_t *rdata = (ldpcDecode_ue_t*) arg;
   NR_UE_DLSCH_t *dlsch = rdata->dlsch;
-#if UE_TIMING_TRACE //TBD
-  PHY_VARS_NR_UE *phy_vars_ue = rdata->phy_vars_ue;
-  time_stats_t *dlsch_rate_unmatching_stats=&phy_vars_ue->dlsch_rate_unmatching_stats;
-  time_stats_t *dlsch_turbo_decoding_stats=&phy_vars_ue->dlsch_turbo_decoding_stats;
-  time_stats_t *dlsch_deinterleaving_stats=&phy_vars_ue->dlsch_deinterleaving_stats;
-#endif
   NR_DL_UE_HARQ_t *harq_process= rdata->harq_process;
   t_nrLDPC_dec_params *p_decoderParms = &rdata->decoderParms;
   int length_dec;
@@ -340,21 +322,16 @@ void nr_processDLSegment(void* arg) {
 
   t_nrLDPC_procBuf **p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf;
 
-#if UE_TIMING_TRACE
-    start_meas(dlsch_deinterleaving_stats);
-#endif
+    start_meas(&rdata->ts_deinterleave);
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DEINTERLEAVING, VCD_FUNCTION_IN);
     nr_deinterleaving_ldpc(E,
                            Qm,
                            harq_process->w[r], // [hna] w is e
                            dlsch_llr+r_offset);
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DEINTERLEAVING, VCD_FUNCTION_OUT);
-#if UE_TIMING_TRACE
-    stop_meas(dlsch_deinterleaving_stats);
-#endif
-#if UE_TIMING_TRACE
-    start_meas(dlsch_rate_unmatching_stats);
-#endif
+    stop_meas(&rdata->ts_deinterleave);
+
+    start_meas(&rdata->ts_rate_unmatch);
     /* LOG_D(PHY,"HARQ_PID %d Rate Matching Segment %d (coded bits %d,E %d, F %d,unpunctured/repeated bits %d, TBS %d, mod_order %d, nb_rb %d, Nl %d, rv %d, round %d)...\n",
           harq_pid,r, G,E,harq_process->F,
           Kr*3,
@@ -379,17 +356,12 @@ void nr_processDLSegment(void* arg) {
                                  harq_process->F,
                                  Kr-harq_process->F-2*(p_decoderParms->Z))==-1) {
       //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_RATE_MATCHING, VCD_FUNCTION_OUT);
-#if UE_TIMING_TRACE
-      stop_meas(dlsch_rate_unmatching_stats);
-#endif
+      stop_meas(&rdata->ts_rate_unmatch);
       LOG_E(PHY,"dlsch_decoding.c: Problem in rate_matching\n");
       rdata->decodeIterations = dlsch->max_ldpc_iterations + 1;
       return;
-    } else {
-#if UE_TIMING_TRACE
-      stop_meas(dlsch_rate_unmatching_stats);
-#endif
     }
+    stop_meas(&rdata->ts_rate_unmatch);
 
     r_offset += E;
 
@@ -417,9 +389,7 @@ void nr_processDLSegment(void* arg) {
     }
 
     {
-#if UE_TIMING_TRACE
-      start_meas(dlsch_turbo_decoding_stats);
-#endif
+      start_meas(&rdata->ts_ldpc_decode);
       //set first 2*Z_c bits to zeros
       memset(&z[0],0,2*harq_process->Z*sizeof(int16_t));
       //set Filler bits
@@ -469,9 +439,7 @@ void nr_processDLSegment(void* arg) {
         harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
       }
 
-#if UE_TIMING_TRACE
-      stop_meas(dlsch_turbo_decoding_stats);
-#endif
+      stop_meas(&rdata->ts_ldpc_decode);
     }
 }
 
@@ -673,6 +641,9 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     rdata->offset = offset;
     rdata->dlsch = dlsch;
     rdata->dlsch_id = 0;
+    reset_meas(&rdata->ts_deinterleave);
+    reset_meas(&rdata->ts_rate_unmatch);
+    reset_meas(&rdata->ts_ldpc_decode);
     pushTpool(&(pool_dl),req);
     nbDecode++;
     LOG_D(PHY,"Added a block to decode, in pipe: %d\n",nbDecode);

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -196,8 +196,7 @@ char prefix_string[2][9] = {"NORMAL","EXTENDED"};
 
 int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
                     PHY_VARS_NR_UE *ue,
-                    int n_frames, int sa,
-                    int dlsch_parallel)
+                    int n_frames, int sa)
 {
 
   int32_t sync_pos, sync_pos_frame; // k_ssb, N_ssb_crb, sync_pos2,
@@ -528,8 +527,7 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
                                          SI_PDSCH,
                                          ue->dlsch_SI[gnb_id],
                                          NULL,
-                                         &ue->dlsch_SI_errors[gnb_id],
-                                         dlsch_parallel);
+                                         &ue->dlsch_SI_errors[gnb_id]);
 
           // deactivate dlsch once dlsch proc is done
           ue->dlsch_SI[gnb_id]->active = 0;

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1055,13 +1055,14 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
   @param[in] size, of input bits
   @param[in] Nid, cell id
   @param[in] n_RNTI, CRNTI
+  @param[in] uci_on_pusch whether UCI placeholder bits need to be scrambled (true -> no optimized scrambling)
   @param[out] out, the scrambled bits
 */
-
 void nr_pusch_codeword_scrambling(uint8_t *in,
                                   uint32_t size,
                                   uint32_t Nid,
                                   uint32_t n_RNTI,
+                                  bool uci_on_pusch,
                                   uint32_t* out);
 
 /** \brief Perform the following functionalities:
@@ -1423,8 +1424,7 @@ void generate_RIV_tables(void);
 int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
                     PHY_VARS_NR_UE *phy_vars_ue, 
                     int n_frames,
-                    int sa,
-                    int dlsch_parallel);
+                    int sa);
 
 /*!
   \brief This function gets the carrier frequencies either from FP or command-line-set global variables, depending on the availability of the latter

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

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

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

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

openair1/PHY/TOOLS/time_meas.h

@@ -179,6 +179,16 @@ static inline void copy_meas(time_stats_t *dst_ts,time_stats_t *src_ts) {
   }
 }
 
+static inline void merge_meas(time_stats_t *dst_ts, time_stats_t *src_ts)
+{
+  if (!opp_enabled)
+    return;
+  dst_ts->trials += src_ts->trials;
+  dst_ts->diff += src_ts->diff;
+  if (src_ts->max > dst_ts->max)
+    dst_ts->max = src_ts->max;
+}
+
 extern notifiedFIFO_t measur_fifo;
 #define CPUMEASUR_SECTION "cpumeasur"
 

openair1/PHY/defs_nr_UE.h

@@ -1012,6 +1012,8 @@ typedef struct {
   time_stats_t phy_proc_tx;
   time_stats_t phy_proc_rx[RX_NB_TH];
 
+  time_stats_t ue_ul_indication_stats;
+
   uint32_t use_ia_receiver;
 
   time_stats_t ofdm_mod_stats;
@@ -1020,7 +1022,6 @@ typedef struct {
   time_stats_t ulsch_modulation_stats;
   time_stats_t ulsch_segmentation_stats;
   time_stats_t ulsch_rate_matching_stats;
-  time_stats_t ulsch_turbo_encoding_stats;
   time_stats_t ulsch_interleaving_stats;
   time_stats_t ulsch_multiplexing_stats;
 
@@ -1033,6 +1034,7 @@ typedef struct {
   time_stats_t pdsch_procedures_per_slot_stat[RX_NB_TH][LTE_SLOTS_PER_SUBFRAME];
   time_stats_t dlsch_procedures_stat[RX_NB_TH];
 
+  time_stats_t rx_pdsch_stats;
   time_stats_t ofdm_demod_stats;
   time_stats_t dlsch_rx_pdcch_stats;
   time_stats_t rx_dft_stats;
@@ -1041,13 +1043,13 @@ typedef struct {
   time_stats_t dlsch_decoding_stats[2];
   time_stats_t dlsch_demodulation_stats;
   time_stats_t dlsch_rate_unmatching_stats;
-  time_stats_t dlsch_turbo_decoding_stats;
+  time_stats_t dlsch_ldpc_decoding_stats;
   time_stats_t dlsch_deinterleaving_stats;
   time_stats_t dlsch_llr_stats;
   time_stats_t dlsch_llr_stats_parallelization[RX_NB_TH][LTE_SLOTS_PER_SUBFRAME];
   time_stats_t dlsch_unscrambling_stats;
   time_stats_t dlsch_rate_matching_stats;
-  time_stats_t dlsch_turbo_encoding_stats;
+  time_stats_t dlsch_ldpc_encoding_stats;
   time_stats_t dlsch_interleaving_stats;
   time_stats_t dlsch_tc_init_stats;
   time_stats_t dlsch_tc_alpha_stats;
@@ -1106,6 +1108,9 @@ typedef struct LDPCDecode_ue_s {
   int offset;
   int Tbslbrm;
   int decodeIterations;
+  time_stats_t ts_deinterleave;
+  time_stats_t ts_rate_unmatch;
+  time_stats_t ts_ldpc_decode;
 } ldpcDecode_ue_t;
 
 #include "SIMULATION/ETH_TRANSPORT/defs.h"

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -186,8 +186,6 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
     }
   }
 
-  if (do_meas==1) stop_meas(&msgTx->phy_proc_tx);
-
 //  if ((frame&127) == 0) dump_pdsch_stats(gNB);
 
   //apply the OFDM symbol rotation here
@@ -196,8 +194,8 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_TX+offset,0);
-  //pthread_mutex_unlock(&mutextest);
 
+  if (do_meas==1) stop_meas(&msgTx->phy_proc_tx);
 }
 
 void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req) {
@@ -353,9 +351,8 @@ void nr_ulsch_procedures(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, int ULSCH
   //------------------- ULSCH unscrambling -------------------
   //----------------------------------------------------------
   start_meas(&gNB->ulsch_unscrambling_stats);
-  nr_ulsch_unscrambling_optim(gNB->pusch_vars[ULSCH_id]->llr,
+  nr_ulsch_unscrambling(gNB->pusch_vars[ULSCH_id]->llr,
                         G,
-			      0,
                         pusch_pdu->data_scrambling_id,
                         pusch_pdu->rnti);
   stop_meas(&gNB->ulsch_unscrambling_stats);

openair1/SCHED_NR_UE/defs.h

@@ -406,8 +406,7 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             PDSCH_t pdsch,
                             NR_UE_DLSCH_t *dlsch0,
                             NR_UE_DLSCH_t *dlsch1,
-                            int *dlsch_errors,
-                            uint8_t dlsch_parallel);
+                            int *dlsch_errors);
 
 int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                            UE_nr_rxtx_proc_t *proc,

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -492,187 +492,8 @@ int nr_ue_pdcch_procedures(uint8_t gNB_id,
   NR_UE_PDCCH *pdcch_vars = ue->pdcch_vars[proc->thread_id][gNB_id];
   fapi_nr_dl_config_dci_dl_pdu_rel15_t *rel15 = &pdcch_vars->pdcch_config[n_ss];
 
-  /*
-  //  unsigned int dci_cnt=0, i;  //removed for nr_ue_pdcch_procedures and added in the loop for nb_coreset_active
-#ifdef NR_PDCCH_SCHED_DEBUG
-  printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> Entering function nr_ue_pdcch_procedures() \n");
-#endif
-
-  int frame_rx = proc->frame_rx;
-  int nr_slot_rx = proc->nr_slot_rx;
-  NR_DCI_ALLOC_t dci_alloc_rx[8];
-  
-  //uint8_t next1_thread_id = proc->thread_id== (RX_NB_TH-1) ? 0:(proc->thread_id+1);
-  //uint8_t next2_thread_id = next1_thread_id== (RX_NB_TH-1) ? 0:(next1_thread_id+1);
-  
-
-  // table dci_fields_sizes_cnt contains dci_fields_sizes for each time a dci is decoded in the slot
-  // each element represents the size in bits for each dci field, for each decoded dci -> [dci_cnt-1]
-  // each time a dci is decode at dci_cnt, the values of the table dci_fields_sizes[i][j] will be copied at table dci_fields_sizes_cnt[dci_cnt-1][i][j]
-  // table dci_fields_sizes_cnt[dci_cnt-1][i][j] will then be used in function nr_extract_dci_info
-  uint8_t dci_fields_sizes_cnt[MAX_NR_DCI_DECODED_SLOT][NBR_NR_DCI_FIELDS][NBR_NR_FORMATS];
-
-  int nb_searchspace_active=0;
-  NR_UE_PDCCH **pdcch_vars = ue->pdcch_vars[proc->thread_id];
-  NR_UE_PDCCH *pdcch_vars2 = ue->pdcch_vars[proc->thread_id][gNB_id];
-  // s in TS 38.212 Subclause 10.1, for each active BWP the UE can deal with 10 different search spaces
-  // Higher layers have updated the number of searchSpaces with are active in the current slot and this value is stored in variable nb_searchspace_total
-  int nb_searchspace_total = pdcch_vars2->nb_search_space;
-
-  pdcch_vars[gNB_id]->crnti = 0x1234; //to be check how to set when using loop memory
-
-  uint16_t c_rnti=pdcch_vars[gNB_id]->crnti;
-  uint16_t cs_rnti=0,new_rnti=0,tc_rnti=0;
-  uint16_t p_rnti=P_RNTI;
-  uint16_t si_rnti=SI_RNTI;
-  uint16_t ra_rnti=99;
-  uint16_t sp_csi_rnti=0,sfi_rnti=0,int_rnti=0,tpc_pusch_rnti=0,tpc_pucch_rnti=0,tpc_srs_rnti=0; //FIXME
-  uint16_t crc_scrambled_values[TOTAL_NBR_SCRAMBLED_VALUES] =
-    {c_rnti,cs_rnti,new_rnti,tc_rnti,p_rnti,si_rnti,ra_rnti,sp_csi_rnti,sfi_rnti,int_rnti,tpc_pusch_rnti,tpc_pucch_rnti,tpc_srs_rnti};
-  #ifdef NR_PDCCH_SCHED_DEBUG
-  printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> there is a bug in FAPI to calculate nb_searchspace_total=%d\n",nb_searchspace_total);
-  #endif
-  if (nb_searchspace_total>1) nb_searchspace_total=1; // to be removed when fixing bug in FAPI
-  #ifdef NR_PDCCH_SCHED_DEBUG
-  printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> there is a bug in FAPI to calculate nb_searchspace_total so we set it to 1...\n");
-  printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> the number of searchSpaces active in the current slot(%d) is %d) \n",
-	 nr_slot_rx,nb_searchspace_total);
-  #endif
-
-  //FK: we define dci_ind and dl_indication as local variables, this way the call to the mac should be thread safe
-  fapi_nr_dci_indication_t dci_ind;
-  nr_downlink_indication_t dl_indication;
-  
-  // p in TS 38.212 Subclause 10.1, for each active BWP the UE can deal with 3 different CORESETs (including coresetId 0 for common search space)
-  //int nb_coreset_total = NR_NBR_CORESET_ACT_BWP;
-  unsigned int dci_cnt=0;
-  // this table contains 56 (NBR_NR_DCI_FIELDS) elements for each dci field and format described in TS 38.212. Each element represents the size in bits for each dci field
-  //uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS] = {{0}};
-  // this is the UL bandwidth part. FIXME! To be defined where this value comes from
-  //  uint16_t n_RB_ULBWP = 106;
-  // this is the DL bandwidth part. FIXME! To be defined where this value comes from
-
-  // First we have to identify each searchSpace active at a time and do PDCCH monitoring corresponding to current searchSpace
-  // Up to 10 searchSpaces can be configured to UE (s<=10)
-  for (nb_searchspace_active=0; nb_searchspace_active<nb_searchspace_total; nb_searchspace_active++){
-    int nb_coreset_active=nb_searchspace_active;
-    //int do_pdcch_monitoring_current_slot=1; // this variable can be removed and fapi is handling
-    
-     // The following code has been removed as it is handled by higher layers (fapi)
-     //
-     // Verify that monitoring is required at the slot nr_slot_rx. We will run pdcch procedure only if do_pdcch_monitoring_current_slot=1
-     // For Type0-PDCCH searchspace, we need to calculate the monitoring slot from Tables 13-1 .. 13-15 in TS 38.213 Subsection 13
-     //NR_UE_SLOT_PERIOD_OFFSET_t sl_period_offset_mon = pdcch_vars2->searchSpace[nb_searchspace_active].monitoringSlotPeriodicityAndOffset;
-     //if (sl_period_offset_mon == nr_sl1) {
-     //do_pdcch_monitoring_current_slot=1; // PDCCH monitoring in every slot
-     //} else if (nr_slot_rx%(uint16_t)sl_period_offset_mon == pdcch_vars2->searchSpace[nb_searchspace_active].monitoringSlotPeriodicityAndOffset_offset) {
-     //do_pdcch_monitoring_current_slot=1; // PDCCH monitoring in every monitoringSlotPeriodicityAndOffset slot with offset
-     //}
-    
-     // FIXME
-     // For PDCCH monitoring when overlap with SS/PBCH according to 38.213 v15.1.0 Section 10
-     // To be implemented LATER !!!
-     
-    //int _offset,_index,_M;
-    //int searchSpace_id                              = pdcch_vars2->searchSpace[nb_searchspace_active].searchSpaceId;
-
-
-    #ifdef NR_PDCCH_SCHED_DEBUG
-      printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> nb_searchspace_active=%d do_pdcch_monitoring_current_slot=%d (to be removed)\n",
-              nb_searchspace_active,
-              do_pdcch_monitoring_current_slot);
-    #endif
-
-//    if (do_pdcch_monitoring_current_slot) {
-      // the searchSpace indicates that we need to monitor PDCCH in current nr_slot_rx
-      // get the parameters describing the current SEARCHSPACE
-      // the CORESET id applicable to the current SearchSpace
-      //int searchSpace_coreset_id                      = pdcch_vars2->searchSpace[nb_searchspace_active].controlResourceSetId;
-      // FIXME this variable is a bit string (14 bits) identifying every OFDM symbol in a slot.
-      // at the moment we will not take into consideration this variable and we will consider that the OFDM symbol offset is always the first OFDM in a symbol
-      uint16_t symbol_within_slot_mon                 = pdcch_vars2->searchSpace[nb_searchspace_active].monitoringSymbolWithinSlot;
-      // get the remaining parameters describing the current SEARCHSPACE:     // FIXME! To be defined where we get this information from
-      //NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L1         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel1;
-      //NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L2         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel2;
-      //NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L4         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel4;
-      //NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L8         = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel8;
-      //NR_UE_SEARCHSPACE_nbrCAND_t num_cand_L16        = pdcch_vars2->searchSpace[nb_searchspace_active].nrofCandidates_aggrlevel16;
-                                                                                                  // FIXME! A table of five enum elements
-      // searchSpaceType indicates whether this is a common search space or a UE-specific search space
-      //int searchSpaceType                             = pdcch_vars2->searchSpace[nb_searchspace_active].searchSpaceType.type;
-      NR_SEARCHSPACE_TYPE_t searchSpaceType                             = ue_specific;//common;
-      #ifdef NR_PDCCH_SCHED_DEBUG
-        printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> searchSpaceType=%d is hardcoded THIS HAS TO BE FIXED!!!\n",
-                searchSpaceType);
-      #endif
-
-      //while ((searchSpace_coreset_id != pdcch_vars2->coreset[nb_coreset_active].controlResourceSetId) && (nb_coreset_active<nb_coreset_total)) {
-        // we need to identify the CORESET associated to the active searchSpace
-        //nb_coreset_active++;
-      if (nb_coreset_active >= nb_coreset_total) return 0; // the coreset_id could not be found. There is a problem
-      }
-
-
-    
-     //we do not need these parameters yet
-    
-     // get the parameters describing the current CORESET
-     //int coreset_duration                                      = pdcch_vars2->coreset[nb_coreset_active].duration;
-     //uint64_t coreset_freq_dom                                 = pdcch_vars2->coreset[nb_coreset_active].frequencyDomainResources;
-     //int coreset_shift_index                                   = pdcch_vars2->coreset[nb_coreset_active].cce_reg_mappingType.shiftIndex;
-    // NR_UE_CORESET_REG_bundlesize_t coreset_bundlesize         = pdcch_vars2->coreset[nb_coreset_active].cce_reg_mappingType.reg_bundlesize;
-    // NR_UE_CORESET_interleaversize_t coreset_interleaversize   = pdcch_vars2->coreset[nb_coreset_active].cce_reg_mappingType.interleaversize;
-    // NR_UE_CORESET_precoder_granularity_t precoder_granularity = pdcch_vars2->coreset[nb_coreset_active].precoderGranularity;
-    // int tci_statesPDCCH                                       = pdcch_vars2->coreset[nb_coreset_active].tciStatesPDCCH;
-    // int tci_present                                           = pdcch_vars2->coreset[nb_coreset_active].tciPresentInDCI;
-    // uint16_t pdcch_DMRS_scrambling_id                         = pdcch_vars2->coreset[nb_coreset_active].pdcchDMRSScramblingID;
-    
-
-    // A set of PDCCH candidates for a UE to monitor is defined in terms of PDCCH search spaces.
-    // Searchspace types:
-    // Type0-PDCCH  common search space for a DCI format with CRC scrambled by a SI-RNTI
-    // number of consecutive resource blocks and a number of consecutive symbols for
-    // the control resource set of the Type0-PDCCH common search space from
-    // the four most significant bits of RMSI-PDCCH-Config as described in Tables 13-1 through 13-10
-    // and determines PDCCH monitoring occasions
-    // from the four least significant bits of RMSI-PDCCH-Config,
-    // included in MasterInformationBlock, as described in Tables 13-11 through 13-15
-    // Type0A-PDCCH common search space for a DCI format with CRC scrambled by a SI-RNTI
-    // Type1-PDCCH  common search space for a DCI format with CRC scrambled by a RA-RNTI, or a TC-RNTI, or a C-RNTI
-    // Type2-PDCCH  common search space for a DCI format with CRC scrambled by a P-RNTI
-    // Type3-PDCCH  common search space for a DCI format with CRC scrambled by INT-RNTI, or SFI-RNTI,
-    // or TPC-PUSCH-RNTI, or TPC-PUCCH-RNTI, or TPC-SRS-RNTI, or C-RNTI, or CS-RNTI(s), or SP-CSI-RNTI
-
-
-
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PDCCH_PROCEDURES, VCD_FUNCTION_IN);
   start_meas(&ue->dlsch_rx_pdcch_stats);
 
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PDCCH, VCD_FUNCTION_IN);
-#ifdef NR_PDCCH_SCHED_DEBUG
-      printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> Entering function nr_rx_pdcch with gNB_id=%d (nb_coreset_active=%d, (symbol_within_slot_mon&0x3FFF)=%d, searchSpaceType=%d)\n",
-                  gNB_id,nb_coreset_active,(symbol_within_slot_mon&0x3FFF),
-                  searchSpaceType);
-#endif
-        nr_rx_pdcch(ue,
-                    frame_rx,
-                    nr_slot_rx,
-                    gNB_id,
-                    //(ue->frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI,
-                    SISO,
-                    ue->high_speed_flag,
-                    ue->is_secondary_ue,
-                    nb_coreset_active,
-                    (symbol_within_slot_mon&0x3FFF),
-                    searchSpaceType);
-#ifdef NR_PDCCH_SCHED_DEBUG
-          printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> Ending function nr_rx_pdcch(nb_coreset_active=%d, (symbol_within_slot_mon&0x3FFF)=%d, searchSpaceType=%d)\n",
-                  nb_coreset_active,(symbol_within_slot_mon&0x3FFF),
-                  searchSpaceType);
-#endif
-
-  */
-  
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PDCCH, VCD_FUNCTION_IN);
   nr_rx_pdcch(ue, proc, rel15);
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PDCCH, VCD_FUNCTION_OUT);
@@ -705,42 +526,6 @@ int nr_ue_pdcch_procedures(uint8_t gNB_id,
   ue->pdcch_vars[proc->thread_id][gNB_id]->dci_received += dci_cnt;
 
   dci_ind->number_of_dcis = dci_cnt;
-    /*
-    for (int i=0; i<dci_cnt; i++) {
-      
-	memset(&dci_ind.dci_list[i].dci,0,sizeof(fapi_nr_dci_pdu_rel15_t));
-	
-	dci_ind.dci_list[i].rnti = dci_alloc_rx[i].rnti;
-	dci_ind.dci_list[i].dci_format = dci_alloc_rx[i].format;
-	dci_ind.dci_list[i].n_CCE = dci_alloc_rx[i].firstCCE;
-	dci_ind.dci_list[i].N_CCE = (int)dci_alloc_rx[i].L;
-	
-	status = nr_extract_dci_info(ue,
-				     gNB_id,
-				     ue->frame_parms.frame_type,
-				     dci_alloc_rx[i].dci_length,
-				     dci_alloc_rx[i].rnti,
-				     dci_alloc_rx[i].dci_pdu,
-				     &dci_ind.dci_list[i].dci,
-				     dci_fields_sizes_cnt[i],
-				     dci_alloc_rx[i].format,
-				     nr_slot_rx,
-				     pdcch_vars2->n_RB_BWP[nb_searchspace_active],
-				     pdcch_vars2->n_RB_BWP[nb_searchspace_active],
-				     crc_scrambled_values);
-	
-	if(status == 0) {
-	  LOG_W(PHY,"<-NR_PDCCH_PHY_PROCEDURES_UE (nr_ue_pdcch_procedures)-> bad DCI %d !!! \n",dci_alloc_rx[i].format);
-	  return(-1);
-	}
-	
-	LOG_D(PHY,"<-NR_PDCCH_PHY_PROCEDURES_UE (nr_ue_pdcch_procedures)-> Ending function nr_extract_dci_info()\n");
-	
-
-        
-      } // end for loop dci_cnt
-    */
-
   // fill dl_indication message
   nr_fill_dl_indication(&dl_indication, dci_ind, NULL, proc, ue, gNB_id);
   //  send to mac
@@ -819,6 +604,7 @@ int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int gNB_
       first_symbol_with_data++;
     }
 
+    start_meas(&ue->rx_pdsch_stats);
     for (m = s0; m < (s1 + s0); m++) {
  
       dual_stream_UE = 0;
@@ -858,6 +644,7 @@ int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int gNB_
         proc->first_symbol_available = 1;
       }
     } // CRNTI active
+    stop_meas(&ue->rx_pdsch_stats);
   }
   return 0;
 }
@@ -868,8 +655,7 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             PDSCH_t pdsch,
                             NR_UE_DLSCH_t *dlsch0,
                             NR_UE_DLSCH_t *dlsch1,
-                            int *dlsch_errors,
-                            uint8_t dlsch_parallel) {
+                            int *dlsch_errors) {
 
   if (dlsch0==NULL)
     AssertFatal(0,"dlsch0 should be defined at this level \n");
@@ -998,12 +784,9 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             harq_pid,
                             pdsch==PDSCH?1:0,
                             dlsch0->harq_processes[harq_pid]->TBS>256?1:0);
-    if( dlsch_parallel) {
-      LOG_T(PHY,"dlsch decoding is parallelized, ret = %d\n", ret);
-    }
-    else {
-      LOG_T(PHY,"Sequential dlsch decoding , ret = %d\n", ret);
-    }
+
+    LOG_T(PHY,"dlsch decoding, ret = %d\n", ret);
+
 
     if(ret<dlsch0->max_ldpc_iterations+1)
       dec = true;
@@ -1078,13 +861,7 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                                harq_pid,
                                pdsch==PDSCH?1:0,//proc->decoder_switch,
                                dlsch1->harq_processes[harq_pid]->TBS>256?1:0);
-      if(dlsch_parallel) {
-        LOG_T(PHY,"CW dlsch decoding is parallelized, ret1 = %d\n", ret1);
-      }
-      else {
-
-        LOG_T(PHY,"CWW sequential dlsch decoding, ret1 = %d\n", ret1);
-      }
+      LOG_T(PHY,"CW dlsch decoding, ret1 = %d\n", ret1);
 
       stop_meas(&ue->dlsch_decoding_stats[proc->thread_id]);
       if (cpumeas(CPUMEAS_GETSTATE)) {
@@ -1598,6 +1375,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
   
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_IN);
+  start_meas(&ue->phy_proc_rx[proc->thread_id]);
 
   LOG_D(PHY," ****** start RX-Chain for Frame.Slot %d.%d (energy %d dB)******  \n",
         frame_rx%1024, nr_slot_rx,
@@ -1779,8 +1557,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
                            SI_PDSCH,
                            ue->dlsch_SI[gNB_id],
                            NULL,
-                           &ue->dlsch_SI_errors[gNB_id],
-                           dlsch_parallel);
+                           &ue->dlsch_SI_errors[gNB_id]);
 
     // deactivate dlsch once dlsch proc is done
     ue->dlsch_SI[gNB_id]->active = 0;
@@ -1804,8 +1581,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
                            P_PDSCH,
                            ue->dlsch_p[gNB_id],
                            NULL,
-                           &ue->dlsch_p_errors[gNB_id],
-                           dlsch_parallel);
+                           &ue->dlsch_p_errors[gNB_id]);
 
     // deactivate dlsch once dlsch proc is done
     ue->dlsch_p[gNB_id]->active = 0;
@@ -1828,8 +1604,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
                            RA_PDSCH,
                            ue->dlsch_ra[gNB_id],
                            NULL,
-                           &ue->dlsch_ra_errors[gNB_id],
-                           dlsch_parallel);
+                           &ue->dlsch_ra_errors[gNB_id]);
 
     // deactivate dlsch once dlsch proc is done
     ue->dlsch_ra[gNB_id]->active = 0;
@@ -1851,8 +1626,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
 			   PDSCH,
 			   ue->dlsch[proc->thread_id][gNB_id][0],
 			   ue->dlsch[proc->thread_id][gNB_id][1],
-			   &ue->dlsch_errors[gNB_id],
-			   dlsch_parallel);
+			   &ue->dlsch_errors[gNB_id]);
 
   stop_meas(&ue->dlsch_procedures_stat[proc->thread_id]);
   if (cpumeas(CPUMEAS_GETSTATE)) {
@@ -1867,48 +1641,9 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
 
  }
 
-start_meas(&ue->generic_stat);
-
-#if 0
-
-  if(nr_slot_rx==5 &&  ue->dlsch[proc->thread_id][gNB_id][0]->harq_processes[ue->dlsch[proc->thread_id][gNB_id][0]->current_harq_pid]->nb_rb > 20){
-       //write_output("decoder_llr.m","decllr",dlsch_llr,G,1,0);
-       //write_output("llr.m","llr",  &ue->pdsch_vars[proc->thread_id][gNB_id]->llr[0][0],(14*nb_rb*12*dlsch1_harq->Qm) - 4*(nb_rb*4*dlsch1_harq->Qm),1,0);
-
-       write_output("rxdataF0_current.m"    , "rxdataF0", &ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
-       //write_output("rxdataF0_previous.m"    , "rxdataF0_prev_sss", &ue->common_vars.common_vars_rx_data_per_thread[next_thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
-
-       //write_output("rxdataF0_previous.m"    , "rxdataF0_prev", &ue->common_vars.common_vars_rx_data_per_thread[next_thread_id].rxdataF[0][0],14*fp->ofdm_symbol_size,1,1);
-
-       write_output("dl_ch_estimates.m", "dl_ch_estimates_sfn5", &ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].dl_ch_estimates[0][0][0],14*fp->ofdm_symbol_size,1,1);
-       write_output("dl_ch_estimates_ext.m", "dl_ch_estimatesExt_sfn5", &ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_estimates_ext[0][0],14*fp->N_RB_DL*12,1,1);
-       write_output("rxdataF_comp00.m","rxdataF_comp00",         &ue->pdsch_vars[proc->thread_id][gNB_id]->rxdataF_comp0[0][0],14*fp->N_RB_DL*12,1,1);
-       //write_output("magDLFirst.m", "magDLFirst", &phy_vars_ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_mag0[0][0],14*fp->N_RB_DL*12,1,1);
-       //write_output("magDLSecond.m", "magDLSecond", &phy_vars_ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_magb0[0][0],14*fp->N_RB_DL*12,1,1);
-
-       AssertFatal (0,"");
-  }
-#endif
-
-  // duplicate harq structure
-/*
-  uint8_t          current_harq_pid        = ue->dlsch[proc->thread_id][gNB_id][0]->current_harq_pid;
-  NR_DL_UE_HARQ_t *current_harq_processes = ue->dlsch[proc->thread_id][gNB_id][0]->harq_processes[current_harq_pid];
-  NR_DL_UE_HARQ_t *harq_processes_dest    = ue->dlsch[next1_thread_id][gNB_id][0]->harq_processes[current_harq_pid];
-  NR_DL_UE_HARQ_t *harq_processes_dest1    = ue->dlsch[next2_thread_id][gNB_id][0]->harq_processes[current_harq_pid];
-  */
-  /*nr_harq_status_t *current_harq_ack = &ue->dlsch[proc->thread_id][gNB_id][0]->harq_ack[nr_slot_rx];
-  nr_harq_status_t *harq_ack_dest    = &ue->dlsch[next1_thread_id][gNB_id][0]->harq_ack[nr_slot_rx];
-  nr_harq_status_t *harq_ack_dest1    = &ue->dlsch[next2_thread_id][gNB_id][0]->harq_ack[nr_slot_rx];
-*/
-
-  //copy_harq_proc_struct(harq_processes_dest, current_harq_processes);
-//copy_ack_struct(harq_ack_dest, current_harq_ack);
-
-//copy_harq_proc_struct(harq_processes_dest1, current_harq_processes);
-//copy_ack_struct(harq_ack_dest1, current_harq_ack);
+  start_meas(&ue->generic_stat);
 
-if (nr_slot_rx==9) {
+  if (nr_slot_rx==9) {
     if (frame_rx % 10 == 0) {
       if ((ue->dlsch_received[gNB_id] - ue->dlsch_received_last[gNB_id]) != 0)
         ue->dlsch_fer[gNB_id] = (100*(ue->dlsch_errors[gNB_id] - ue->dlsch_errors_last[gNB_id]))/(ue->dlsch_received[gNB_id] - ue->dlsch_received_last[gNB_id]);
@@ -1932,25 +1667,23 @@ if (nr_slot_rx==9) {
 
   }
 
-stop_meas(&ue->generic_stat);
-if (cpumeas(CPUMEAS_GETSTATE))
+  stop_meas(&ue->generic_stat);
+  if (cpumeas(CPUMEAS_GETSTATE))
     LOG_D(PHY,"after tubo until end of Rx %5.2f \n",ue->generic_stat.p_time/(cpuf*1000.0));
 
 #ifdef EMOS
-phy_procedures_emos_UE_RX(ue,slot,gNB_id);
+  phy_procedures_emos_UE_RX(ue,slot,gNB_id);
 #endif
 
 
-VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_OUT);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_OUT);
 
-stop_meas(&ue->phy_proc_rx[proc->thread_id]);
-if (cpumeas(CPUMEAS_GETSTATE))
+  stop_meas(&ue->phy_proc_rx[proc->thread_id]);
+  if (cpumeas(CPUMEAS_GETSTATE))
     LOG_D(PHY, "------FULL RX PROC [SFN %d]: %5.2f ------\n",nr_slot_rx,ue->phy_proc_rx[proc->thread_id].p_time/(cpuf*1000.0));
 
-//#endif //pdsch
-
-LOG_D(PHY," ****** end RX-Chain  for AbsSubframe %d.%d ******  \n", frame_rx%1024, nr_slot_rx);
-return (0);
+  LOG_D(PHY," ****** end RX-Chain  for AbsSubframe %d.%d ******  \n", frame_rx%1024, nr_slot_rx);
+  return (0);
 }
 
 

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -90,8 +90,7 @@ bool nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
                             PDSCH_t pdsch,
                             NR_UE_DLSCH_t *dlsch0,
                             NR_UE_DLSCH_t *dlsch1,
-                            int *dlsch_errors,
-                            uint8_t dlsch_parallel) {
+                            int *dlsch_errors) {
   return false;
 }
 
@@ -713,7 +712,7 @@ int main(int argc, char **argv)
       }
       if (UE->is_synchronized == 0) {
 	UE_nr_rxtx_proc_t proc={0};
-	ret = nr_initial_sync(&proc, UE, 1, 0, 0);
+	ret = nr_initial_sync(&proc, UE, 1, 0);
 	printf("nr_initial_sync1 returns %d\n",ret);
 	if (ret<0) n_errors++;
       }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -273,7 +273,6 @@ bool is_xlsch_in_slot(uint64_t bitmap, sub_frame_t slot) {
 void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
                                frame_t frame,
                                sub_frame_t slot){
-  //pthread_mutex_lock(&mutextest);
 
   protocol_ctxt_t   ctxt={0};
   PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, module_idP, ENB_FLAG_YES, NOT_A_RNTI, frame, slot,module_idP);