Merge remote-tracking branch 'origin/develop-nr' into nr_pdcch_updates

Conflicts:
	openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

cmake_targets/build_oai

@@ -43,10 +43,10 @@ conf_nvram_path=$OPENAIR_DIR/openair3/NAS/TOOLS/ue_eurecom_test_sfr.conf
 MSC_GEN=0
 XFORMS="True"
 UE_EXPANSION="False"
+UESIM_EXPANSION="False"
 PRINT_STATS="False"
 VCD_TIMING="False"
-DEADLINE_SCHEDULER_FLAG_USER="False"
-FORCE_DEADLINE_SCHEDULER_FLAG_USER=""
+DEADLINE_SCHEDULER_FLAG_USER=""
 CPU_AFFINITY_FLAG_USER="False" #Only valid when lowlatecy flag is set to False
 REL="Rel15"
 NR_REL="NR_Rel15"
@@ -78,7 +78,7 @@ trap handle_ctrl_c INT
 function print_help() {
   echo_info "
 This program installs OpenAirInterface Software
-You should have ubuntu 14.xx, updated, and the Linux kernel >= 3.14
+You should have ubuntu 16.xx or 18.04 updated
 Options
 -h
    This help
@@ -116,7 +116,7 @@ Options
    Rel8 limits the implementation to 3GPP Release 8 version
    Rel10 limits the implementation to 3GPP Release 10 version
 -w | --hardware
-   EXMIMO, USRP, BLADERF, ETHERNET, LMSSDR, ADRV9371_ZC706, None (Default)
+   EXMIMO, USRP, BLADERF, ETHERNET, LMSSDR, ADRV9371_ZC706, SIMU, None (Default)
    Adds this RF board support (in external packages installation and in compilation)
 -t | --transport protocol
    ETHERNET , None
@@ -175,6 +175,9 @@ Options
 --basic-simulator
    Generates a basic [1 UE + 1 eNB + no channel] simulator.
    See targets/ARCH/tcp_bridge/README.tcp_bridge_oai for documentation.
+--rfsimulator
+   Generate virtual RF driver
+   to use it, set the environement variable RFSIMULATOR to \"enb\" in the eNB and to the eNB IP address in the UEs
 Usage (first build):
  NI/ETTUS B201  + COTS UE : ./build_oai -I  --eNB -x --install-system-files -w USRP
 Usage (Regular):
@@ -250,7 +253,7 @@ function main() {
        -w | --hardware)
             HW="$2" #"${i#*=}"
             # Use OAI_USRP  as the key word USRP is used inside UHD driver
-	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  ] ; then 
+	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  -a  "$HW" != "SIMU" ] ; then 
 		echo_fatal "Unknown HW type $HW will exit..."		
 	    else
 		if [ "$HW" == "USRP" ] ; then 
@@ -265,6 +268,9 @@ function main() {
 		if [ "$HW" == "LMSSDR" ] ; then 
 		    HW="OAI_LMSSDR"
 		fi 
+		if [ "$HW" == "SIMU" ] ; then
+                    HW="OAI_SIMU"
+                fi
 		echo_info "Setting hardware to: $HW"
 	    fi
             shift 2;;
@@ -332,11 +338,11 @@ function main() {
             echo_info "Will build doxygen support"
             shift;;     
             --disable-deadline)
-            FORCE_DEADLINE_SCHEDULER_FLAG_USER="False"
+                DEADLINE_SCHEDULER_FLAG_USER="False"
                 echo_info "Disabling the usage of deadline scheduler"
                 shift 1;;
             --enable-deadline)
-            FORCE_DEADLINE_SCHEDULER_FLAG_USER="True"
+                DEADLINE_SCHEDULER_FLAG_USER="True"
                 echo_info "Enabling the usage of deadline scheduler"
             shift 1;;
        --enable-cpu-affinity)
@@ -400,6 +406,10 @@ function main() {
             BASIC_SIMULATOR=1
             echo_info "Compiling the basic simulator"
             shift 1;;
+            --rfsimulator)
+                RFSIMULATOR=true
+                echo_info "Compiling the RF simulator"
+                shift 1;;
             -h | --help)
             print_help
             exit 1;;
@@ -442,31 +452,16 @@ function main() {
   fi
 
     echo_info "RF HW set to $HW" 
-  #Now we set flags to enable deadline scheduler settings
-  #By default: USRP: disable, 
-  #By default: BLADERF: enable,
-  #By default: EXMIMO: enable
-  if [ "$FORCE_DEADLINE_SCHEDULER_FLAG_USER" = "" ]; then
-     if [ "$HW" = "EXMIMO" ] ; then 
+    # If the user doesn't specify the Linux scheduler to use, we set a value
+    if [ "$DEADLINE_SCHEDULER_FLAG_USER" = "" ]; then
+	case "$HW" in
+            "EXMIMO")
 		DEADLINE_SCHEDULER_FLAG_USER="True"
-     elif [ "$HW" = "ETHERNET" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_USRP" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_ADRV9371_ZC706" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_BLADERF" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_LMSSDR" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "None" ] ; then 
+		;;
+            *)
 		DEADLINE_SCHEDULER_FLAG_USER="False"
-     else 
-        echo_error "Unknown HW type $HW. Exiting now..."
-        exit 
-     fi
-  else
-     DEADLINE_SCHEDULER_FLAG_USER=$FORCE_DEADLINE_SCHEDULER_FLAG_USER
+		;;
+	esac
     fi
 
   #Disable CPU Affinity for deadline scheduler

cmake_targets/tools/make_asn1c_includes.sh

+#!/bin/bash
+GENERATED_FULL_DIR=$1
+shift
+ASN1_SOURCE_DIR=$1
+shift
+export ASN1C_PREFIX=$1 
+shift
+options=$*
+done_flag="$GENERATED_FULL_DIR"/done
+if [ "$done_flag" -ot $ASN1_SOURCE_DIR ] ; then 
+   rm -f "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.c "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.h
+   mkdir -p "$GENERATED_FULL_DIR"
+   asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example $options -D $GENERATED_FULL_DIR $ASN1_SOURCE_DIR |& egrep -v "^Copied|^Compiled" | sort -u
+fi
+touch $done_flag

common/utils/backtrace.h

@@ -23,9 +23,16 @@
 
 #ifndef BACKTRACE_H_
 #define BACKTRACE_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 void display_backtrace(void);
 
 void backtrace_handle_signal(siginfo_t *info);
+#ifdef __cplusplus
+}
+#endif
+
 
 #endif /* BACKTRACE_H_ */

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c

@@ -206,6 +206,7 @@ decoder_node_t *new_decoder_node(int first_leaf_index,int level) {
   node->all_frozen=0;
   node->alpha      = (int16_t*)malloc16(node->Nv*sizeof(int16_t));
   node->beta       = (int16_t*)malloc16(node->Nv*sizeof(int16_t));
+  node->softbeta   = (int16_t*)malloc16(node->Nv*sizeof(int16_t));
   memset((void*)node->beta,-1,node->Nv*sizeof(int16_t));
   
 
@@ -383,15 +384,17 @@ void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
     }
     if (node->Nv == 2) { // apply hard decision on left node
       betal[0] = (alpha_l[0]>0) ? -1 : 1;
+      node->left->softbeta[0] = alpha_l[0];
 #ifdef DEBUG_NEW_IMPL
-      printf("betal[0] %d (%p)\n",betal[0],&betal[0]);
+      printf("betal[0] %d (%p), softbeta %d \n",betal[0],&betal[0],node->left->softbeta[0]);
 #endif
       pp->nr_polar_U[node->first_leaf_index] = (1+betal[0])>>1; 
-#ifdef DEBUG_NEW_IMPL
+      //#ifdef DEBUG_NEW_IMPL
       printf("Setting bit %d to %d (LLR %d)\n",node->first_leaf_index,(betal[0]+1)>>1,alpha_l[0]);
-#endif
+      //#endif
     }
   }
+  else for (int i=0;i<node->Nv/2;i++) node->left->softbeta[i]=32767;
 }
 
 void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
@@ -455,10 +458,11 @@ void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
       }
     if (node->Nv == 2) { // apply hard decision on right node
       betar[0] = (alpha_r[0]>0) ? -1 : 1;
+      node->right->softbeta[0] = alpha_r[0];
       pp->nr_polar_U[node->first_leaf_index+1] = (1+betar[0])>>1;
-#ifdef DEBUG_NEW_IMPL
+      //#ifdef DEBUG_NEW_IMPL
       printf("Setting bit %d to %d (LLR %d)\n",node->first_leaf_index+1,(betar[0]+1)>>1,alpha_r[0]);
-#endif
+      //#endif
     } 
   }
 }
@@ -469,11 +473,15 @@ int16_t all1[16] = {1,1,1,1,
 		    1,1,1,1,
 		    1,1,1,1};
 
-void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
+void computeBeta(t_nrPolar_params *pp,decoder_node_t *node, int do_softbeta) {
 
   int16_t *betav     = node->beta;
   int16_t *betal     = node->left->beta;
   int16_t *betar     = node->right->beta;
+  int16_t *softbetav = node->softbeta;
+  int16_t *softbetal = node->left->softbeta;
+  int16_t *softbetar = node->right->softbeta;
+
 #ifdef DEBUG_NEW_IMPL
   printf("Computing beta @ level %d first_leaf_index %d (all_frozen %d)\n",node->level,node->first_leaf_index,node->left->all_frozen);
 #endif
@@ -498,14 +506,14 @@ void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
     }
     else
 #else
-    int avx2mod = (node->Nv/2)&15;
+    int sse4mod = (node->Nv/2)&7;
 
     if (ssr4mod == 0) {
       int ssr4len = node->Nv/2/8;
       register __m128i allones=*((__m128i*)all1);
       for (int i=0;i<sse4len;i++) {
-      ((__m256i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i],
-							  ((__m128i*)betal)[i]),allones));
+      ((__m128i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i],
+							  ((__m128i*)betal)[i]),allones);
       }
     }
     else if (sse4mod == 4) {
@@ -521,21 +529,45 @@ void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
       }
   }
   else memcpy((void*)&betav[0],betar,(node->Nv/2)*sizeof(int16_t));
+
   memcpy((void*)&betav[node->Nv/2],betar,(node->Nv/2)*sizeof(int16_t));
 
+// softbeta computation
+  if (do_softbeta==1) {
+
+    int16_t a,b,absa,absb,maska,maskb,minabs;
+
+    for (int i=0;i<node->Nv/2;i++) {
+      a=softbetal[i];
+      b=softbetar[i];
+      maska=a>>15;
+      maskb=b>>15;
+      absa=(a+maska)^maska;
+      absb=(b+maskb)^maskb;
+      minabs = absa<absb ? absa : absb;
+      softbetav[i] = (maska^maskb)!=0 ? -minabs : minabs;
+#ifdef DEBUG_NEW_IMPL
+      printf("Nv %d, first_leaf %d: beta_v[%d] %d (%d,%d) softbetav[%d] %d (%d,%d)\n",node->Nv,node->first_leaf_index,i,betav[i],betal[i],betar[i],i,softbetav[i],a,b);
+#endif
+    }
+    memcpy((void*)&softbetav[node->Nv/2],(void*)softbetar,sizeof(int16_t)*node->Nv/2);
+  }
+ 
+
+
 }
 
-void generic_polar_decoder(t_nrPolar_params *pp,decoder_node_t *node) {
+void generic_polar_decoder(t_nrPolar_params *pp,decoder_node_t *node, int do_softbeta) {
 
 
   // Apply F to left
   applyFtoleft(pp,node);
   // if left is not a leaf recurse down to the left
-  if (node->left->leaf==0) generic_polar_decoder(pp,node->left);
+  if (node->left->leaf==0) generic_polar_decoder(pp,node->left,do_softbeta);
 
   applyGtoright(pp,node);
-  if (node->right->leaf==0) generic_polar_decoder(pp,node->right);	
+  if (node->right->leaf==0) generic_polar_decoder(pp,node->right,do_softbeta);	
 
-  computeBeta(pp,node);
+  computeBeta(pp,node,do_softbeta);
 
 } 

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -70,7 +70,7 @@ typedef struct decoder_node_t_s {
   int all_frozen;
   int16_t *alpha;
   int16_t *beta;
-  int16_t *soft_beta;
+  int16_t *softbeta;
 } decoder_node_t;
 
 typedef struct decoder_tree_t_s {
@@ -118,7 +118,7 @@ struct nrPolar_params {
   uint64_t cprime_tab1[32][256];
   uint64_t B_tab0[32][256];
   uint64_t B_tab1[32][256];
-  uint32_t* crc256Table;
+  uint32_t *crc256Table;
   uint8_t **extended_crc_generator_matrix;
   //lowercase: bits, Uppercase: Bits stored in bytes
   //polar_encoder vectors
@@ -137,79 +137,72 @@ struct nrPolar_params {
   decoder_tree_t tree;
 } __attribute__ ((__packed__));
 typedef struct nrPolar_params t_nrPolar_params;
-typedef t_nrPolar_params *t_nrPolar_paramsPtr;
 
 void polar_encoder(uint32_t *input,
                    uint32_t *output,
-				   t_nrPolar_paramsPtr polarParams);
+                   t_nrPolar_params *polarParams);
 
 void polar_encoder_dci(uint32_t *in,
                        uint32_t *out,
-					   t_nrPolar_paramsPtr polarParams,
+                       t_nrPolar_params *polarParams,
                        uint16_t n_RNTI);
 
 void polar_encoder_fast(uint64_t *A,
                         uint32_t *out,
                         int32_t crcmask,
-			t_nrPolar_paramsPtr polarParams);
+                        t_nrPolar_params *polarParams);
 
 int8_t polar_decoder(double *input,
                      uint8_t *output,
-					 t_nrPolar_paramsPtr polarParams,
+                     t_nrPolar_params *polarParams,
                      uint8_t listSize,
                      uint8_t pathMetricAppr);
 
 uint32_t polar_decoder_int16(int16_t *input,
                              uint64_t *out,
-			     t_nrPolar_params *polarParams);
+                             const t_nrPolar_params *polarParams);
 
 int8_t polar_decoder_aPriori(double *input,
                              uint32_t *output,
-							 t_nrPolar_paramsPtr polarParams,
+                             t_nrPolar_params *polarParams,
                              uint8_t listSize,
                              uint8_t pathMetricAppr,
                              double *aPrioriPayload);
 
 int8_t polar_decoder_aPriori_timing(double *input,
                                     uint32_t *output,
-									t_nrPolar_paramsPtr polarParams,
+                                    t_nrPolar_params *polarParams,
                                     uint8_t listSize,
                                     uint8_t pathMetricAppr,
                                     double *aPrioriPayload,
                                     double cpuFreqGHz,
-									FILE* logFile);
+                                    FILE *logFile);
 
 int8_t polar_decoder_dci(double *input,
                          uint32_t *out,
-						 t_nrPolar_paramsPtr polarParams,
+                         t_nrPolar_params *polarParams,
                          uint8_t listSize,
                          uint8_t pathMetricAppr,
                          uint16_t n_RNTI);
 
 void generic_polar_decoder(t_nrPolar_params *,
-		decoder_node_t *);
+                           decoder_node_t *,int);
 
 void build_decoder_tree(t_nrPolar_params *pp);
-void build_polar_tables(t_nrPolar_paramsPtr polarParams);
+void build_polar_tables(t_nrPolar_params *polarParams);
 void init_polar_deinterleaver_table(t_nrPolar_params *polarParams);
 
-void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
-				   int8_t messageType,
-				   uint16_t messageLength,
-				   uint8_t aggregation_level);
-
-void nr_polar_print_polarParams(t_nrPolar_paramsPtr polarParams);
+void nr_polar_print_polarParams(t_nrPolar_params *polarParams);
 
-t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
-									 int8_t messageType,
+t_nrPolar_params *nr_polar_params ( int8_t messageType,
                                     uint16_t messageLength,
                                     uint8_t aggregation_level);
 
 uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level);
 
-uint8_t** nr_polar_kronecker_power_matrices(uint8_t n);
+uint8_t **nr_polar_kronecker_power_matrices(uint8_t n);
 
-const uint16_t* nr_polar_sequence_pattern(uint8_t n);
+const uint16_t *nr_polar_sequence_pattern(uint8_t n);
 
 /*!@fn uint32_t nr_polar_output_length(uint16_t K, uint16_t E, uint8_t n_max)
  * @brief Computes...
@@ -390,16 +383,14 @@ uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);
 static inline void nr_polar_interleaver(uint8_t *input,
                                         uint8_t *output,
                                         uint16_t *pattern,
-					uint16_t size)
-{
+                                        uint16_t size) {
   for (int i=0; i<size; i++) output[i]=input[pattern[i]];
 }
 
 static inline void nr_polar_deinterleaver(uint8_t *input,
     uint8_t *output,
     uint16_t *pattern,
-					  uint16_t size)
-{
+    uint16_t size) {
   for (int i=0; i<size; i++) {
     output[pattern[i]]=input[i];
   }

openair1/PHY/CODING/nr_polar_init.c

@@ -37,16 +37,14 @@
 #include "PHY/NR_TRANSPORT/nr_dci.h"
 
 static int intcmp(const void *p1,const void *p2) {
-
-  return(*(int16_t*)p1 > *(int16_t*)p2);
+  return(*(int16_t *)p1 > *(int16_t *)p2);
 }
 
-void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
+static void nr_polar_init(t_nrPolar_params * *polarParams,
                           int8_t messageType,
                           uint16_t messageLength,
-		   uint8_t aggregation_level)
-{
-	t_nrPolar_paramsPtr currentPtr = *polarParams;
+                          uint8_t aggregation_level) {
+  t_nrPolar_params *currentPtr = *polarParams;
   uint16_t aggregation_prime = nr_polar_aggregation_prime(aggregation_level);
 
   //Parse the list. If the node is already created, return without initialization.
@@ -58,10 +56,9 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 
   //  printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams);
   //Else, initialize and add node to the end of the linked list.
-	t_nrPolar_paramsPtr newPolarInitNode = malloc(sizeof(t_nrPolar_params));
+  t_nrPolar_params *newPolarInitNode = malloc(sizeof(t_nrPolar_params));
 
   if (newPolarInitNode != NULL) {
-
     newPolarInitNode->idx = (messageType * messageLength * aggregation_prime);
     newPolarInitNode->nextPtr = NULL;
     //printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
@@ -93,7 +90,6 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
       newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
       //printf("Initializing polar parameters for DCI (K %d, E %d, L %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength,aggregation_level);
     } else if (messageType == -1) { //UCI
-
     } else {
       AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
     }
@@ -102,31 +98,25 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
     newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K, newPolarInitNode->encoderLength, newPolarInitNode->n_max);
     newPolarInitNode->n = log2(newPolarInitNode->N);
     newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n);
-
     //polar_encoder vectors:
     newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits);
     newPolarInitNode->nr_polar_aPrime = malloc(sizeof(uint8_t) * ((ceil((newPolarInitNode->payloadBits)/32.0)*4)+3));
     newPolarInitNode->nr_polar_APrime = malloc(sizeof(uint8_t) * newPolarInitNode->K);
     newPolarInitNode->nr_polar_D = malloc(sizeof(uint8_t) * newPolarInitNode->N);
     newPolarInitNode->nr_polar_E = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength);
-
     //Polar Coding vectors
     newPolarInitNode->nr_polar_U = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat
     newPolarInitNode->nr_polar_CPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat
     newPolarInitNode->nr_polar_B = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat
     newPolarInitNode->nr_polar_A = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat
-
-
-
     newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n);
-
     newPolarInitNode->interleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
     nr_polar_interleaving_pattern(newPolarInitNode->K,
                                   newPolarInitNode->i_il,
                                   newPolarInitNode->interleaving_pattern);
-
     newPolarInitNode->deinterleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
-		for (int i=0;i<newPolarInitNode->K;i++)
+
+    for (int i=0; i<newPolarInitNode->K; i++)
       newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i;
 
     newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
@@ -137,13 +127,14 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
                                    newPolarInitNode->K,
                                    newPolarInitNode->N,
                                    newPolarInitNode->encoderLength);
-
     newPolarInitNode->information_bit_pattern = malloc(sizeof(uint8_t) * newPolarInitNode->N);
     newPolarInitNode->Q_I_N = malloc(sizeof(int16_t) * (newPolarInitNode->K + newPolarInitNode->n_pc));
     newPolarInitNode->Q_F_N = malloc( sizeof(int16_t) * (newPolarInitNode->N + 1)); // Last element shows the final array index assigned a value.
     newPolarInitNode->Q_PC_N = malloc( sizeof(int16_t) * (newPolarInitNode->n_pc));
+
     for (int i = 0; i <= newPolarInitNode->N; i++)
       newPolarInitNode->Q_F_N[i] = -1; // Empty array.
+
     nr_polar_info_bit_pattern(newPolarInitNode->information_bit_pattern,
                               newPolarInitNode->Q_I_N,
                               newPolarInitNode->Q_F_N,
@@ -154,81 +145,63 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
                               newPolarInitNode->encoderLength,
                               newPolarInitNode->n_pc);
     // sort the Q_I_N array in ascending order (first K positions)
-		qsort((void*)newPolarInitNode->Q_I_N,newPolarInitNode->K,sizeof(int16_t),intcmp);
- 
+    qsort((void *)newPolarInitNode->Q_I_N,newPolarInitNode->K,sizeof(int16_t),intcmp);
     newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
     nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern,
                                          newPolarInitNode->i_bil,
                                          newPolarInitNode->encoderLength);
-
     free(J);
-
     build_decoder_tree(newPolarInitNode);
     build_polar_tables(newPolarInitNode);
     init_polar_deinterleaver_table(newPolarInitNode);
-
     //printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes);
-
   } else {
-		AssertFatal(1 == 0, "[nr_polar_init] New t_nrPolar_paramsPtr could not be created");
-	}
-
-	currentPtr = *polarParams;
-	//If polarParams is empty:
-	if (currentPtr == NULL)
-	{
-		*polarParams = newPolarInitNode;
-		//printf("Creating first polarParams entry index %d, %p\n",newPolarInitNode->idx,*polarParams);
-		return;
+    AssertFatal(1 == 0, "[nr_polar_init] New t_nrPolar_params * could not be created");
   }
-	//Else, add node to the end of the linked list.
-	while (currentPtr->nextPtr != NULL) {
-	  currentPtr = currentPtr->nextPtr;
-	}
-	currentPtr->nextPtr= newPolarInitNode;
-	printf("Adding new polarParams entry to list index %d,%p\n",
-	       newPolarInitNode->idx,
-	       currentPtr->nextPtr);
 
+  //Fixme: the list is not thread safe
+  //The defect is not critical: we always append (never delete items) and adding two times the same is fine
+  newPolarInitNode->nextPtr=*polarParams;
+  *polarParams=newPolarInitNode;
   return;
 }
 
-void nr_polar_print_polarParams(t_nrPolar_paramsPtr polarParams)
-{
+void nr_polar_print_polarParams(t_nrPolar_params *polarParams) {
   uint8_t i = 0;
+
   if (polarParams == NULL) {
     printf("polarParams is empty.\n");
   } else {
-		while (polarParams != NULL){
+    while (polarParams != NULL) {
       printf("polarParams[%d] = %d\n", i, polarParams->idx);
       polarParams = polarParams->nextPtr;
       i++;
     }
   }
+
   return;
 }
 
-t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
-				     int8_t messageType,
+t_nrPolar_params *nr_polar_params ( int8_t messageType,
                                     uint16_t messageLength,
-				     uint8_t aggregation_level)
-{
-	t_nrPolar_paramsPtr currentPtr = NULL;
+                                    uint8_t aggregation_level) {
+  static t_nrPolar_params *polarList = NULL;
+  nr_polar_init(&polarList, messageType,messageLength,aggregation_level);
+  t_nrPolar_params *polarParams=polarList;
+  const int tag=messageType * messageLength * nr_polar_aggregation_prime(aggregation_level);
 
   while (polarParams != NULL) {
-		if (polarParams->idx ==
-				(messageType * messageLength * (nr_polar_aggregation_prime(aggregation_level)) )) {
-			currentPtr = polarParams;
-			break;
-		} else {
+    if (polarParams->idx == tag)
+      return polarParams;
+
     polarParams = polarParams->nextPtr;
   }
-	}
-	return currentPtr;
+
+  AssertFatal(false,"Polar Init tables internal failure\n");
+  return NULL;
 }
 
-uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level)
-{
+uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level) {
   if (aggregation_level == 0) return 0;
   else if (aggregation_level == 1) return NR_POLAR_AGGREGATION_LEVEL_1_PRIME;
   else if (aggregation_level == 2) return NR_POLAR_AGGREGATION_LEVEL_2_PRIME;

openair1/PHY/CODING/nr_segmentation.c

@@ -126,7 +126,7 @@ else
 
   } else {
     //msg("nr_segmentation.c: Illegal codeword size !!!\n");
-    return(-1);
+    return -1;
   }
   *Zout = *K;
   *K = *K*Kb;
@@ -140,10 +140,11 @@ else
 
   if ((input_buffer) && (output_buffers)) {
 
-    s=0;
+    s = 0;
 
     for (r=0; r<*C; r++) {
 
+      k = 0;
       Kprime = Bprime_by_C;
 
       while (k<((Kprime - L)>>3)) {
@@ -153,11 +154,12 @@ else
         s++;
       }
 
-      if (*F>0)
+      if (*F>0) {
         for (k=Kprime>>3; k<(*K)>>3; k++) {
           output_buffers[r][k] = NR_NULL;
           //printf("r %d filler bits [%d] = %d Kprime %d \n", r,k, output_buffers[r][k], Kprime);
         }
+      }
 
       if (*C > 1) { // add CRC
         crc = crc24b(output_buffers[r],Kprime-L)>>8;
@@ -165,12 +167,10 @@ else
         output_buffers[r][1+((Kprime-L)>>3)] = ((uint8_t*)&crc)[1];
         output_buffers[r][2+((Kprime-L)>>3)] = ((uint8_t*)&crc)[0];
       }
-
-      k=0;
     }
   }
 
-  return(0);
+  return 0;
 }
 
 

openair1/PHY/INIT/nr_init_ue.c

@@ -670,7 +670,7 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
 
   // many memory allocation sizes are hard coded
   AssertFatal( fp->nb_antennas_rx <= 2, "hard coded allocation for ue_common_vars->dl_ch_estimates[eNB_id]" );
-  AssertFatal( ue->n_connected_eNB <= NUMBER_OF_CONNECTED_eNB_MAX, "n_connected_eNB is too large" );
+  AssertFatal( nb_connected_eNB <= NUMBER_OF_CONNECTED_eNB_MAX, "n_connected_eNB is too large" );
   // init phy_vars_ue
 
   for (i=0; i<4; i++) {
@@ -919,10 +919,10 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
 
   for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
     for (j=0; j<2; j++) {
-      for (k=0; k<2; k++) {
+      for (k=0; k<RX_NB_TH_MAX; k++) {
 	AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
 
-	LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[i][j]);
+	LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[k][i][j]);
       }
     }
 

openair1/PHY/INIT/nr_parms.c

@@ -156,6 +156,9 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
   }
 
   fp->slots_per_frame = 10* fp->slots_per_subframe;
+
+  fp->nb_antenna_ports_eNB = 1; // default value until overwritten by RRCConnectionReconfiguration
+
   fp->symbols_per_slot = ((Ncp == NORMAL)? 14 : 12); // to redefine for different slot formats
   fp->samples_per_subframe_wCP = fp->ofdm_symbol_size * fp->symbols_per_slot * fp->slots_per_subframe;
   fp->samples_per_frame_wCP = 10 * fp->samples_per_subframe_wCP;

openair1/PHY/NR_TRANSPORT/nr_dci.h

@@ -30,12 +30,11 @@ typedef unsigned __int128 uint128_t;
 uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
                          nfapi_nr_rnti_type_e rnti_type,
                          uint16_t N_RB,
-                        nfapi_nr_config_request_t* config);
+                         nfapi_nr_config_request_t *config);
 
 uint8_t nr_generate_dci_top(NR_gNB_PDCCH pdcch_vars,
-                            t_nrPolar_paramsPtr *nrPolar_params,
                             uint32_t **gold_pdcch_dmrs,
-                            int32_t* txdataF,
+                            int32_t *txdataF,
                             int16_t amp,
                             NR_DL_FRAME_PARMS frame_parms,
                             nfapi_nr_config_request_t config);
@@ -44,7 +43,7 @@ void nr_pdcch_scrambling(uint32_t *in,
                          uint16_t size,
                          uint32_t Nid,
                          uint32_t n_RNTI,
-                         uint32_t* out);
+                         uint32_t *out);
 
 void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
                            int frame,
@@ -54,7 +53,7 @@ void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
                            nfapi_nr_dl_config_dci_dl_pdu *pdu,
                            nfapi_nr_dl_config_dlsch_pdu *dlsch_pdu);
 
-void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m);
+void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t *dci_alloc, uint16_t n_shift, uint8_t m);
 
 
 #endif //__PHY_NR_TRANSPORT_DCI__H

openair1/PHY/NR_TRANSPORT/nr_transport.h

@@ -36,7 +36,7 @@ int nr_generate_pss(  int16_t *d_pss,
                       int32_t *txdataF,
                       int16_t amp,
                       uint8_t ssb_start_symbol,
-                      nfapi_nr_config_request_t* config,
+                      nfapi_nr_config_request_t *config,
                       NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
@@ -49,7 +49,7 @@ int nr_generate_sss(  int16_t *d_sss,
                       int32_t *txdataF,
                       int16_t amp,
                       uint8_t ssb_start_symbol,
-                      nfapi_nr_config_request_t* config,
+                      nfapi_nr_config_request_t *config,
                       NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
@@ -62,7 +62,7 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
                           int32_t *txdataF,
                           int16_t amp,
                           uint8_t ssb_start_symbol,
-                          nfapi_nr_config_request_t* config,
+                          nfapi_nr_config_request_t *config,
                           NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
@@ -85,7 +85,6 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
 @returns 0 on success
  */
 int nr_generate_pbch(NR_gNB_PBCH *pbch,
-                     t_nrPolar_paramsPtr polar_params,
                      uint8_t *pbch_pdu,
                      uint8_t *interleaver,
                      int32_t *txdataF,
@@ -95,7 +94,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
                      uint8_t Lmax,
                      uint8_t ssb_index,
                      int sfn,
-                     nfapi_nr_config_request_t* config,
+                     nfapi_nr_config_request_t *config,
                      NR_DL_FRAME_PARMS *frame_parms);
 
 /*!

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -516,7 +516,8 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                            p_nrLDPC_procBuf[r],
                            p_procTime);
 
-		if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
+		// Fixme: correct type is unsigned, but nrLDPC_decoder and all called behind use signed int
+		if (check_crc((uint8_t*)llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
 		  printf("CRC OK\n");
 		  ret = 2;
 		}

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -1350,7 +1350,7 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
   unsigned char aatx,aarx,pilots=0;
   __m128i *dl_ch128,*dl_ch128_2,*dl_ch_mag128,*dl_ch_mag128b,*rxdataF128,*rxdataF_comp128,*rho128;
   __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp128,QAM_amp128b;
-
+  QAM_amp128b = _mm_setzero_si128();
 
   if (symbol == 2){
       pilots=1;

openair1/PHY/NR_UE_TRANSPORT/nr_prach.c

@@ -577,7 +577,7 @@ int32_t generate_nr_prach( PHY_VARS_NR_UE *ue, uint8_t eNB_id, uint8_t subframe,
   uint8_t preamble_index     = ue->prach_resources[eNB_id]->ra_PreambleIndex;
   //uint8_t tdd_mapindex       = ue->prach_resources[eNB_id]->ra_TDD_map_index;
   int16_t *prachF           = ue->prach_vars[eNB_id]->prachF;
-  static int16_t prach_tmp[45600*2] __attribute__((aligned(32)));
+  static int16_t prach_tmp[45600*4] __attribute__((aligned(32)));
   int16_t *prach            = prach_tmp;
   int16_t *prach2;
   int16_t amp               = ue->prach_vars[eNB_id]->amp;

openair1/PHY/defs_gNB.h

@@ -391,7 +391,6 @@ typedef struct PHY_VARS_gNB_s {
   Sched_Rsp_t         Sched_INFO;
   NR_gNB_PDCCH        pdcch_vars;
   NR_gNB_PBCH         pbch;
-  t_nrPolar_paramsPtr nrPolar_params;
   LTE_eNB_PHICH       phich_vars[2];
 
   NR_gNB_COMMON       common_vars;