Merge remote-tracking branch 'origin/develop' into F1C_extensions_develop

2022-03-14 11:39:13 +01:00
parent 14ec3e505d a981291ba8
commit 12eed23f63
211 changed files with 4469 additions and 23795 deletions
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -33,7 +33,9 @@ podSecurityContext:

 securityContext:
  privileged: true
-  # capabilities:
+  capabilities:
+    add:
+      - SYS_CAP_PTRACE
  #   drop:
  #   - ALL
  # readOnlyRootFilesystem: true
@@ -106,6 +106,9 @@ class Containerize():
 		self.registrySvrId = ''
 		self.testSvrId = ''

+		#checkers from xml
+		self.ran_checkers={}
+
 #-----------------------------------------------------------
 # Container management functions
 #-----------------------------------------------------------
@@ -624,7 +627,7 @@ class Containerize():
 		else:
 			if containerToKill:
 				logging.debug('\u001B[1m Analyzing ' + nodeB_prefix + 'NB logfile \u001B[0m ' + self.eNB_logFile[self.eNB_instance])
-				logStatus = RAN.AnalyzeLogFile_eNB(self.eNB_logFile[self.eNB_instance], HTML)
+				logStatus = RAN.AnalyzeLogFile_eNB(self.eNB_logFile[self.eNB_instance], HTML, self.ran_checkers)
 			else:
 				logStatus = 0
 			if (logStatus < 0):
@@ -788,9 +791,10 @@ class Containerize():
 					continue

 				logging.debug('\u001B[1m Analyzing xNB logfile ' + filename + ' \u001B[0m')
-				logStatus = RAN.AnalyzeLogFile_eNB(filename, HTML)
+				logStatus = RAN.AnalyzeLogFile_eNB(filename, HTML, self.ran_checkers)
 				if (logStatus < 0):
 					fullStatus = False
+					self.exitStatus = 1
 					HTML.CreateHtmlTestRow(RAN.runtime_stats, 'KO', logStatus)
 				else:
 					HTML.CreateHtmlTestRow(RAN.runtime_stats, 'OK', CONST.ALL_PROCESSES_OK)
@@ -30,11 +30,15 @@



-
+import logging
 import re
 import subprocess
-import logging
-import math
+import sshconnection
+
+logging.basicConfig(
+	level=logging.DEBUG,
+	format="[%(asctime)s] %(name)s:%(levelname)s: %(message)s"
+)

 class Log_Mgt:

@@ -49,40 +53,25 @@ class Log_Mgt:
 #-----------------$


-	def __CheckAvailSpace(self):
+	def __CheckUsedSpace(self):
 		HOST=self.Username+'@'+self.IPAddress
 		COMMAND="df "+ self.path
 		ssh = subprocess.Popen(["ssh", "%s" % HOST, COMMAND],shell=False,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
 		result = ssh.stdout.readlines()
 		s=result[1].decode('utf-8').rstrip()#result[1] is the second line with the results we are looking for
-		tmp=s.split()
-		return tmp[3] #return avail space from the line
+		used=s.split()[4] #get 4th field ex: 70%
+		m = re.match('^(\d+)\%',used)
+		if m is not None:
+			return int(m.group(1))

-	def __GetOldestFile(self):
-		HOST=self.Username+'@'+self.IPAddress
-		COMMAND="ls -rtl "+ self.path #-rtl will bring oldest file on top
-		ssh = subprocess.Popen(["ssh", "%s" % HOST, COMMAND],shell=False,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
-		result = ssh.stdout.readlines()
-		s=result[1].decode('utf-8').rstrip()
-		tmp=s.split()
-		return tmp[8]#return filename from the line
+	def __RemoveOldest(self):
+		mySSH = sshconnection.SSHConnection()
+		mySSH.open(self.IPAddress, self.Username, self.Password)
+		COMMAND='echo ' + self.Password + ' | sudo -S find ' + self.path + ' -type f -mtime +14 -delete'
+		mySSH.command(COMMAND,'\$',20)
+		mySSH.close()


-	def __AvgSize(self):
-		HOST=self.Username+'@'+self.IPAddress
-		COMMAND="ls -rtl "+ self.path
-		ssh = subprocess.Popen(["ssh", "%s" % HOST, COMMAND],shell=False,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
-		result = ssh.stdout.readlines()
-		if len(result)>1: #at least 1 file present
-			total_size=0
-			for i in range(1,len(result)):
-				s=result[i].decode('utf-8').rstrip()
-				tmp=s.split()
-				total_size+=int(tmp[4]) #get filesize
-			return math.floor(total_size/(len(result)-1)) #compute average file/artifact size
-		else:#empty,no files
-			return 0
-

 #-----------------$
 #PUBLIC Methods$
@@ -90,17 +79,15 @@ class Log_Mgt:


 	def LogRotation(self):
-		avail_space =int(self.__CheckAvailSpace())*1000 #avail space in target folder, initially displayed in Gb
-		avg_size=self.__AvgSize() #average size of artifacts in the target folder
-		logging.debug("Avail Space : " + str(avail_space) + " / Artifact Avg Size : " + str(avg_size))
-		if avail_space < 50*avg_size: #reserved space is 50x artifact file ; oldest file will be deleted
-			oldestfile=self.__GetOldestFile()
-			HOST=self.Username+'@'+self.IPAddress
-			COMMAND="echo " + self.Password + " | sudo -S rm "+ self.path + "/" + oldestfile
-			logging.debug(COMMAND)
-			ssh = subprocess.Popen(["ssh", "%s" % HOST, COMMAND],shell=False,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
+		used_space = self.__CheckUsedSpace() #avail space in target folder
+		if used_space > 80 :
+			logging.debug('\u001B[1;37;41m  Used Disk > 80%, on '  + self.Username+'@'+self.IPAddress + '\u001B[0m')
+			logging.debug('\u001B[1;37;41m  Removing Artifacts older than 14 days \u001B[0m')
+			self.__RemoveOldest()
 		else:
-			logging.debug("Still some space left for artifacts storage")
+			logging.debug('Used Disk < 80%, on '  + self.Username+'@'+self.IPAddress +', no cleaning required')
+
+
 			


@@ -246,7 +246,7 @@ class PhySim:
 		isFinished = False
 		# doing a deep copy!
 		tmpPodNames = podNames.copy()
-		while(count < 32 and isFinished == False):
+		while(count < 50 and isFinished == False):
 			time.sleep(60)
 			for podName in tmpPodNames:
 				mySSH.command2(f'oc logs --tail=1 {podName} 2>&1', 6, silent=True)
@@ -0,0 +1,301 @@
+Active_gNBs = ( "gNB-OAI");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe00;
+    gNB_name  =  "gNB-OAI";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  1;
+    plmn_list = ({
+                  mcc = 208;
+                  mnc = 99;
+                  mnc_length = 2;
+                  snssaiList = (
+                    {
+                      sst = 1;
+                      sd  = 0x1; // 0 false, else true
+                    },
+                    {
+                      sst = 1;
+                      sd  = 0x112233; // 0 false, else true
+                    }
+                  );
+
+                  });
+
+    nr_cellid = 12345678L;
+
+    ////////// Physical parameters:
+
+    ssb_SubcarrierOffset                                      = 0;
+    pdsch_AntennaPorts                                        = 1;
+    pusch_AntennaPorts                                        = 1;
+    sib1_tda                                                  = 15;
+    min_rxtxtime = 6;
+
+     pdcch_ConfigSIB1 = (
+      {
+        controlResourceSetZero = 2;
+        searchSpaceZero = 0;
+      }
+      );
+
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3600 MHz + 12 PRBs@30kHz SCS (same as initial BWP)
+      absoluteFrequencySSB                                             = 640288;
+      dl_frequencyBand                                                 = 78;
+      # this is 3600 MHz
+      dl_absoluteFrequencyPointA                                       = 640000;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        dl_subcarrierSpacing                                           = 1;
+        dl_carrierBandwidth                                            = 24;
+     #initialDownlinkBWP
+      #genericParameters
+        # this is RBstart=27,L=48 (275*(L-1))+RBstart
+        initialDLBWPlocationAndBandwidth                               = 6325;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        initialDLBWPsubcarrierSpacing                                   = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                              = 2;
+        initialDLBWPsearchSpaceZero                                     = 0;
+
+  #uplinkConfigCommon
+     #frequencyInfoUL
+      ul_frequencyBand                                              = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                             = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      ul_subcarrierSpacing                                          = 1;
+      ul_carrierBandwidth                                           = 24;
+      pMax                                                          = 20;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                            = 6325;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+        initialULBWPsubcarrierSpacing                               = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 98;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 13;
+          preambleReceivedTargetPower                               = -96;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 6;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 1;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 4;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 4;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 14;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #
+        msg1_SubcarrierSpacing                                      = 1,
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+
+        msg3_DeltaPreamble                                          = 1;
+        p0_NominalWithGrant                                         =-90;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 40;
+        p0_nominal                                                  = -90;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 1;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7;
+      nrofDownlinkSymbols                                           = 6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4;
+
+      ssPBCH_BlockPower                                             = -25;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+
+    ////////// AMF parameters:
+    amf_ip_address      = ( { ipv4       = "192.168.70.132";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+
+    NETWORK_INTERFACES :
+    {
+        GNB_INTERFACE_NAME_FOR_NG_AMF            = "demo-oai";
+        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "192.168.70.129/24";
+        GNB_INTERFACE_NAME_FOR_NGU               = "demo-oai";
+        GNB_IPV4_ADDRESS_FOR_NGU                 = "192.168.70.129/24";
+        GNB_PORT_FOR_S1U                         = 2152; # Spec 2152
+    };
+
+  }
+);
+
+MACRLCs = (
+{
+  num_cc                      = 1;
+  tr_s_preference             = "local_L1";
+  tr_n_preference             = "local_RRC";
+  pusch_TargetSNRx10          = 150;
+  pucch_TargetSNRx10          = 200;
+  ulsch_max_frame_inactivity  = 1;
+}
+);
+
+L1s = (
+{
+  num_cc = 1;
+  tr_n_preference       = "local_mac";
+  pusch_proc_threads    = 8;
+  prach_dtx_threshold   = 120;
+  pucch0_dtx_threshold  = 150;
+  ofdm_offset_divisor   = 8; #set this to UINT_MAX for offset 0
+}
+);
+
+RUs = (
+{
+  local_rf       = "yes"
+  nb_tx          = 1
+  nb_rx          = 1
+  att_tx         = 0
+  att_rx         = 0;
+  bands          = [78];
+  max_pdschReferenceSignalPower = -27;
+  max_rxgain                    = 114;
+  sf_extension                  = 0;
+  eNB_instances  = [0];
+  #beamforming 1x4 matrix:
+  bf_weights = [0x00007fff, 0x0000, 0x0000, 0x0000];
+  clock_src = "internal";
+}
+);
+
+THREAD_STRUCT = (
+{
+  #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+  parallel_config    = "PARALLEL_SINGLE_THREAD";
+  #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+  worker_config      = "WORKER_ENABLE";
+}
+);
+
+rfsimulator :
+{
+  serveraddr = "server";
+  serverport = "4043";
+  options = (); #("saviq"); or/and "chanmod"
+  modelname = "AWGN";
+  IQfile = "/tmp/rfsimulator.iqs";
+};
+
+security = {
+  # preferred ciphering algorithms
+  # the first one of the list that an UE supports in chosen
+  # valid values: nea0, nea1, nea2, nea3
+  ciphering_algorithms = ( "nea0" );
+
+  # preferred integrity algorithms
+  # the first one of the list that an UE supports in chosen
+  # valid values: nia0, nia1, nia2, nia3
+  integrity_algorithms = ( "nia2", "nia0" );
+
+  # setting 'drb_ciphering' to "no" disables ciphering for DRBs, no matter
+  # what 'ciphering_algorithms' configures; same thing for 'drb_integrity'
+  drb_ciphering = "yes";
+  drb_integrity = "no";
+};
+
+log_config :
+{
+  global_log_level                      ="info";
+  global_log_verbosity                  ="medium";
+  hw_log_level                          ="info";
+  hw_log_verbosity                      ="medium";
+  phy_log_level                         ="info";
+  phy_log_verbosity                     ="medium";
+  mac_log_level                         ="info";
+  mac_log_verbosity                     ="high";
+  rlc_log_level                         ="info";
+  rlc_log_verbosity                     ="medium";
+  pdcp_log_level                        ="info";
+  pdcp_log_verbosity                    ="medium";
+  rrc_log_level                         ="info";
+  rrc_log_verbosity                     ="medium";
+  ngap_log_level                        ="debug";
+  ngap_log_verbosity                    ="medium";
+};
+
@@ -45,6 +45,7 @@ ENB_PROCESS_REALTIME_ISSUE = -13
 ENB_PROCESS_NOLOGFILE_TO_ANALYZE = -14
 ENB_PROCESS_SLAVE_RRU_NOT_SYNCED = -15
 ENB_REAL_TIME_PROCESSING_ISSUE = -16
+ENB_RETX_ISSUE = -17
 HSS_PROCESS_FAILED = -2
 HSS_PROCESS_OK = +2
 MME_PROCESS_FAILED = -3
@@ -50,10 +50,6 @@ memleak:openair1/PHY/CODING/TESTBENCH/ltetest.c
 invalidPrintfArgType_sint:openair1/PHY/CODING/TESTBENCH/pdcch_test.c
 //
 //-----------------------------------------------------------------------------
-// oaisim deprecated, remove?
-doubleFree:openair3/TEST/oaisim_mme_list_benchmark.c
-//
-//-----------------------------------------------------------------------------
 // is itti analyzer deprecated
 nullPointer:common/utils/itti_analyzer/itti_analyzer.c
 nullPointerRedundantCheck:common/utils/itti_analyzer/libbuffers/buffers.c
@@ -4,16 +4,14 @@
 Title : Processing Time (us)
 ColNames :
  - Metric
-  - Average
-  - Max
-  - Average vs Reference Deviation (Reference Value ; Acceptability Threshold)
+  - Average; Max; Count
+  - Average vs Reference Deviation (Reference Value; Acceptability Threshold)
 Ref : 
  feprx : 120.0
  feptx_prec : 8.0
  feptx_ofdm : 50.0
  feptx_total : 75.0
-  L1 Tx processing thread 0 : 300.0
-  L1 Tx processing thread 1 : 300.0
+  L1 Tx processing : 300.0
  DLSCH encoding : 230.0
  L1 Rx processing : 175.0
  PUSCH inner-receiver : 100.0
@@ -25,8 +23,7 @@ Threshold :
  feptx_prec : 1.25
  feptx_ofdm : 1.25
  feptx_total : 1.25
-  L1 Tx processing thread 0 : 1.25
-  L1 Tx processing thread 1 : 1.25
+  L1 Tx processing : 1.25
  DLSCH encoding : 1.25
  L1 Rx processing : 1.25
  PUSCH inner-receiver : 1.25
@@ -4,16 +4,14 @@
 Title : Processing Time (us)
 ColNames :
  - Metric
-  - Average
-  - Max
-  - Average vs Reference Deviation (Reference Value ; Acceptability Threshold)
+  - Average; Max; Count
+  - Average vs Reference Deviation (Reference Value; Acceptability Threshold)
 Ref : 
  feprx : 60.0
  feptx_prec : 8.0
  feptx_ofdm : 50.0
  feptx_total : 75.0
-  L1 Tx processing thread 0 : 300.0
-  L1 Tx processing thread 1 : 300.0
+  L1 Tx processing : 300.0
  DLSCH encoding : 230.0
  L1 Rx processing : 175.0
  PUSCH inner-receiver : 100.0
@@ -25,8 +23,7 @@ Threshold :
  feptx_prec : 1.25
  feptx_ofdm : 1.25
  feptx_total : 1.25
-  L1 Tx processing thread 0 : 1.25
-  L1 Tx processing thread 1 : 1.25
+  L1 Tx processing : 1.25
  DLSCH encoding : 1.25
  L1 Rx processing : 1.25
  PUSCH inner-receiver : 1.25
@@ -478,21 +478,19 @@ class HTMLManagement():
 		self.htmlFile.write('      </tr>\n')
 		self.htmlFile.write('      <tr bgcolor = "#33CCFF" >\n')
 		self.htmlFile.write('        <th colspan="3">'+ DataLog['ColNames'][0] +'</th>\n')
-		self.htmlFile.write('        <th>' + DataLog['ColNames'][1] + '</th>\n')
-		self.htmlFile.write('        <th>' + DataLog['ColNames'][2] + '</th>\n')
-		self.htmlFile.write('        <th colspan=' + str(1+self.htmlUEConnected) + '>'+ DataLog['ColNames'][3] +'</th>\n')
+		self.htmlFile.write('        <th colspan="2">' + DataLog['ColNames'][1] + '</th>\n')
+		self.htmlFile.write('        <th colspan=' + str(1+self.htmlUEConnected) + '>'+ DataLog['ColNames'][2] +'</th>\n')
 		self.htmlFile.write('      </tr>\n')

 		for k in DataLog['Data']:
 			# TestRow 
 			self.htmlFile.write('      <tr>\n')
 			self.htmlFile.write('        <td colspan="3" bgcolor = "lightcyan" >' + k  + ' </td>\n')				
-			self.htmlFile.write('        <td bgcolor = "lightcyan" >' + DataLog['Data'][k][0]  + ' </td>\n')
-			self.htmlFile.write('        <td bgcolor = "lightcyan" >' + DataLog['Data'][k][1]  + ' </td>\n')
-			if float(DataLog['Data'][k][2])> DataLog['Threshold'][k]:
-				self.htmlFile.write('        <th bgcolor = "red" >' + DataLog['Data'][k][2]  + ' (Ref = ' + str(DataLog['Ref'][k]) + ' ; Thres = '   +str(DataLog['Threshold'][k])+') ' + '</th>\n')
+			self.htmlFile.write('        <td colspan="2" bgcolor = "lightcyan" >' + DataLog['Data'][k][0] + '; ' + DataLog['Data'][k][1] + '; ' + DataLog['Data'][k][2] + ' </td>\n')
+			if float(DataLog['Data'][k][3])> DataLog['Threshold'][k]:
+				self.htmlFile.write('        <th bgcolor = "red" >' + DataLog['Data'][k][3]  + ' (Ref = ' + str(DataLog['Ref'][k]) + ' ; Thres = '   +str(DataLog['Threshold'][k])+') ' + '</th>\n')
 			else:
-				self.htmlFile.write('        <th bgcolor = "green" ><font color="white">' + DataLog['Data'][k][2]  + ' (Ref = ' + str(DataLog['Ref'][k]) + ' ; Thres = '   +str(DataLog['Threshold'][k])+') ' + '</th>\n')					
+				self.htmlFile.write('        <th bgcolor = "green" ><font color="white">' + DataLog['Data'][k][3]  + ' (Ref = ' + str(DataLog['Ref'][k]) + ' ; Thres = '   +str(DataLog['Threshold'][k])+') ' + '</th>\n')
 			self.htmlFile.write('      </tr>\n')
 		self.htmlFile.close()

@@ -401,6 +401,12 @@ def GetParametersFromXML(action):
 		string_field=test.findtext('nb_healthy')
 		if (string_field is not None):
 			CONTAINERS.nb_healthy[0] = int(string_field)
+		string_field=test.findtext('d_retx_th')
+		if (string_field is not None):
+			CONTAINERS.ran_checkers['d_retx_th']= string_field
+		string_field=test.findtext('u_retx_th')
+		if (string_field is not None):
+			CONTAINERS.ran_checkers['u_retx_th']= string_field

 	elif action == 'PingFromContainer':
 		string_field = test.findtext('container_name')
@@ -39,6 +39,7 @@ import time
 from multiprocessing import Process, Lock, SimpleQueue
 import yaml

+
 #-----------------------------------------------------------
 # OAI Testing modules
 #-----------------------------------------------------------
@@ -758,7 +759,7 @@ class RANManagement():
 		mySSH.command('echo ' + self.eNBPassword + ' | sudo -S rm enb*.log core* enb_*record.raw enb_*.pcap gnb_*.pcap enb_*txt physim_*.log *stats.log *monitor.pickle *monitor*.png ping*.log.png log/*/*.log log/*/*.pcap', '\$', 15)
 		mySSH.close()

-	def AnalyzeLogFile_eNB(self, eNBlogFile, HTML):
+	def AnalyzeLogFile_eNB(self, eNBlogFile, HTML, checkers={}):
 		if (not os.path.isfile('./' + eNBlogFile)):
 			return -1
 		enb_log_file = open('./' + eNBlogFile, 'r')
@@ -815,10 +816,12 @@ class RANManagement():
 		removing_ue = 0
 		#count"X2AP-PDU"
 		x2ap_pdu = 0
-		#NSA specific log markers
-		nsa_markers ={'SgNBReleaseRequestAcknowledge': [],'FAILURE': [], 'scgFailureInformationNR-r15': [], 'SgNBReleaseRequest': []}
+		#gnb specific log markers
+		gnb_markers ={'SgNBReleaseRequestAcknowledge': [],'FAILURE': [], 'scgFailureInformationNR-r15': [], 'SgNBReleaseRequest': [], 'Detected UL Failure on PUSCH':[]}
 		nodeB_prefix_found = False
 		RealTimeProcessingIssue = False
+		DLRetxIssue = False
+		ULRetxIssue = False
 	
 		line_cnt=0 #log file line counter
 		for line in enb_log_file.readlines():
@@ -1008,11 +1011,11 @@ class RANManagement():
 			result = re.search('X2AP-PDU', str(line))
 			if result is not None:
 				x2ap_pdu += 1
-			#nsa markers logging
-			for k in nsa_markers:
+			#gnb markers logging
+			for k in gnb_markers:
 				result = re.search(k, line)
 				if result is not None:
-					nsa_markers[k].append(line_cnt)					
+					gnb_markers[k].append(line_cnt)

 		enb_log_file.close()

@@ -1096,46 +1099,94 @@ class RANManagement():
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg
-			#nsa markers
+			#gnb markers
 			statMsg = 'logfile line count = ' + str(line_cnt)			
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg
-			if len(nsa_markers['SgNBReleaseRequestAcknowledge'])!=0:
-				statMsg = 'SgNBReleaseRequestAcknowledge = ' + str(len(nsa_markers['SgNBReleaseRequestAcknowledge'])) + ' occurences , starting line ' + str(nsa_markers['SgNBReleaseRequestAcknowledge'][0])
+			if len(gnb_markers['SgNBReleaseRequestAcknowledge'])!=0:
+				statMsg = 'SgNBReleaseRequestAcknowledge = ' + str(len(gnb_markers['SgNBReleaseRequestAcknowledge'])) + ' occurences , starting line ' + str(gnb_markers['SgNBReleaseRequestAcknowledge'][0])
 			else:
-				statMsg = 'SgNBReleaseRequestAcknowledge = ' + str(len(nsa_markers['SgNBReleaseRequestAcknowledge'])) + ' occurences' 
+				statMsg = 'SgNBReleaseRequestAcknowledge = ' + str(len(gnb_markers['SgNBReleaseRequestAcknowledge'])) + ' occurences' 
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg
-			statMsg = 'FAILURE = ' + str(len(nsa_markers['FAILURE'])) + ' occurences'
+			statMsg = 'FAILURE = ' + str(len(gnb_markers['FAILURE'])) + ' occurences'
+			htmlMsg = statMsg+'\n'
+			logging.debug(statMsg)
+			htmleNBFailureMsg += htmlMsg
+			statMsg = 'Detected UL Failure on PUSCH = ' + str(len(gnb_markers['Detected UL Failure on PUSCH'])) + ' occurences'
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg

-			#ulsch and dlsch statistics
+			#ulsch and dlsch statistics and checkers
+			#print statistics into html
 			if len(dlsch_ulsch_stats)!=0: #check if dictionary is not empty
+				#for each dictionary key, generate the msg for html as information
 				statMsg=''
-				for key in dlsch_ulsch_stats: #for each dictionary key
+				for key in dlsch_ulsch_stats: 
 					statMsg += dlsch_ulsch_stats[key] + '\n' 
 					logging.debug(dlsch_ulsch_stats[key])
 				htmleNBFailureMsg += statMsg

+			#checker
+			if (len(dlsch_ulsch_stats)!=0) and (len(checkers)!=0):
+				if 'd_retx_th' in checkers:
+					checkers['d_retx_th'] = [float(x) for x in checkers['d_retx_th'].split(',')]
+					dlsch_checker_status = list(0 for i in checkers['d_retx_th'])#status 0 / -1
+					d_perc_retx = list(0 for i in checkers['d_retx_th'])#results in %
+
+				if 'u_retx_th' in checkers:
+					checkers['u_retx_th'] = [float(x) for x in checkers['u_retx_th'].split(',')]
+					ulsch_checker_status = list(0 for i in checkers['u_retx_th'])
+					u_perc_retx = list(0 for i in checkers['u_retx_th'])
+
+				#ul and dl retransmissions checkers
+				#NOTICE:  DL and UL regex are different 
+
+				if ('dlsch_rounds' in dlsch_ulsch_stats) and ('d_retx_th' in checkers):
+					tmp=re.match(r'^.*dlsch_rounds\s+(\d+)\/(\d+)\/(\d+)\/(\d+),\s+dlsch_errors\s+(\d+)',dlsch_ulsch_stats['dlsch_rounds'])
+					if tmp is not None :
+						#captures the different groups from the regex
+						retx_data=[float(x) for x in tmp.groups()]
+						for i in range(0,len(d_perc_retx)):
+							#case where numerator > denumerator with denum ==0 is disregarded, cannot hapen in principle, will lead to 0%
+							d_perc_retx[i] = 0 if (retx_data[i] == 0)  else 100*retx_data[i+1]/retx_data[i]
+							#treating % > 100 , % > requirement
+							if (d_perc_retx[i] > 100) or (d_perc_retx[i] > checkers['d_retx_th'][i]): dlsch_checker_status[i] = -1
+					if -1 in dlsch_checker_status:
+						DLRetxIssue = True
+
+				if ('ulsch_rounds' in dlsch_ulsch_stats)  and ('u_retx_th' in checkers):
+					tmp=re.match(r'^.*ulsch_rounds\s+(\d+)\/(\d+)\/(\d+)\/(\d+),\s+.*,\s+ulsch_errors\s+(\d+)',dlsch_ulsch_stats['ulsch_rounds'])
+					if tmp is not None :
+						retx_data=[float(x) for x in tmp.groups()]
+						for i in range(0,len(d_perc_retx)):
+							u_perc_retx[i] = 0 if (retx_data[i] == 0) else 100*retx_data[i+1]/retx_data[i]
+							if (u_perc_retx[i] > 100) or (u_perc_retx[i] > checkers['u_retx_th'][i]): ulsch_checker_status[i] = -1
+					if -1 in ulsch_checker_status:
+						ULRetxIssue = True
+
+
+
 			#real time statistics
 			datalog_rt_stats['Data']={}
 			if len(real_time_stats)!=0: #check if dictionary is not empty
 				for k in real_time_stats:
-					tmp=re.match(r'^(?P<metric>.*):\s+(?P<avg>\d+\.\d+) us;\s+\d+;\s+(?P<max>\d+\.\d+) us;',real_time_stats[k])
+					tmp=re.match(r'^(?P<metric>.*):\s+(?P<avg>\d+\.\d+) us;\s+(?P<count>\d+);\s+(?P<max>\d+\.\d+) us;',real_time_stats[k])
 					if tmp is not None:
 						metric=tmp.group('metric')
 						avg=float(tmp.group('avg'))
 						max=float(tmp.group('max'))
-						datalog_rt_stats['Data'][metric]=["{:.0f}".format(avg),"{:.0f}".format(max),"{:.2f}".format(avg/datalog_rt_stats['Ref'][metric])]
+						count=int(tmp.group('count'))
+						datalog_rt_stats['Data'][metric]=["{:.0f}".format(avg),"{:.0f}".format(max),"{:d}".format(count),"{:.2f}".format(avg/datalog_rt_stats['Ref'][metric])]
 				#once all metrics are collected, store the data as a class attribute to build a dedicated HTML table afterward
 				self.datalog_rt_stats=datalog_rt_stats
 				#check if there is a fail => will render the test as failed
 				for k in datalog_rt_stats['Data']:
-					if float(datalog_rt_stats['Data'][k][2])> datalog_rt_stats['Threshold'][k]: #condition for fail : avg/ref is greater than the fixed threshold
+					if float(datalog_rt_stats['Data'][k][3])> datalog_rt_stats['Threshold'][k]: #condition for fail : avg/ref is greater than the fixed threshold
+						logging.debug('\u001B[1;30;43m datalog_rt_stats metric ' + k + '=' + datalog_rt_stats['Data'][k][3] + ' > threshold ' + str(datalog_rt_stats['Threshold'][k]) + ' \u001B[0m')
 						RealTimeProcessingIssue = True
 			else:
 				statMsg = 'No real time stats found in the log file\n'
@@ -1158,18 +1209,34 @@ class RANManagement():
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg
-			if len(nsa_markers['SgNBReleaseRequest'])!=0:
-				statMsg = 'SgNBReleaseRequest = ' + str(len(nsa_markers['SgNBReleaseRequest'])) + ' occurences , starting line ' + str(nsa_markers['SgNBReleaseRequest'][0])
+			if len(gnb_markers['SgNBReleaseRequest'])!=0:
+				statMsg = 'SgNBReleaseRequest = ' + str(len(gnb_markers['SgNBReleaseRequest'])) + ' occurences , starting line ' + str(gnb_markers['SgNBReleaseRequest'][0])
 			else:
-				statMsg = 'SgNBReleaseRequest = ' + str(len(nsa_markers['SgNBReleaseRequest'])) + ' occurences'
+				statMsg = 'SgNBReleaseRequest = ' + str(len(gnb_markers['SgNBReleaseRequest'])) + ' occurences'
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg
-			statMsg = 'scgFailureInformationNR-r15 = ' + str(len(nsa_markers['scgFailureInformationNR-r15'])) + ' occurences'
+			statMsg = 'scgFailureInformationNR-r15 = ' + str(len(gnb_markers['scgFailureInformationNR-r15'])) + ' occurences'
 			htmlMsg = statMsg+'\n'
 			logging.debug(statMsg)
 			htmleNBFailureMsg += htmlMsg			

+		if DLRetxIssue:
+			retx_checker_status_str = ''
+			for status in dlsch_checker_status : retx_checker_status_str+=str(status)+ ' '
+			logging.debug('\u001B[1;37;41m ' + nodeB_prefix + 'NB ended with too many retransmissions / errors issue in DL ! \u001B[0m')
+			logging.debug('\u001B[1;37;41m Status : ' + retx_checker_status_str + ' \u001B[0m')
+			htmleNBFailureMsg += 'Fail due to retransmissions / errors issue in DL, status : ' + retx_checker_status_str + '\n'
+			global_status = CONST.ENB_RETX_ISSUE
+
+		if ULRetxIssue:
+			retx_checker_status_str = ''
+			for status in ulsch_checker_status : retx_checker_status_str+=str(status)+ ' '
+			logging.debug('\u001B[1;37;41m ' + nodeB_prefix + 'NB ended with too many retransmissions / errors issue in UL ! \u001B[0m')
+			logging.debug('\u001B[1;37;41m Status : ' + retx_checker_status_str + ' \u001B[0m')
+			htmleNBFailureMsg += 'Fail due to retransmissions / errors issue in UL, status : ' + retx_checker_status_str + '\n'
+			global_status = CONST.ENB_RETX_ISSUE
+
 		if RealTimeProcessingIssue:
 			logging.debug('\u001B[1;37;41m ' + nodeB_prefix + 'NB ended with real time processing issue! \u001B[0m')
 			htmleNBFailureMsg += 'Fail due to real time processing issue\n'
@@ -756,7 +756,7 @@ function report_test {
        EPC_CONFIGS=("noS1")
        TRANS_MODES=("tdd")
        FR_MODE=("SA")
-        BW_CASES=(106)
+        BW_CASES=(106 24)
        for CN_CONFIG in ${EPC_CONFIGS[@]}
        do
          for TMODE in ${TRANS_MODES[@]}
@@ -1401,8 +1401,11 @@ function start_rf_sim_nr_ue {
        elif [ $LOC_RA_SA_TEST -eq 1 ] #RA test => use --do-ra option
        then
            echo "echo \"./nr-uesoftmodem --rfsim --do-ra --log_config.global_log_options level,nocolor,time --rrc_config_path /home/ubuntu/tmp/cmake_targets/ran_build/build/\" > ./my-nr-softmodem-run.sh " >> $1
-        else #SA test => use --sa option
+        elif [ $LOC_RA_SA_TEST -eq 2 ] #SA test 106PRB => use --sa option
+        then
            echo "echo \"./nr-uesoftmodem -r 106 --numerology 1 --band 78 -C 3619200000 --rfsim --sa --log_config.global_log_options level,nocolor,time\" > ./my-nr-softmodem-run.sh " >> $1
+        else # -eq 3 SA test 24PRB 
+           echo "echo \"./nr-uesoftmodem -r 24 -s 24 --numerology 1 --band 78 -C 3604320000 --rfsim --sa --log_config.global_log_options level,nocolor,time\" > ./my-nr-softmodem-run.sh " >> $1
        fi
    fi
    echo "chmod 775 ./my-nr-softmodem-run.sh" >> $1
@@ -2270,7 +2273,7 @@ function run_test_on_vm {
        mkdir --parents $ARCHIVES_LOC

        echo "############################################################"
-        echo "SA TEST"
+        echo "SA TEST 106PRB"
        echo "############################################################"
        #SA test, attention : has a different config file from the rest of the test
        CN_CONFIG="noS1"
@@ -2305,7 +2308,7 @@ function run_test_on_vm {
            echo "${CN_CONFIG} : Starting the NR-UE"
            echo "############################################################"
            CURRENT_NR_UE_LOG_FILE=tdd_${PRB}prb_${CN_CONFIG}_ue_sa_test.log
-            #last argument = 2 is to enable --sa for SA test
+            #last argument = 2 is to enable --sa for SA test for 106PRB
            start_rf_sim_nr_ue $NR_UE_VM_CMDS $NR_UE_VM_IP_ADDR $GNB_VM_IP_ADDR $CURRENT_NR_UE_LOG_FILE $PRB $FREQUENCY $S1_NOS1_CFG 2
            if [ $NR_UE_SYNC -eq 0 ]
            then
@@ -2340,9 +2343,11 @@ function run_test_on_vm {
                echo "SA test NOT OK"
                echo "try_cnt = " $try_cnt
                try_cnt=$((try_cnt+1))
+                SA_106PRB_STATUS = -1
            else
                echo "SA test OK"
                try_cnt=$((try_cnt+10))
+                SA_106PRB_STATUS = 0
            fi
        done
        ########### end SA test
@@ -2350,6 +2355,92 @@ function run_test_on_vm {
        sleep 30


+        echo "############################################################"
+        echo "SA TEST 24PRB"
+        echo "############################################################"
+        #SA test, attention : has a different config file from the rest of the test
+        CN_CONFIG="noS1"
+        CONF_FILE=gnb.sa.band78.fr1.24PRB.usrpb210.conf
+        S1_NOS1_CFG=0
+        PRB=24
+        FREQUENCY=3600
+
+        if [ ! -d $ARCHIVES_LOC ]
+        then
+            mkdir --parents $ARCHIVES_LOC
+        fi
+
+        local try_cnt=0
+
+        ######### start of SA TEST loop
+        while [ $try_cnt -lt 5 ] #5 because it hardly succeed within CI
+        do
+
+            SYNC_STATUS=0
+            SA_STATUS=0
+            rm -f $ARCHIVES_LOC/tdd_${PRB}prb_${CN_CONFIG}*sa_test.log
+
+            echo "############################################################"
+            echo "${CN_CONFIG} : Starting the gNB"
+            echo "############################################################"
+            CURRENT_GNB_LOG_FILE=tdd_${PRB}prb_${CN_CONFIG}_gnb_sa_test.log
+            #last argument = 2 is to enable --sa for SA test 
+            start_rf_sim_gnb $GNB_VM_CMDS "$GNB_VM_IP_ADDR" $CURRENT_GNB_LOG_FILE $PRB $CONF_FILE $S1_NOS1_CFG 2
+
+            echo "############################################################"
+            echo "${CN_CONFIG} : Starting the NR-UE"
+            echo "############################################################"
+            CURRENT_NR_UE_LOG_FILE=tdd_${PRB}prb_${CN_CONFIG}_ue_sa_test.log
+            #last argument = 3 is to enable --sa for SA test for 24PRB
+            start_rf_sim_nr_ue $NR_UE_VM_CMDS $NR_UE_VM_IP_ADDR $GNB_VM_IP_ADDR $CURRENT_NR_UE_LOG_FILE $PRB $FREQUENCY $S1_NOS1_CFG 3
+            if [ $NR_UE_SYNC -eq 0 ]
+            then
+                echo "Problem w/ gNB and NR-UE not syncing"
+                terminate_enb_ue_basic_sim $NR_UE_VM_CMDS $NR_UE_VM_IP_ADDR 2
+                terminate_enb_ue_basic_sim $GNB_VM_CMDS $GNB_VM_IP_ADDR 1
+                scp -o StrictHostKeyChecking=no ubuntu@$GNB_VM_IP_ADDR:/home/ubuntu/tmp/cmake_targets/log/$CURRENT_GNB_LOG_FILE $ARCHIVES_LOC
+                scp -o StrictHostKeyChecking=no ubuntu@$NR_UE_VM_IP_ADDR:/home/ubuntu/tmp/cmake_targets/log/$CURRENT_NR_UE_LOG_FILE $ARCHIVES_LOC
+                SYNC_STATUS=-1
+                try_cnt=$((try_cnt+1))
+                continue
+            fi
+
+            echo "############################################################"
+            echo "${CN_CONFIG} : Terminate gNB/NR-UE simulators"
+            echo "############################################################"
+            sleep 20
+            terminate_enb_ue_basic_sim $NR_UE_VM_CMDS $NR_UE_VM_IP_ADDR 2
+            terminate_enb_ue_basic_sim $GNB_VM_CMDS $GNB_VM_IP_ADDR 1
+            scp -o StrictHostKeyChecking=no ubuntu@$GNB_VM_IP_ADDR:/home/ubuntu/tmp/cmake_targets/log/$CURRENT_GNB_LOG_FILE $ARCHIVES_LOC
+            scp -o StrictHostKeyChecking=no ubuntu@$NR_UE_VM_IP_ADDR:/home/ubuntu/tmp/cmake_targets/log/$CURRENT_NR_UE_LOG_FILE $ARCHIVES_LOC
+
+            #check SA markers in gNB and NR UE log files
+            echo "############################################################"
+            echo "${CN_CONFIG} : Checking SA on gNB / NR-UE"
+            echo "############################################################"
+
+            # Proper check to be done when SA test is working!
+            check_sa_result $ARCHIVES_LOC/$CURRENT_GNB_LOG_FILE $ARCHIVES_LOC/$CURRENT_NR_UE_LOG_FILE
+            if [ $SA_STATUS -ne 0 ]
+            then
+                echo "SA test NOT OK"
+                echo "try_cnt = " $try_cnt
+                try_cnt=$((try_cnt+1))
+                SA_24PRB_STATUS = -1
+            else
+                echo "SA test OK"
+                try_cnt=$((try_cnt+10))
+                SA_24PRB_STATUS = 0
+            fi
+        done
+        ########### end SA test
+
+        sleep 30
+
+
+
+
+

        echo "############################################################"
        echo "RA TEST FR2"
@@ -2661,7 +2752,8 @@ function run_test_on_vm {
        echo "Checking run status"
        echo "############################################################"

-        if [ $SA_STATUS -ne 0 ]; then NR_STATUS=-1; fi     
+        if [ $SA_106PRB_STATUS -ne 0 ]; then NR_STATUS=-1; fi 
+        if [ $SA_24PRB_STATUS -ne 0 ]; then NR_STATUS=-1; fi  
        if [ $RA_FR2_STATUS -ne 0 ]; then NR_STATUS=-1; fi        
        if [ $RA_FR1_STATUS -ne 0 ]; then NR_STATUS=-1; fi
        if [ $SYNC_STATUS -ne 0 ]; then NR_STATUS=-1; fi
@@ -20,8 +20,7 @@ gnb :
    feptx_prec:
    feptx_ofdm:
    feptx_total:
-    L1 Tx processing thread 0:
-    L1 Tx processing thread 1:
+    L1 Tx processing:
    DLSCH encoding:
    L1 Rx processing:
    PUSCH inner-receiver:
@@ -40,12 +39,11 @@ gnb :
      rt.feptx_ofdm:
      rt.feptx_total:
    page3:
-      rt.L1 Tx processing thread 0:
-      rt.L1 Tx processing thread 1:
+      rt.L1 Tx processing:
      rt.DLSCH encoding:
      rt.L1 Rx processing:
    page4:
      rt.PUSCH inner-receiver:
      rt.PUSCH decoding:
      rt.DL & UL scheduling timing stats:
-      rt.UL Indication:
+      rt.UL Indication:
@@ -116,6 +116,8 @@
                <class>UndeployGenObject</class>
                <desc>Undeploy all OAI 5G stack</desc>
                <yaml_path>yaml_files/5g_f1_rfsimulator</yaml_path>
+                <d_retx_th>5,0,0,0</d_retx_th>
+                <u_retx_th>5,0,0,0</u_retx_th>
        </testCase>

 </testCaseList>
@@ -111,6 +111,8 @@
                <class>UndeployGenObject</class>
                <desc>Undeploy all OAI 5G stack</desc>
                <yaml_path>yaml_files/5g_fdd_rfsimulator</yaml_path>
+                <d_retx_th>5,0,0,0</d_retx_th>
+                <u_retx_th>5,0,0,0</u_retx_th>
        </testCase>

 </testCaseList>
@@ -109,6 +109,8 @@
                <class>UndeployGenObject</class>
                <desc>Undeploy all OAI 5G stack</desc>
                <yaml_path>yaml_files/5g_rfsimulator</yaml_path>
+                <d_retx_th>5,0,0,0</d_retx_th>
+                <u_retx_th>5,0,0,0</u_retx_th>
        </testCase>

 </testCaseList>
@@ -96,8 +96,8 @@

 	<testCase id="072000">
 		<class>Iperf</class>
-		<desc>iperf (DL/140Mbps/UDP)(60 sec)(single-ue profile)</desc>
-		<iperf_args>-u -b 140M -t 60</iperf_args>
+		<desc>iperf (DL/200Mbps/UDP)(60 sec)(single-ue profile)</desc>
+		<iperf_args>-u -b 200M -t 60</iperf_args>
 		<direction>DL</direction>
 		<id>nrmodule2_quectel</id>
 		<iperf_packetloss_threshold>50</iperf_packetloss_threshold>
@@ -42,6 +42,8 @@
 000001
 071004
 000001
+ 071005
+ 000001
 011002
 081000
 	</TestCaseRequestedList>
@@ -148,7 +150,16 @@
 		<iperf_bitrate_threshold>90</iperf_bitrate_threshold>
 		<iperf_profile>single-ue</iperf_profile>
 	</testCase>
-
+	<testCase id="071005">
+		<class>Iperf</class>
+		<desc>iperf (DL/130Mbps/UDP)(30 sec)(single-ue profile)</desc>
+		<iperf_args>-u -b 130M -t 30</iperf_args>
+		<direction>DL</direction>
+		<id>nrmodule2_quectel</id>
+		<iperf_packetloss_threshold>50</iperf_packetloss_threshold>
+		<iperf_bitrate_threshold>50</iperf_bitrate_threshold>
+		<iperf_profile>single-ue</iperf_profile>
+	</testCase>


 	<testCase id="081000">
@@ -21,8 +21,10 @@

 # Author: laurent THOMAS, Lionel GAUTHIER

-cmake_minimum_required (VERSION 3.0)
+cmake_minimum_required (VERSION 2.8)
+project (OpenAirInterface LANGUAGES C CXX)

+include("macros.cmake")

 # System packages that are required
 # We use either the cmake buildin, in ubuntu are in: /usr/share/cmake*/Modules/
@@ -48,6 +50,7 @@ include_directories(${CRYPTO_INCLUDE_DIRS})
 #uhd 4.0 and iris installs by default in /usr/local
 include_directories("/usr/local/include/")
 #use native cmake method as this package is not in pkg-config
+add_list2_option(RF_BOARD "None" "RF head type" "None" "OAI_USRP" "OAI_BLADERF" "OAI_LMSSDR" "OAI_SIMU" "EXMIMO")
 if (${RF_BOARD} STREQUAL "OAI_USRP")
  find_package(Boost REQUIRED)
  include_directories(${LIBBOOST_INCLUDE_DIR})
@@ -184,106 +187,6 @@ else (CUDA_FOUND)
   message ("No CUDA tool installed")
 endif ()

-
-###########################################
-# macros to define options as there is numerous options in oai
-################################################
-macro(add_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  add_definitions("-D${name}=${value}")
-endmacro(add_option)
-
-macro(add_boolean_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  set_property(CACHE ${name} PROPERTY TYPE BOOL)
-  if (${value})
-    add_definitions("-D${name}")
-  endif (${value})
-endmacro(add_boolean_option)
-
-macro(add_integer_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  add_definitions("-D${name}=${value}")
-endmacro(add_integer_option)
-
-macro(add_list1_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
-  if(NOT "${value}" STREQUAL "False")
-    add_definitions("-D${name}=${value}")
-  endif()
-endmacro(add_list1_option)
-
-macro(add_list2_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
-  if(NOT "${value}" STREQUAL "False")
-    add_definitions("-D${value}=1")
-  endif()
-endmacro(add_list2_option)
-
-macro(add_list_string_option name val helpstr)
-  if(DEFINED ${name})
-    set(value ${${name}})
-  else(DEFINED ${name})
-    set(value ${val})
-  endif()
-  set(${name} ${value} CACHE STRING "${helpstr}")
-  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
-  if(NOT "${value}" STREQUAL "False")
-    add_definitions("-D${name}=\"${value}\"")
-  endif()
-endmacro(add_list_string_option)
-
-# this function should produce the same value as the macro MAKE_VERSION defined in the C code (file types.h)
-function(make_version VERSION_VALUE)
-  math(EXPR RESULT "0")
-  foreach (ARG ${ARGN})
-    math(EXPR RESULT "${RESULT} * 16 + ${ARG}")
-  endforeach()
-  set(${VERSION_VALUE} "${RESULT}" PARENT_SCOPE)
-endfunction()
-
-macro(compile_asn1 asn1Source asn1cCmd ResultFlag)
-   # Warning: if you modify ASN.1 source file to generate new C files, cmake should be re-run instead of make
-   execute_process(COMMAND ${asn1cCmd}  ${asn1Source} RESULT_VARIABLE ret)
-
-   if (NOT ${ret} STREQUAL 0)
-      message(FATAL_ERROR "${ret}: error")
-   endif (NOT ${ret} STREQUAL 0)
-
-   add_custom_target (
-     ${ResultFlag} ALL
-     ${asn1cCmd} ${asn1Source}
-     DEPENDS ${asn1Source}
-   )
-endmacro(compile_asn1)
-
 ####################################################
 # compilation flags
 #############################################
@@ -341,9 +244,10 @@ set(CMAKE_CXX_FLAGS
  "${CMAKE_CXX_FLAGS} ${C_FLAGS_PROCESSOR}  ${commonOpts} -std=c++11")


+add_boolean_option(SANITIZE_ADDRESS False "enable the address sanitizer (ASan)")
 if (SANITIZE_ADDRESS)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -static-libasan -fno-common")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -static-libasan -fno-common")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -fno-common")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -fno-common")
 endif ()

 add_definitions("-DASN_DISABLE_OER_SUPPORT")
@@ -785,23 +689,14 @@ add_library(F1AP ${F1AP_C_FILES} )
 add_list1_option(NB_ANTENNAS_RX "4" "Number of antennas in reception" "1" "2" "4")
 add_list1_option(NB_ANTENNAS_TX "4" "Number of antennas in transmission" "1" "2" "4")

-add_list2_option(RF_BOARD "EXMIMO" "RF head type" "None" "OAI_USRP" "OAI_BLADERF" "OAI_LMSSDR" "OAI_SIMU")
-
-add_list2_option(TRANSP_PRO "None" "Transport protocol type" "None" "ETHERNET")
 #NOKIA config enhancement
-set (CONFIG_ROOTDIR
-  ${OPENAIR_DIR}/common/config
-  )
-set (CONFIG_SOURCES
+set (CONFIG_ROOTDIR ${OPENAIR_DIR}/common/config)
+add_library(CONFIG_LIB
  ${CONFIG_ROOTDIR}/config_load_configmodule.c
  ${CONFIG_ROOTDIR}/config_userapi.c
  ${CONFIG_ROOTDIR}/config_cmdline.c
-  )
-set (CONFIG_LIBCONFIG_SOURCES
-  ${CONFIG_ROOTDIR}/libconfig/config_libconfig.c
-  )
-add_library(CONFIG_LIB ${CONFIG_SOURCES})
-add_library(params_libconfig MODULE ${CONFIG_LIBCONFIG_SOURCES} )
+)
+add_library(params_libconfig MODULE ${CONFIG_ROOTDIR}/libconfig/config_libconfig.c)
 target_link_libraries(params_libconfig config)
 # shared library loader
 set (SHLIB_LOADER_SOURCES
@@ -1260,15 +1155,6 @@ set(FSPT_MSG_LIB FSPT_MSG)
 message("fspt c dir is : ${FSPT_C_DIR}")
 include_directories (${FSPT_C_DIR})

-#  add_library(ASYNC_IF
-#    ${OPENAIR2_DIR}/UTIL/ASYNC_IF/socket_link.c
-#    ${OPENAIR2_DIR}/UTIL/ASYNC_IF/link_manager.c
-#    ${OPENAIR2_DIR}/UTIL/ASYNC_IF/message_queue.c
-#    ${OPENAIR2_DIR}/UTIL/ASYNC_IF/ringbuffer_queue.c
-#    )
-#  set(ASYNC_IF_LIB ASYNC_IF)
-#  include_directories(${OPENAIR2_DIR}/UTIL/ASYNC_IF)
-
 set(PROTOBUF_LIB "protobuf-c")

 #set(PROTOBUF_LIB "protobuf") #for Cpp
@@ -1279,55 +1165,19 @@ add_library(HASHTABLE
 )
 include_directories(${OPENAIR_DIR}/common/utils/hashtable)

-set(UTIL_SRC
-  #  ${OPENAIR2_DIR}/UTIL/CLI/cli.c
-  #  ${OPENAIR2_DIR}/UTIL/CLI/cli_cmd.c
-  #  ${OPENAIR2_DIR}/UTIL/CLI/cli_server.c
-  ${OPENAIR2_DIR}/UTIL/FIFO/pad_list.c
+add_library(UTIL
  ${OPENAIR2_DIR}/UTIL/LISTS/list.c
  ${OPENAIR2_DIR}/UTIL/LISTS/list2.c
  ${OPENAIR_DIR}/common/utils/LOG/log.c
  ${OPENAIR_DIR}/common/utils/LOG/vcd_signal_dumper.c
  ${OPENAIR2_DIR}/UTIL/MATH/oml.c
-  #  ${OPENAIR2_DIR}/UTIL/MEM/mem_block.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_create_dir.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_detect_file.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_generate_report.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_parse_filename.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_parse_XML.c
-  #  ${OPENAIR2_DIR}/UTIL/OCG/OCG_save_XML.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/common.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/grid.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/job.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/mobility_parser.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/omg.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/omg_hashtable.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/rwalk.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/rwp.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/static.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/steadystaterwp.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/trace.c
-  #  ${OPENAIR2_DIR}/UTIL/OMG/trace_hashtable.c
  ${OPENAIR2_DIR}/UTIL/OPT/probe.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg_tx.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg_kpi.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg_models.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg_form.c
-  #  ${OPENAIR2_DIR}/UTIL/OTG/otg_rx.c
-  )
-add_library(UTIL ${UTIL_SRC})
-add_dependencies(UTIL rrc_flag)
-
-#set(OMG_SUMO_SRC
-#  ${OPENAIR2_DIR}/UTIL/OMG/client_traci_OMG.c
-#  ${OPENAIR2_DIR}/UTIL/OMG/id_manager.c
-#  ${OPENAIR2_DIR}/UTIL/OMG/sumo.c
-#  ${OPENAIR2_DIR}/UTIL/OMG/socket_traci_OMG.c
-#  ${OPENAIR2_DIR}/UTIL/OMG/storage_traci_OMG.c
-#  )
-#add_library(OMG_SUMO ${OMG_SUMO_SRC})
+  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
+  ${OPENAIR_DIR}/common/utils/utils.c
+  ${OPENAIR_DIR}/common/utils/system.c
+  ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${OPENAIR_DIR}/common/utils/time_meas.c
+)

 set(SECU_OSA_SRC
  ${OPENAIR2_DIR}/UTIL/OSA/osa_key_deriver.c
@@ -1590,7 +1440,6 @@ set(PHY_SRC_COMMON
  ${OPENAIR1_DIR}/PHY/TOOLS/signal_energy.c
  ${OPENAIR1_DIR}/PHY/TOOLS/dB_routines.c
  ${OPENAIR1_DIR}/PHY/TOOLS/sqrt.c
-  ${OPENAIR1_DIR}/PHY/TOOLS/time_meas.c
  ${OPENAIR1_DIR}/PHY/TOOLS/lut.c
  )

@@ -1727,7 +1576,6 @@ set(PHY_SRC_UE
  ${OPENAIR1_DIR}/PHY/TOOLS/signal_energy.c
  ${OPENAIR1_DIR}/PHY/TOOLS/dB_routines.c
  ${OPENAIR1_DIR}/PHY/TOOLS/sqrt.c
-  ${OPENAIR1_DIR}/PHY/TOOLS/time_meas.c
  ${OPENAIR1_DIR}/PHY/TOOLS/lut.c
  ${PHY_POLARSRC}
  ${PHY_SMALLBLOCKSRC}
@@ -1781,7 +1629,6 @@ set(PHY_SRC_UE
  ${OPENAIR1_DIR}/PHY/TOOLS/signal_energy.c
  ${OPENAIR1_DIR}/PHY/TOOLS/dB_routines.c
  ${OPENAIR1_DIR}/PHY/TOOLS/sqrt.c
-  ${OPENAIR1_DIR}/PHY/TOOLS/time_meas.c
  ${OPENAIR1_DIR}/PHY/TOOLS/lut.c
  ${OPENAIR1_DIR}/PHY/INIT/nr_init_ue.c
  #  ${OPENAIR1_DIR}/SIMULATION/NR_UE_PHY/unit_tests/src/pucch_uci_test.c
@@ -2009,6 +1856,7 @@ set(NR_L2_SRC_UE
  ${NR_SDAP_SRC}
  ${NR_UE_RRC_DIR}/L2_interface_ue.c
  ${NR_UE_RRC_DIR}/main_ue.c
+  ${NR_RRC_DIR}/nr_rrc_config.c
  ${NR_UE_RRC_DIR}/rrc_UE.c
  ${NR_UE_RRC_DIR}/rrc_nsa.c
  )
@@ -2700,7 +2548,7 @@ add_library(minimal_lib
  ${OPENAIR_DIR}/common/utils/minimal_stub.c
  ${T_SOURCE}
  )
-target_link_libraries(minimal_lib pthread dl ${T_LIB} ${CONFIG_LIB})
+target_link_libraries(minimal_lib pthread dl ${T_LIB} CONFIG_LIB)

 add_executable(nfapi_test
  ${OPENAIR_DIR}/openair2/NR_PHY_INTERFACE/nfapi_5g_test.c
@@ -2729,7 +2577,6 @@ add_executable(lte-softmodem
  ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
  ${OPENAIR_TARGETS}/RT/USER/ru_control.c
  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
  ${OPENAIR2_DIR}/ENB_APP/NB_IoT_interface.c
  ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
@@ -2744,14 +2591,11 @@ add_executable(lte-softmodem
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/multicast_link.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/socket.c
  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${PHY_INTERFACE_DIR}/queue_t.c
  ${OPENAIR_DIR}/common/utils/lte/ue_power.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  )
 add_dependencies(lte-softmodem rrc_flag s1ap_flag x2_flag oai_iqplayer)
@@ -2764,14 +2608,13 @@ target_link_libraries (lte-softmodem
  -Wl,--end-group z dl)

 target_link_libraries (lte-softmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (lte-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
+target_link_libraries (lte-softmodem pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
 target_link_libraries (lte-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem ${T_LIB})


 add_executable(ocp-enb
  ${OPENAIR_DIR}/executables/main-ocp.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
  ${OPENAIR_DIR}/executables/main-fs6.c
  ${OPENAIR_DIR}/executables/transport_split.c
@@ -2787,14 +2630,11 @@ add_executable(ocp-enb
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/multicast_link.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/socket.c
  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/lte/ue_power.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${PHY_INTERFACE_DIR}/queue_t.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  )
 add_dependencies(ocp-enb rrc_flag s1ap_flag x2_flag oai_iqplayer coding params_libconfig rfsimulator)
@@ -2806,7 +2646,7 @@ target_link_libraries (ocp-enb
  PHY_COMMON PHY PHY_RU LFDS L2 L2_LTE NFAPI_COMMON_LIB NFAPI_LIB MISC_NFAPI_LTE_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB LFDS7 SIMU_COMMON
  ${RAL_LIB} ${NAS_UE_LIB} ITTI ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} ${FSPT_MSG_LIB}
  -Wl,--end-group z dl)
-target_link_libraries (ocp-enb ${LIBXML2_LIBRARIES} pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${LIB_LMS_LIBRARIES} ${T_LIB})
+target_link_libraries (ocp-enb ${LIBXML2_LIBRARIES} pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${LIB_LMS_LIBRARIES} ${T_LIB})

 add_executable(oairu
  ${OPENAIR_TARGETS}/RT/USER/lte-ru.c
@@ -2815,23 +2655,18 @@ add_executable(oairu
  ${OPENAIR_TARGETS}/ARCH/COMMON/record_player.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
  ${OPENAIR_DIR}/openair1/SCHED/phy_procedures_lte_common.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/executables/main_ru.c
  ${T_SOURCE}
-  ${OPENAIR_DIR}/common/utils/LOG/log.c
-  ${CONFIG_SOURCES}
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${SHLIB_LOADER_SOURCES}
 )
 target_link_libraries (oairu
  -Wl,--start-group
  SCHED_RU_LIB
-  PHY_COMMON PHY_RU
+  PHY_COMMON PHY_RU UTIL
  -Wl,--end-group z dl)

-target_link_libraries (oairu pthread m ${CONFIG_LIB} rt ${CMAKE_DL_LIBS} ${T_LIB})
+target_link_libraries (oairu pthread m CONFIG_LIB rt ${CMAKE_DL_LIBS} ${T_LIB})


 # lte-uesoftmodem is  UE implementation
@@ -2850,13 +2685,10 @@ add_executable(lte-uesoftmodem
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/multicast_link.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/socket.c
  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/lte/ue_power.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  )

@@ -2874,7 +2706,7 @@ target_link_libraries (lte-uesoftmodem
  -Wl,--end-group z dl)

 target_link_libraries (lte-uesoftmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (lte-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (lte-uesoftmodem pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (lte-uesoftmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-uesoftmodem ${T_LIB})

@@ -2887,7 +2719,6 @@ add_executable(nr-softmodem
  ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
  ${OPENAIR_DIR}/executables/nr-gnb.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/executables/nr-ru.c
  ${OPENAIR_DIR}/executables/nr-softmodem.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
@@ -2897,15 +2728,12 @@ add_executable(nr-softmodem
  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/lte/ue_power.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${PHY_INTERFACE_DIR}/queue_t.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  ${OPENAIR2_DIR}/ENB_APP/flexran_agent_ran_api_to_fix.c
  )
@@ -2919,52 +2747,12 @@ target_link_libraries (nr-softmodem
  -Wl,--end-group z dl)

 target_link_libraries (nr-softmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (nr-softmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (nr-softmodem pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (nr-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (nr-softmodem ${T_LIB})

 add_dependencies( nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc )

-add_executable(ocp-gnb
-  ${rrc_h}
-  ${nr_rrc_h}
-  ${s1ap_h}
-#  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_DIR}/executables/ocp-gnb.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${OPENAIR_DIR}/executables/softmodem-common.c
-  ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
-  ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
-  ${OPENAIR_TARGETS}/ARCH/COMMON/record_player.c
-  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
-  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
-  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
-  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
-  ${PHY_INTERFACE_DIR}/queue_t.c
-  ${XFORMS_SOURCE_NR}
-  ${T_SOURCE}
-  ${CONFIG_SOURCES}
-  ${SHLIB_LOADER_SOURCES}
-  ${XFORMSINTERFACE_SOURCE}
-  )
-
-target_link_libraries (ocp-gnb
-  -Wl,--start-group
-  UTIL HASHTABLE SCTP_CLIENT SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_NR_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
-  ITTI ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${RAL_LIB} ${NAS_UE_LIB} RRC_LIB NR_RRC_LIB
-  NGAP_LIB NGAP_GNB S1AP_LIB S1AP_ENB L2_LTE_NR L2_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
-  X2AP_LIB X2AP_ENB F1AP_LIB F1AP M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB SIMU_COMMON
-  -Wl,--end-group z dl)
-
-target_link_libraries (ocp-gnb ${LIBXML2_LIBRARIES} )
-target_link_libraries (ocp-gnb pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
-target_link_libraries (ocp-gnb ${LIB_LMS_LIBRARIES})
-target_link_libraries (ocp-gnb ${T_LIB})
-add_dependencies(ocp-gnb ldpc_orig ldpc_optim ldpc_optim8seg ldpc params_libconfig rfsimulator oai_usrpdevif rfsimulator nrscope)
-
-
 # nr-uesoftmodem is  UE implementation
 #######################################

@@ -2972,7 +2760,6 @@ add_executable(nr-uesoftmodem
  ${rrc_h}
  ${s1ap_h}
 #  ${OPENAIR_BIN_DIR}/messages_xml.h
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/executables/nr-uesoftmodem.c
  ${OPENAIR_DIR}/executables/nr-ue.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
@@ -2984,13 +2771,9 @@ add_executable(nr-uesoftmodem
  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${UTIL_SRC}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  )

@@ -3005,7 +2788,7 @@ target_link_libraries (nr-uesoftmodem
  -Wl,--end-group z dl)

 target_link_libraries (nr-uesoftmodem ${LIBXML2_LIBRARIES})
-target_link_libraries (nr-uesoftmodem pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (nr-uesoftmodem pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (nr-uesoftmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (nr-uesoftmodem ${T_LIB})

@@ -3013,7 +2796,6 @@ add_dependencies( nr-uesoftmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc )
 if (CUDA_FOUND)
   add_dependencies( nr-uesoftmodem ldpc_cuda)
   add_dependencies( nr-softmodem ldpc_cuda)
-   add_dependencies( ocp-gnb ldpc_cuda)
 endif (CUDA_FOUND)
 ###################################"
 # Addexecutables for tests
@@ -3027,30 +2809,25 @@ endif (CUDA_FOUND)
 add_executable(dlsim_tm4
  ${OPENAIR1_DIR}/SIMULATION/LTE_PHY/dlsim_tm4.c
  ${OPENAIR1_DIR}/PHY/TOOLS/lte_phy_scope_tm4.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${T_SOURCE}
  )
 target_link_libraries (dlsim_tm4
  -Wl,--start-group SIMU_COMMON SIMU UTIL SCHED_LIB SCHED_RU_LIB PHY LFDS ITTI -Wl,--end-group
-  pthread m rt ${CONFIG_LIB} ${ATLAS_LIBRARIES} ${T_LIB}
+  pthread m rt CONFIG_LIB ${ATLAS_LIBRARIES} ${T_LIB}
  )

 add_executable(rftest
  ${OPENAIR_DIR}/openair1/PHY/TOOLS/calibration_test.c
  ${OPENAIR_DIR}/openair1/PHY/TOOLS/calibration_scope.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
 )
-target_link_libraries(rftest minimal_lib PHY_NR_COMMON pthread dl m forms ${T_LIB} )
+target_link_libraries(rftest minimal_lib CONFIG_LIB PHY_NR_COMMON UTIL pthread dl m forms ${T_LIB} )

 add_executable(polartest
  ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/polartest.c
-  ${OPENAIR_DIR}/common/utils/backtrace.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3061,9 +2838,7 @@ target_link_libraries(polartest

 add_executable(smallblocktest
  ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/smallblocktest.c
-  ${OPENAIR_DIR}/common/utils/backtrace.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
 )
@@ -3093,11 +2868,7 @@ target_link_libraries(ldpctest

 add_executable(nr_dlschsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlschsim.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3108,11 +2879,7 @@ target_link_libraries(nr_dlschsim

 add_executable(nr_pbchsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/pbchsim.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3124,12 +2891,7 @@ target_link_libraries(nr_pbchsim
 #PUCCH ---> Prashanth
 add_executable(nr_pucchsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/pucchsim.c
-  ${OPENAIR_DIR}/common/utils/backtrace.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/system.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3140,17 +2902,13 @@ target_link_libraries(nr_pucchsim

 add_executable(nr_dlsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlsim.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
  ${NR_UE_RRC_DIR}/rrc_nsa.c
  ${NFAPI_USER_DIR}/nfapi.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${PHY_INTERFACE_DIR}/queue_t.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3162,17 +2920,13 @@ target_compile_definitions(nr_dlsim PUBLIC -DPHYSICAL_SIMULATOR)

 add_executable(nr_prachsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/prachsim.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${OPENAIR1_DIR}/SCHED_NR/phy_procedures_nr_common.c
  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
  ${NR_UE_RRC_DIR}/rrc_nsa.c
  ${NFAPI_USER_DIR}/nfapi.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${PHY_INTERFACE_DIR}/queue_t.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES})
 target_link_libraries(nr_prachsim
@@ -3181,12 +2935,8 @@ target_link_libraries(nr_prachsim

 add_executable(nr_ulschsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulschsim.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${PHY_INTERFACE_DIR}/queue_t.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3197,9 +2947,6 @@ target_link_libraries(nr_ulschsim

 add_executable(nr_ulsim
  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulsim.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
  ${OPENAIR_DIR}/executables/softmodem-common.c
  ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
@@ -3207,7 +2954,6 @@ add_executable(nr_ulsim
  ${NR_UE_RRC_DIR}/rrc_nsa.c
  ${NFAPI_USER_DIR}/nfapi.c
  ${PHY_INTERFACE_DIR}/queue_t.c
-  ${UTIL_SRC}
  ${T_SOURCE}
  ${SHLIB_LOADER_SOURCES}
  )
@@ -3221,58 +2967,21 @@ foreach(myExe dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim pr

  add_executable(${myExe}
    ${OPENAIR1_DIR}/SIMULATION/LTE_PHY/${myExe}.c
-    ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
-    ${OPENAIR_DIR}/common/utils/backtrace.c
-    ${OPENAIR_DIR}/common/utils/system.c
-    ${OPENAIR_DIR}/common/utils/utils.c
    ${OPENAIR_DIR}/common/utils/lte/ue_power.c
    ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
    ${OPENAIR1_DIR}/PHY/INIT/lte_param_init.c
    ${XFORMS_SOURCE}
    ${T_SOURCE}
-    ${CONFIG_SOURCES}
    ${SHLIB_LOADER_SOURCES}
    ${NFAPI_USER_DIR}/nfapi.c
    )
  target_link_libraries (${myExe}
    -Wl,--start-group SIMU_COMMON SIMU UTIL SCHED_LIB SCHED_RU_LIB SCHED_UE_LIB PHY_COMMON PHY_NR_COMMON PHY PHY_UE PHY_RU LFDS ITTI LFDS7 -Wl,--end-group
-    pthread m rt ${CONFIG_LIB} ${ATLAS_LIBRARIES}  ${XFORMS_LIBRARIES} ${T_LIB} dl
+    pthread m rt CONFIG_LIB ${ATLAS_LIBRARIES}  ${XFORMS_LIBRARIES} ${T_LIB} dl
    )

 endforeach(myExe)

-add_executable(test_epc_generate_scenario
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/generate_scenario.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/generate_scenario.h
-  ${OPENAIR2_DIR}/ENB_APP/enb_config.h
-  ${OPENAIR2_DIR}/COMMON/commonDef.h
-  ${OPENAIR2_DIR}/COMMON/messages_def.h
-  ${OPENAIR3_DIR}/S1AP/s1ap_eNB_defs.h
-  )
-target_link_libraries (test_epc_generate_scenario
-  -Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP SCHED_LIB PHY LFDS ITTI L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
-  )
-
-add_executable(test_epc_play_scenario
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_decode.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_display.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_fsm.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_parse.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap_compare_ie.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_s1ap_eNB_defs.h
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario_sctp.c
-  ${OPENAIR3_DIR}/TEST/EPC_TEST/play_scenario.h
-  ${OPENAIR2_DIR}/COMMON/commonDef.h
-  ${OPENAIR2_DIR}/COMMON/messages_def.h
-  )
-target_include_directories(test_epc_play_scenario PUBLIC /usr/local/share/asn1c)
-target_link_libraries (test_epc_play_scenario
-  -Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB X2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP SCHED_LIB PHY_NR_COMMON PHY_COMMON PHY PHY_UE LFDS ITTI -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
-  )
-
-
 #unitary tests for Core NEtwork pieces
 #################################
 foreach(myExe s1ap
@@ -3289,7 +2998,7 @@ foreach(myExe s1ap
    ${OPENAIR3_DIR}/TEST/test_${myExe}.c
    )
  target_link_libraries (test_${myExe}
-    -Wl,--start-group SECU_CN UTIL LFDS -Wl,--end-group m rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${CONFIG_LIB}
+    -Wl,--start-group SECU_CN UTIL LFDS -Wl,--end-group m rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} CONFIG_LIB
    )
 endforeach(myExe)

@@ -3408,16 +3117,12 @@ add_executable(nr-ittisim
  ${OPENAIR2_DIR}/RRC/NAS/rb_config.c
  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
-  ${OPENAIR_DIR}/common/utils/utils.c
-  ${OPENAIR_DIR}/common/utils/system.c
  ${OPENAIR_DIR}/common/utils/nr/nr_common.c
-  ${OPENAIR_DIR}/common/utils/threadPool/thread-pool.c
  ${OPENAIR_DIR}/common/utils/lte/ue_power.c
  ${OPENAIR_DIR}/common/utils/lte/prach_utils.c
  ${OPENAIR2_DIR}/ENB_APP/flexran_agent_ran_api_to_fix.c
  ${XFORMSINTERFACE_SOURCE}
  ${T_SOURCE}
-  ${CONFIG_SOURCES}
  ${SHLIB_LOADER_SOURCES}
  )

@@ -3431,7 +3136,7 @@ target_link_libraries (nr-ittisim
  -Wl,--end-group z dl)

 target_link_libraries (nr-ittisim ${LIBXML2_LIBRARIES})
-target_link_libraries (nr-ittisim pthread m ${CONFIG_LIB} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
+target_link_libraries (nr-ittisim pthread m CONFIG_LIB rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES} ${ATLAS_LIBRARIES})
 target_link_libraries (nr-ittisim ${LIB_LMS_LIBRARIES})
 target_link_libraries (nr-ittisim ${T_LIB})

@@ -1093,17 +1093,18 @@
                                 (Test8: 217 PRB 100 PDSCH-PRBs 110 PDSCH-Offset),
                                 (Test9: 106 PRBs 50 PDSCH-PRBs MCS Index 27),
                                 (Test10: 106 PRBs 50 PDSCH-PRBs MCS Index 16),
-                                 (Test11: HARQ test 25% TP (4 rounds),
-                                 (Test12: HARQ test 33% TP (3 rounds),
-                                 (Test13: HARQ test 50% TP (2 rounds),
-                                 (Test14: 3 PTRS, 8 Interpolated Symbols),
-                                 (Test15: 6 PTRS, 5 Interpolated Symbols),
-                                 (Test16: 11 PTRS, 0 Interpolated Symbols),
-                                 (Test17: Mapping type A, 2 DMRS Symbols),
-                                 (Test18: Mapping type A, 3 DMRS Symbols),
-                                 (Test19: Mapping type B, 4 DMRS Symbols),
-                                 (Test20: 4x4 MIMO, 1 Layer),
-                                 (Test21: 4x4 MIMO, 2 Layers)</desc>
+                                 (Test11: 106 MCS-TABLE 256 QAM MCS Index 26),
+                                 (Test12: HARQ test 25% TP (4 rounds),
+                                 (Test13: HARQ test 33% TP (3 rounds),
+                                 (Test14: HARQ test 50% TP (2 rounds),
+                                 (Test15: 3 PTRS, 8 Interpolated Symbols),
+                                 (Test16: 6 PTRS, 5 Interpolated Symbols),
+                                 (Test17: 11 PTRS, 0 Interpolated Symbols),
+                                 (Test18: Mapping type A, 2 DMRS Symbols),
+                                 (Test19: Mapping type A, 3 DMRS Symbols),
+                                 (Test20: Mapping type B, 4 DMRS Symbols),
+                                 (Test21: 4x4 MIMO, 1 Layer),
+                                 (Test22: 4x4 MIMO, 2 Layers)</desc>
      <pre_compile_prog></pre_compile_prog>
      <compile_prog>$OPENAIR_DIR/cmake_targets/build_oai</compile_prog>
      <compile_prog_args> --phy_simulators  -c </compile_prog_args>
@@ -1118,8 +1119,9 @@
                  -n100 -R217 -b100 -s5
                  -n100 -R217 -a80 -s5
                  -n100 -R217 -a110 -s5 -b100
-                  -n100 -e27 -s30 
-                  -n100 -e16 -s10 
+                  -n100 -e27 -s30
+                  -n100 -e16 -s10
+                  -n100 -q1 -e27 -s30
                  -n100 -s1 -t25
                  -n100 -s1 -t33
                  -n100 -s1 -t50
@@ -1131,7 +1133,7 @@
                  -n100 -s2 -U 2 1 3
                  -n10 -s20 -U 3 0 0 2 -gR -x1 -y4 -z4
                  -n10 -s20 -U 3 0 0 2 -gR -x2 -y4 -z4</main_exec_args>
-      <tags>nr_dlsim.test1 nr_dlsim.test2 nr_dlsim.test3 nr_dlsim.test4 nr_dlsim.test5 nr_dlsim.test6 nr_dlsim.test7 nr_dlsim.test8 nr_dlsim.test9 nr_dlsim.test10 nr_dlsim.test11 nr_dlsim.test12 nr_dlsim.test13 nr_dlsim.test14 nr_dlsim.test15 nr_dlsim.test16 nr_dlsim.test17 nr_dlsim.test18 nr_dlsim.test19 nr_dlsim.test20 nr_dlsim.test21</tags>
+      <tags>nr_dlsim.test1 nr_dlsim.test2 nr_dlsim.test3 nr_dlsim.test4 nr_dlsim.test5 nr_dlsim.test6 nr_dlsim.test7 nr_dlsim.test8 nr_dlsim.test9 nr_dlsim.test10 nr_dlsim.test11 nr_dlsim.test12 nr_dlsim.test13 nr_dlsim.test14 nr_dlsim.test15 nr_dlsim.test16 nr_dlsim.test17 nr_dlsim.test18 nr_dlsim.test19 nr_dlsim.test20 nr_dlsim.test21 nr_dlsim.test22</tags>
      <search_expr_true>PDSCH test OK</search_expr_true>
      <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>
      <nruns>3</nruns>
@@ -39,34 +39,24 @@ conf_nvram_path=$OPENAIR_DIR/openair3/NAS/TOOLS/ue_eurecom_test_sfr.conf

 XFORMS="True"
 SKIP_SHARED_LIB_FLAG="False"
-UE_EXPANSION="False"
 PRINT_STATS="False"
-VCD_TIMING="False"
 DEADLINE_SCHEDULER_FLAG_USER=""
-CPU_AFFINITY_FLAG_USER="False" #Only valid when low-latency flag is set to False
 REL="Rel15"
 HW="None"
 TP="Ethernet"
 EPC=0
 VERBOSE_CI=0
 VERBOSE_COMPILE=0
-CFLAGS_PROCESSOR_USER=""
 RUN_GROUP=0
 TEST_CASE_GROUP=""
+BUILD_DIR=ran_build
 BUILD_DOXYGEN=0
 BUILD_COVERITY_SCAN=0
-T_TRACER="True"
 DISABLE_HARDWARE_DEPENDENCY="False"
 CMAKE_BUILD_TYPE="RelWithDebInfo"
 CMAKE_CMD="$CMAKE"
-UE_AUTOTEST_TRACE="False"
-UE_DEBUG_TRACE="False"
-UE_TIMING_TRACE="False"
-USRP_REC_PLAY="False"
 BUILD_ECLIPSE=0
 NR="False"
-ITTI_SIM="False"
-SANITIZE_ADDRESS="False"
 OPTIONAL_LIBRARIES="telnetsrv enbscope uescope nrscope"
 RU=0
 trap handle_ctrl_c INT
@@ -82,6 +72,8 @@ Options
   Erase all files made by previous compilations, installations
 --clean-kernel
   Erase previously installed features in kernel: iptables, drivers, ...
+-d | --build-dir
+   Sets build directory (will be <oai-root>/cmake_targets/<build-dir>/build)
 -I | --install-external-packages
   Installs required packages such as LibXML, asn1.1 compiler, freediameter, ...
   This option will require root password
@@ -201,6 +193,9 @@ function main() {
            clean_kernel
            echo_info "Erased iptables config and removed modules from kernel"
            shift;;
+       -d | --build-dir)
+            BUILD_DIR=$2
+            shift;;
       -I | --install-external-packages)
            INSTALL_EXTERNAL=1
            echo_info "Will install external packages"
@@ -275,7 +270,7 @@ function main() {
            echo_info "Will compile NR UE"
            shift;;
       --mu)
-            UE_EXPANSION="True"
+            CMAKE_CMD="$CMAKE_CMD -DUE_EXPANSION=True -DPRE_SCD_THREAD=True"
            echo_info "Will compile with UE_EXPANSION"
            shift;;
       --UE-conf-nvram)
@@ -299,7 +294,9 @@ function main() {
                *)
                    echo_fatal "Unknown HW type $HW: exit..."
            esac
-			echo_info "Setting hardware to: $HW"
+            echo_info "Setting hardware to: $HW"
+            #CMAKE_CMD="$CMAKE_CMD -DRF_BOARD=\"${HW}\""
+            CMAKE_CMD="$CMAKE_CMD -DRF_BOARD=${HW}"
            shift 2;;
       -t | --transport)
 	    TP=$2
@@ -323,7 +320,7 @@ function main() {
            shift 2;;
       -V | --vcd)
            echo_info "Setting gtk-wave output"
-            VCD_TIMING=1
+            CMAKE_CMD="$CMAKE_CMD -DENABLE_VCD_FIFO=True"
            EXE_ARGUMENTS="$EXE_ARGUMENTS -V"
            shift;;
       -x | --xforms)
@@ -348,8 +345,8 @@ function main() {
            echo_info "Will compile with verbose instructions"
            shift;;
       --cflags_processor)
-            CFLAGS_PROCESSOR_USER=$2
-            echo_info "Setting CPU FLAGS from USER to: $CFLAGS_PROCESSOR_USER"
+            CMAKE_CMD="$CMAKE_CMD -DCFLAGS_PROCESSOR_USER=\"$2\""
+            echo_info "Setting CPU FLAGS from USER to: $2"
            shift 2;;
       --build-doxygen)
 	        BUILD_DOXYGEN=1
@@ -361,22 +358,26 @@ function main() {
            shift;;
       --disable-deadline)
            DEADLINE_SCHEDULER_FLAG_USER="False"
+            CMAKE_CMD="$CMAKE_CMD -DDEADLINE_SCHEDULER=False"
            echo_info "Disabling the usage of deadline scheduler"
            shift 1;;
       --enable-deadline)
            DEADLINE_SCHEDULER_FLAG_USER="True"
+            CMAKE_CMD="$CMAKE_CMD -DDEADLINE_SCHEDULER=True"
            echo_info "Enabling the usage of deadline scheduler"
            shift 1;;
       --enable-cpu-affinity)
            CPU_AFFINITY_FLAG_USER="True"
+            CMAKE_CMD="$CMAKE_CMD -DCPU_AFFINITY=True"
            echo_info "Enabling CPU Affinity (only valid when not using deadline scheduler)"
            shift 1;;
       --disable-cpu-affinity)
            CPU_AFFINITY_FLAG_USER="False"
+            CMAKE_CMD="$CMAKE_CMD -DCPU_AFFINITY=False"
            echo_info "Disabling CPU Affinity (only valid when not using deadline scheduler)"
            shift 1;;
       --disable-T-Tracer)
-            T_TRACER="False"
+            CMAKE_CMD="$CMAKE_CMD -DT_TRACER=False"
            echo_info "Disabling the T tracer"
            shift 1;;
       --disable-hardware-dependency)
@@ -384,15 +385,15 @@ function main() {
            DISABLE_HARDWARE_DEPENDENCY="True"
            shift 1;;
       --ue-autotest-trace)
-            UE_AUTOTEST_TRACE="True"
+            CMAKE_CMD="$CMAKE_CMD -DUE_AUTOTEST_TRACE=True"
            echo_info "Enabling autotest specific trace for UE"
            shift 1;;
       --ue-trace)
-            UE_DEBUG_TRACE="True"
+            CMAKE_CMD="$CMAKE_CMD -DUE_DEBUG_TRACE=False"
            echo_info "Enabling UE trace for debug"
            shift 1;;
       --ue-timing)
-            UE_TIMING_TRACE="True"
+            CMAKE_CMD="$CMAKE_CMD -DUE_TIMING_TRACE=True"
            echo_info "Enabling UE timing trace"
            shift 1;;
       --uhd-images-dir)
@@ -423,24 +424,20 @@ function main() {
              fi
            fi
            shift 2;;		
-        --usrp-recplay)
-            USRP_REC_PLAY="True"
-            echo_info "Enabling USRP record playback mode"
-            shift 1;;
        -k | --skip-shared-libraries)
            SKIP_SHARED_LIB_FLAG="True"
            echo_info "Skipping build of shared libraries, rfsimulator and transport protocol libraries"
            shift;;
-    --ninja)
-        CMAKE_CMD="$CMAKE_CMD -GNinja"
-	MAKE_CMD=ninja
-	shift;;
-    --sanitize-address | -fsanitize=address)
-        SANITIZE_ADDRESS=True
-        shift;;
-      --ittiSIM)
+        --ninja)
+            CMAKE_CMD="$CMAKE_CMD -GNinja"
+            MAKE_CMD=ninja
+            shift;;
+        --sanitize-address | -fsanitize=address)
+            CMAKE_CMD="$CMAKE_CMD -DSANITIZE_ADDRESS=True"
+            shift;;
+        --ittiSIM)
            ittiSIM=1
-            ITTI_SIM="True"
+            CMAKE_CMD="$CMAKE_CMD -DITTI_SIM=True"
            echo_info "Will compile itti simulator"
            shift;;
        -h | --help)
@@ -466,9 +463,6 @@ function main() {
      fi
  fi

-  CMAKE_CMD="$CMAKE_CMD .."
-  echo_info "CMAKE_CMD=$CMAKE_CMD"
-
  ########################################################
  # Check validity of HW and TP parameters for eNB / gNB #
  ########################################################
@@ -508,6 +502,7 @@ function main() {
  #Disable CPU Affinity for deadline scheduler
  if [ "$DEADLINE_SCHEDULER_FLAG_USER" = "True" ] ; then 
     CPU_AFFINITY_FLAG_USER="False"
+     CMAKE_CMD="$CMAKE_CMD -DCPU_AFFINITY=False"
  fi

  echo_info "Flags for Deadline scheduler: $DEADLINE_SCHEDULER_FLAG_USER"
@@ -585,46 +580,13 @@ function main() {
  echo_info "3. building the compilation directives ..."

  DIR=$OPENAIR_DIR/cmake_targets
-  if [ "$T_TRACER" =  "False" ] ; then
-      build_dir=ran_build_noLOG
-  else
-      build_dir=ran_build  
-  fi

-  [ "$CLEAN" = "1" ] && rm -rf $DIR/$build_dir/build
-  mkdir -p $DIR/$build_dir/build
+  [ "$CLEAN" = "1" ] && rm -rf $DIR/$BUILD_DIR/build
+  mkdir -p $DIR/$BUILD_DIR/build

-# configuration module libraries, one currently available, using libconfig 
-  config_libconfig_shlib=params_libconfig
-  
-  # first generate the CMakefile in the right directory
-  # softmodem compilation
-  
-  cmake_file=$DIR/$build_dir/CMakeLists.txt
-  echo "cmake_minimum_required(VERSION 2.8)"                             >  $cmake_file
-  echo "project (OpenAirInterface)"                                    >> $cmake_file
-  echo "set ( CMAKE_BUILD_TYPE $CMAKE_BUILD_TYPE )"                     >> $cmake_file
-  echo "set ( CFLAGS_PROCESSOR_USER \"$CFLAGS_PROCESSOR_USER\" )"       >> $cmake_file
-  echo "set ( UE_EXPANSION $UE_EXPANSION )"                             >> $cmake_file
-  #    echo "set ( PHY_TX_THREAD $UE_EXPANSION )"                            >> $cmake_file
-  echo "set ( PRE_SCD_THREAD $UE_EXPANSION )"                           >> $cmake_file
-  echo "set ( ENABLE_VCD_FIFO $VCD_TIMING )"                            >> $cmake_file
-  echo "set ( RF_BOARD \"${HW}\")"                                      >> $cmake_file
-  echo "set ( TRANSP_PRO \"${TP}\")"                                    >> $cmake_file
-  echo "set ( PACKAGE_NAME \"${exec}\")"                                >> $cmake_file
-  echo "set ( DEADLINE_SCHEDULER \"${DEADLINE_SCHEDULER_FLAG_USER}\" )" >> $cmake_file
-  echo "set ( CPU_AFFINITY \"${CPU_AFFINITY_FLAG_USER}\" )"             >> $cmake_file
-  echo "set ( T_TRACER $T_TRACER )"                                     >> $cmake_file
-  echo "set ( UE_AUTOTEST_TRACE $UE_AUTOTEST_TRACE )"                   >> $cmake_file
-  echo "set ( UE_DEBUG_TRACE $UE_DEBUG_TRACE )"                         >> $cmake_file
-  echo "set ( UE_TIMING_TRACE $UE_TIMING_TRACE )"                       >> $cmake_file
-  echo "set ( USRP_REC_PLAY $USRP_REC_PLAY )"                           >> $cmake_file
-  echo "set ( SKIP_SHARED_LIB_FLAG $SKIP_SHARED_LIB_FLAG )"             >> $cmake_file
-  echo "set ( ITTI_SIM $ITTI_SIM )"                                     >> $cmake_file
-  echo "set ( SANITIZE_ADDRESS $SANITIZE_ADDRESS )"                     >> $cmake_file
-  echo 'include(${CMAKE_CURRENT_SOURCE_DIR}/../CMakeLists.txt)'         >> $cmake_file
-  cd  $DIR/$build_dir/build
-  eval $CMAKE_CMD
+  cd  $DIR/$BUILD_DIR/build
+  echo_info "running $CMAKE_CMD"
+  eval $CMAKE_CMD ../..

  execlist=""
  if [ "$eNB" = "1" ] ; then
@@ -653,7 +615,7 @@ function main() {
  for f in $execlist ; do
      echo_info "Compiling $f..."
      compilations \
-          $build_dir $f \
+          $BUILD_DIR $f \
          $f $dbin/$f.$REL
  done
  
@@ -662,13 +624,16 @@ function main() {
  
  if [ "$SKIP_SHARED_LIB_FLAG" = "False" ]; then
      echo_info "Building shared libraries common to UE and gNB"
+
+      # configuration module libraries, one currently available, using libconfig
+      config_libconfig_shlib=params_libconfig
      
      compilations \
-          $build_dir $config_libconfig_shlib \
+          $BUILD_DIR $config_libconfig_shlib \
          lib$config_libconfig_shlib.so $dbin/lib$config_libconfig_shlib.so
      
      compilations \
-          $build_dir coding \
+          $BUILD_DIR coding \
          libcoding.so $dbin/libcoding.so
      
  fi
@@ -681,7 +646,7 @@ function main() {
    then
      echo_info "Building ue_ip module"
      compilations \
-        $build_dir ue_ip \
+        $BUILD_DIR ue_ip \
        CMakeFiles/ue_ip/ue_ip.ko $dbin/ue_ip.ko
    else
      echo_info "Bypassing ue_ip build"
@@ -698,7 +663,7 @@ function main() {
    mkdir -p $DIR/nas_sim_tools/build
    cd $DIR/nas_sim_tools/build

-    eval $CMAKE_CMD
+    eval $CMAKE_CMD ..
    compilations \
      nas_sim_tools usim \
      usim $dbin/usim
@@ -712,16 +677,16 @@ function main() {
    # generate USIM data
    if [ -f $dbin/conf2uedata ]; then
      install_nas_tools $conf_nvram_path $gen_nvram_path "$dlog/conf2uedata.txt"
-      echo_info "Copying UE specific part to $DIR/$build_dir/build"
-      cp -Rvf $dbin/.ue_emm.nvram0 $DIR/$build_dir/build
-      cp -Rvf $dbin/.ue.nvram0 $DIR/$build_dir/build
-      cp -Rvf $dbin/.usim.nvram0 $DIR/$build_dir/build
+      echo_info "Copying UE specific part to $DIR/$BUILD_DIR/build"
+      cp -Rvf $dbin/.ue_emm.nvram0 $DIR/$BUILD_DIR/build
+      cp -Rvf $dbin/.ue.nvram0 $DIR/$BUILD_DIR/build
+      cp -Rvf $dbin/.usim.nvram0 $DIR/$BUILD_DIR/build
    else
      echo_warning "not generated UE NAS files: binaries not found"
    fi
  fi

-  cd  $DIR/$build_dir/build
+  cd  $DIR/$BUILD_DIR/build
  
  ##################
  # PHY simulators #
@@ -739,9 +704,6 @@ function main() {
    compilations \
      ran_build coding \
      libcoding.so $dbin/libcoding.so
-#    compilations \
-#	   lte-simulators $config_libconfig_shlib \
-#	   lib$config_libconfig_shlib.so $dbin/lib$config_libconfig_shlib.so
  fi

  ###################
@@ -763,14 +725,14 @@ function main() {
  if [ "$HW" = "EXMIMO" ] ; then
    echo_info "Compiling Express MIMO 2 board drivers"
    compilations \
-      $build_dir openair_rf \
+      $BUILD_DIR openair_rf \
      CMakeFiles/openair_rf/openair_rf.ko $dbin/openair_rf.ko
    compilations \
-	  $build_dir updatefw \
+	  $BUILD_DIR updatefw \
 	  updatefw $dbin/updatefw
    echo_info "Compiling oarf tools. The logfile for compilation is here: $dlog/oarf.txt"
-    make -C $OPENAIR_DIR/cmake_targets/$build_dir/build oarf > $dlog/oarf.txt 2>&1
-    cp $OPENAIR_DIR/cmake_targets/$build_dir/build/*.oct $dbin
+    make -C $OPENAIR_DIR/cmake_targets/$BUILD_DIR/build oarf > $dlog/oarf.txt 2>&1
+    cp $OPENAIR_DIR/cmake_targets/$BUILD_DIR/build/*.oct $dbin
    if [ -s $dbin/oarf_config_exmimo.oct ] ; then
 	  echo_success "oarf tools compiled"
    else
@@ -785,7 +747,7 @@ function main() {
  if [ ! -z "$BUILD_OPTLIB" ] ; then 
     for oklib in $BUILD_OPTLIB ; do
         compilations \
-             $build_dir $oklib \
+             $BUILD_DIR $oklib \
             lib${oklib}.so $dbin/lib${oklib}.so
     done
  fi
@@ -859,7 +821,7 @@ function main() {
          # link liboai_device.so with the selected RF device library
          if [ "$HW" == "EXMIMO" ] ; then
              compilations \
-                  $build_dir oai_exmimodevif \
+                  $BUILD_DIR oai_exmimodevif \
                  liboai_exmimodevif.so $dbin/liboai_exmimodevif.so.$REL

              ln -sf liboai_exmimodevif.so liboai_device.so
@@ -867,7 +829,7 @@ function main() {
              echo_info "liboai_device.so is linked to EXMIMO device library"
          elif [ "$HW" == "OAI_USRP" ] ; then
              compilations \
-                  $build_dir oai_usrpdevif \
+                  $BUILD_DIR oai_usrpdevif \
                  liboai_usrpdevif.so $dbin/liboai_usrpdevif.so.$REL

              ln -sf liboai_usrpdevif.so liboai_device.so
@@ -876,7 +838,7 @@ function main() {
          elif [ "$HW" == "OAI_BLADERF" ] ; then
              if [ -f "/usr/include/libbladeRF.h" ] ; then
                  compilations \
-                      $build_dir oai_bladerfdevif \
+                      $BUILD_DIR oai_bladerfdevif \
                      liboai_bladerfdevif.so $dbin/liboai_bladerfdevif.so.$REL
              fi

@@ -886,7 +848,7 @@ function main() {
          elif [ "$HW" == "OAI_LMSSDR" ] ; then
 #              if [ -f "/usr/include/libbladeRF.h" ] ; then
                  compilations \
-                      $build_dir oai_lmssdrdevif \
+                      $BUILD_DIR oai_lmssdrdevif \
                      liboai_lmssdrdevif.so $dbin/liboai_lmssdrdevif.so.$REL
 #              fi

@@ -895,7 +857,7 @@ function main() {
              echo_info "liboai_device.so is linked to LMSSDR device library"	 
          elif [ "$HW" == "OAI_IRIS" ] ; then
              compilations \
-                  $build_dir oai_irisdevif \
+                  $BUILD_DIR oai_irisdevif \
                  liboai_irisdevif.so $dbin/liboai_irisdevif.so.$REL

              ln -s liboai_irisdevif.so liboai_device.so
@@ -915,7 +877,7 @@ function main() {
              echo_info "liboai_device.so is linked to ADRV9371_ZC706 device library for Kernel $SYRIQ_KMAJ.$SYRIQ_KMIN"
          elif [ "$HW" == "OAI_AW2SORI" ] ; then
 	      compilations \
-		  $build_dir aw2sori_transpro \
+		  $BUILD_DIR aw2sori_transpro \
                  libaw2sori_transpro.so $dbin/libaw2sori_transpro.so.$REL 

              ln -sf libaw2sori_transpro.so libthirdparty_transpro.so
@@ -930,12 +892,12 @@ function main() {
      if [ "$SKIP_SHARED_LIB_FLAG" = "False" ]; then
          echo_info "Compiling rfsimulator"
          compilations \
-              $build_dir rfsimulator \
+              $BUILD_DIR rfsimulator \
              librfsimulator.so $dbin/librfsimulator.so.$REL

          echo_info "Compiling tcp_bridge_oai"
          compilations \
-              $build_dir tcp_bridge_oai \
+              $BUILD_DIR tcp_bridge_oai \
              libtcp_bridge_oai.so $dbin/libtcp_bridge_oai.so.$REL
      fi

@@ -946,7 +908,7 @@ function main() {
          rm -f $dbin/liboai_transpro.so
 	  if [ "$TP" == "Ethernet" ]; then
              compilations \
-		  $build_dir oai_eth_transpro \
+		  $BUILD_DIR oai_eth_transpro \
 		  liboai_eth_transpro.so $dbin/liboai_eth_transpro.so.$REL
              ln -sf liboai_eth_transpro.so liboai_transpro.so
              ln -sf $dbin/liboai_eth_transpro.so.$REL $dbin/liboai_transpro.so
@@ -954,7 +916,7 @@ function main() {
 	  fi
 	  if [ "$TP" == "benetel4g" ]; then
              compilations \
-		  $build_dir benetel_4g \
+		  $BUILD_DIR benetel_4g \
 		  libbenetel_4g.so $dbin/libbenetel_4g.$REL
              ln -sf libbenetel_4g.so liboai_transpro.so
              ln -sf $dbin/libbenetel_4g.so.$REL $dbin/liboai_transpro.so
@@ -962,7 +924,7 @@ function main() {
 	  fi
 	  if [ "$TP" == "benetel5g" ]; then
              compilations \
-		  $build_dir benetel_5g \
+		  $BUILD_DIR benetel_5g \
 		  libbenetel_5g.so $dbin/libbenetel_5g.$REL
              ln -sf libbenetel_5g.so liboai_transpro.so
              ln -sf $dbin/libbenetel_5g.so.$REL $dbin/liboai_transpro.so
@@ -983,7 +945,7 @@ function main() {
    [ "$CLEAN" = "1" ] && rm -rf $OPENAIR_DIR/cmake_targets/doxygen/build
    mkdir -p $OPENAIR_DIR/cmake_targets/doxygen/build
    cd $OPENAIR_DIR/cmake_targets/doxygen/build
-    eval $CMAKE_CMD
+    eval $CMAKE_CMD ..
    make doc
    ) >& $doxygen_log
  fi
@@ -86,6 +86,7 @@ check_supported_distribution() {
        "ubuntu20.04") return 0 ;;
        "ubuntu20.10") return 0 ;;
        "ubuntu21.04") return 0 ;;
+        "ubuntu21.10") return 0 ;;
    esac
    return 1
 }
@@ -0,0 +1,98 @@
+###########################################
+# macros to define options as there is numerous options in oai
+################################################
+macro(add_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  add_definitions("-D${name}=${value}")
+endmacro(add_option)
+
+macro(add_boolean_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  set_property(CACHE ${name} PROPERTY TYPE BOOL)
+  if (${value})
+    add_definitions("-D${name}")
+  endif (${value})
+endmacro(add_boolean_option)
+
+macro(add_integer_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  add_definitions("-D${name}=${value}")
+endmacro(add_integer_option)
+
+macro(add_list1_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
+  if(NOT "${value}" STREQUAL "False")
+    add_definitions("-D${name}=${value}")
+  endif()
+endmacro(add_list1_option)
+
+macro(add_list2_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
+  if(NOT "${value}" STREQUAL "False")
+    add_definitions("-D${value}=1")
+  endif()
+endmacro(add_list2_option)
+
+macro(add_list_string_option name val helpstr)
+  if(DEFINED ${name})
+    set(value ${${name}})
+  else(DEFINED ${name})
+    set(value ${val})
+  endif()
+  set(${name} ${value} CACHE STRING "${helpstr}")
+  set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
+  if(NOT "${value}" STREQUAL "False")
+    add_definitions("-D${name}=\"${value}\"")
+  endif()
+endmacro(add_list_string_option)
+
+# this function should produce the same value as the macro MAKE_VERSION defined in the C code (file types.h)
+function(make_version VERSION_VALUE)
+  math(EXPR RESULT "0")
+  foreach (ARG ${ARGN})
+    math(EXPR RESULT "${RESULT} * 16 + ${ARG}")
+  endforeach()
+  set(${VERSION_VALUE} "${RESULT}" PARENT_SCOPE)
+endfunction()
+
+macro(compile_asn1 asn1Source asn1cCmd ResultFlag)
+   # Warning: if you modify ASN.1 source file to generate new C files, cmake should be re-run instead of make
+   execute_process(COMMAND ${asn1cCmd}  ${asn1Source} RESULT_VARIABLE ret)
+
+   if (NOT ${ret} STREQUAL 0)
+      message(FATAL_ERROR "${ret}: error")
+   endif (NOT ${ret} STREQUAL 0)
+
+   add_custom_target (
+     ${ResultFlag} ALL
+     ${asn1cCmd} ${asn1Source}
+     DEPENDS ${asn1Source}
+   )
+endmacro(compile_asn1)
@@ -411,6 +411,16 @@ int register_log_component(char *name,
  return computed_compidx;
 }

+static void unregister_all_log_components(void)
+{
+  log_component_t* lc = &g_log->log_component[0];
+  while (lc->name) {
+    free((char *)lc->name); // defined as const, but assigned through strdup()
+    free(lc->filelog_name);
+    lc++;
+  }
+}
+
 int isLogInitDone (void)
 {
  if (g_log == NULL)
@@ -502,6 +512,12 @@ int logInit (void)
  return 0;
 }

+void logTerm(void)
+{
+  unregister_all_log_components();
+  free_and_zero(g_log);
+}
+
 #include <sys/syscall.h>
 static inline int log_header(log_component_t *c,
 			     char *log_buffer,
@@ -302,6 +302,7 @@ extern "C" {
 #    include "log_if.h"
 /*----------------------------------------------------------------------------*/
 int  logInit (void);
+void logTerm (void);
 int  isLogInitDone (void);
 void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
 void vlogRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, va_list args );
@@ -472,130 +473,6 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int

 /* @}*/

-static __inline__ uint64_t rdtsc(void) {
-  uint32_t a, d;
-  __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
-  return (((uint64_t)d)<<32) | ((uint64_t)a);
-}
-
-#define DEBUG_REALTIME 1
-#if DEBUG_REALTIME
-
-extern double cpuf;
-
-static inline uint64_t checkTCPU(int timeout,
-		                         char *file,
-								 int line)
-{
-  static uint64_t __thread lastCPUTime=0;
-  static uint64_t __thread last=0;
-  uint64_t cur=rdtsc();
-  struct timespec CPUt;
-  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &CPUt);
-  uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
-  double microCycles=(double)(cpuf*1000);
-  int duration=(int)((cur-last)/microCycles);
-
-  if ( last!=0 && duration > timeout ) {
-    //struct timespec ts;
-    //clock_gettime(CLOCK_MONOTONIC, &ts);
-    printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
-           duration, timeout, (long long)CPUTime-lastCPUTime );
-  }
-
-  last=cur;
-  lastCPUTime=CPUTime;
-  return cur;
-}
-
-static inline unsigned long long checkT(int timeout,
-		                                char *file,
-										int line)
-{
-  static unsigned long long __thread last=0;
-  unsigned long long cur=rdtsc();
-  int microCycles=(int)(cpuf*1000);
-  int duration=(int)((cur-last)/microCycles);
-
-  if ( last!=0 && duration > timeout )
-    printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
-           duration, timeout);
-
-  last=cur;
-  return cur;
-}
-
-typedef struct m {
-  uint64_t iterations;
-  uint64_t sum;
-  uint64_t maxArray[11];
-} Meas;
-
-static inline void printMeas(char *txt,
-		                     Meas *M,
-							 int period)
-{
-  if (M->iterations%period == 0 ) {
-    char txt2[512];
-    sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%"
-            PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
-            txt,
-            M->sum/M->iterations,
-            M->iterations,
-            M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4], M->maxArray[5],
-            M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
-#if T_TRACER
-    LOG_W(PHY,"%s",txt2);
-#else
-    printf("%s",txt2);
-#endif
-  }
-}
-
-static inline int cmpint(const void *a,
-		                 const void *b)
-{
-  uint64_t *aa=(uint64_t *)a;
-  uint64_t *bb=(uint64_t *)b;
-  return (int)(*aa-*bb);
-}
-
-static inline void updateTimes(uint64_t start,
-		                       Meas *M,
-							   int period,
-							   char *txt)
-{
-  if (start!=0) {
-    uint64_t end=rdtsc();
-    long long diff=(end-start)/(cpuf*1000);
-    M->maxArray[0]=diff;
-    M->sum+=diff;
-    M->iterations++;
-    qsort(M->maxArray, 11, sizeof(uint64_t), cmpint);
-    printMeas(txt,M,period);
-  }
-}
-
-#define check(a) do { checkT(a,__FILE__,__LINE__); } while (0)
-#define checkcpu(a) do { checkTCPU(a,__FILE__,__LINE__); } while (0)
-#define initRefTimes(a) static __thread Meas a= {0}
-#define pickTime(a) uint64_t a=rdtsc()
-#define readTime(a) a
-#define initStaticTime(a) static __thread uint64_t a={0}
-#define pickStaticTime(a) do { a=rdtsc(); } while (0)
-
-#else
-#define check(a) do {} while (0)
-#define checkcpu(a) do {} while (0)
-#define initRefTimes(a) do {} while (0)
-#define initStaticTime(a) do {} while (0)
-#define pickTime(a) do {} while (0)
-#define readTime(a) 0
-#define pickStaticTime(a) do {} while (0)
-#define updateTimes(a,b,c,d) do {} while (0)
-#define printMeas(a,b,c) do {} while (0)
-#endif
-
 #ifdef __cplusplus
 }
 #endif
@@ -69,7 +69,6 @@ char *loader_format_shlibpath(char *modname, char *version)
 char *tmpstr;
 char *shlibpath   =NULL;
 char *shlibversion=NULL;
-char *cfgprefix;
 paramdef_t LoaderParams[] ={{"shlibpath", NULL, 0, strptr:&shlibpath, defstrval:NULL, TYPE_STRING, 0, NULL},
                            {"shlibversion", NULL, 0, strptr:&shlibversion, defstrval:"", TYPE_STRING, 0, NULL}};

@@ -81,16 +80,11 @@ int ret;
 /* looks for specific path for this module in the config file */
 /* specific value for a module path and version is located in a modname subsection of the loader section */
 /* shared lib name is formatted as lib<module name><module version>.so */
-  cfgprefix = malloc(sizeof(LOADER_CONFIG_PREFIX)+strlen(modname)+16);
-  if (cfgprefix == NULL) {
-      fprintf(stderr,"[LOADER] %s %d malloc error loading module %s, %s\n",__FILE__, __LINE__, modname, strerror(errno));
-      exit_fun("[LOADER] unrecoverable error");
-  } else {
-      sprintf(cfgprefix,LOADER_CONFIG_PREFIX ".%s",modname);
-      int ret = config_get( LoaderParams,sizeof(LoaderParams)/sizeof(paramdef_t),cfgprefix);
-      if (ret <0) {
-          fprintf(stderr,"[LOADER]  %s %d couldn't retrieve config from section %s\n",__FILE__, __LINE__,cfgprefix);
-      }
+  char cfgprefix[sizeof(LOADER_CONFIG_PREFIX)+strlen(modname)+16];
+  sprintf(cfgprefix,LOADER_CONFIG_PREFIX ".%s",modname);
+  ret = config_get( LoaderParams,sizeof(LoaderParams)/sizeof(paramdef_t),cfgprefix);
+  if (ret <0) {
+      fprintf(stderr,"[LOADER]  %s %d couldn't retrieve config from section %s\n",__FILE__, __LINE__,cfgprefix);
   }
 /* no specific path, use loader default shared lib path */
   if (shlibpath == NULL) {
@@ -142,6 +136,7 @@ int load_module_version_shlib(char *modname, char *version, loader_shlibfunc_t *
  }

  shlib_path = loader_format_shlibpath(modname, version);
+  printf("shlib_path %s\n", shlib_path);

  for (int i = 0; i < loader_data.numshlibs; i++) {
    if (strcmp(loader_data.shlibs[i].name, modname) == 0) {
@@ -198,15 +193,17 @@ int load_module_version_shlib(char *modname, char *version, loader_shlibfunc_t *
  }

  if (farray) {
-    if (!loader_data.shlibs[lib_idx].funcarray) {
-      loader_data.shlibs[lib_idx].funcarray = malloc(numf*sizeof(loader_shlibfunc_t));
-      if (!loader_data.shlibs[lib_idx].funcarray) {
+    loader_shlibdesc_t *shlib = &loader_data.shlibs[lib_idx];
+    if (!shlib->funcarray) {
+      shlib->funcarray = calloc(numf, sizeof(loader_shlibfunc_t));
+      if (!shlib->funcarray) {
        fprintf(stderr, "[LOADER] load_module_shlib(): unable to allocate memory\n");
        ret = -1;
        goto load_module_shlib_exit;
      }
+      shlib->len_funcarray = numf;
+      shlib->numfunc = 0;
    }
-    loader_data.shlibs[lib_idx].numfunc = 0;
    for (int i = 0; i < numf; i++) {
      farray[i].fptr = dlsym(lib_handle,farray[i].fname);
      if (!farray[i].fptr) {
@@ -215,9 +212,32 @@ int load_module_version_shlib(char *modname, char *version, loader_shlibfunc_t *
        ret = -1;
        goto load_module_shlib_exit;
      }
-      loader_data.shlibs[lib_idx].funcarray[i].fname=strdup(farray[i].fname);
-      loader_data.shlibs[lib_idx].funcarray[i].fptr = farray[i].fptr;
-      loader_data.shlibs[lib_idx].numfunc++;
+      /* check whether this function has been loaded before */
+      int j = 0;
+      for (; j < shlib->numfunc; ++j) {
+        if (shlib->funcarray[j].fptr == farray[i].fptr) {
+          int rc = strcmp(shlib->funcarray[i].fname, farray[i].fname);
+          AssertFatal(rc == 0,
+                      "reloading the same fptr with different fnames (%s, %s)\n",
+                      shlib->funcarray[i].fname, farray[i].fname);
+          break;
+        }
+      }
+      if (j == shlib->numfunc) {
+        if (shlib->numfunc == shlib->len_funcarray) {
+          loader_shlibfunc_t *n = realloc(shlib->funcarray, shlib->numfunc * 2 * sizeof(loader_shlibfunc_t));
+          if (!n) {
+            fprintf(stderr, "[LOADER] %s(): unable to allocate memory\n", __func__);
+            ret = -1;
+            goto load_module_shlib_exit;
+          }
+          shlib->funcarray = n;
+          shlib->len_funcarray = shlib->numfunc * 2;
+        }
+        shlib->funcarray[j].fname = strdup(farray[i].fname);
+        shlib->funcarray[j].fptr = farray[i].fptr;
+        shlib->numfunc++;
+      }
    } /* for int i... */
  } else {  /* farray ! NULL */
    sprintf(afname,"%s_getfarray",modname);
@@ -248,3 +268,18 @@ void * get_shlibmodule_fptr(char *modname, char *fname)
    } /* for i loop on modules */
    return NULL;
 }
+
+void loader_reset()
+{
+  for (int i = 0; i < loader_data.numshlibs && loader_data.shlibs[i].name != NULL; i++) {
+    loader_shlibdesc_t *shlib = &loader_data.shlibs[i];
+    free(shlib->name);
+    free(shlib->thisshlib_path);
+    for (int j = 0; j < shlib->numfunc; ++j)
+      free(shlib->funcarray[j].fname);
+    free(shlib->funcarray);
+    shlib->numfunc = 0;
+    shlib->len_funcarray = 0;
+  }
+  free(loader_data.shlibs);
+}
@@ -47,6 +47,7 @@ typedef struct {
   char               *thisshlib_path;
   uint32_t           numfunc;
   loader_shlibfunc_t *funcarray;
+   uint32_t           len_funcarray;
 }loader_shlibdesc_t;

 typedef struct {
@@ -90,5 +91,6 @@ extern void * get_shlibmodule_fptr(char *modname, char *fname);
 extern loader_data_t loader_data;
 #endif /* LOAD_MODULE_SHLIB_MAIN */
 #define load_module_shlib(M, F, N, I) load_module_version_shlib(M, NULL, F, N, I)
+void loader_reset();
 #endif

@@ -36,6 +36,27 @@

 const char *duplex_mode[]={"FDD","TDD"};

+int tables_5_3_2[5][11] = {
+  {25, 52, 79, 106, 133, 160, 216, 270, -1, -1, -1}, // 15 FR1
+  {11, 24, 38, 51, 65, 78, 106, 133, 162, 217, 273}, // 30 FR1
+  {-1, 11, 18, 24, 31, 38, 51, 65, 79, 107, 135},    // 60 FR1
+  {66, 132, 264, -1 , -1, -1, -1, -1, -1, -1, -1},   // 60 FR2
+  {32, 66, 132, 264, -1, -1, -1, -1, -1, -1, -1}     // 120FR2
+};
+
+int get_supported_band_index(int scs, int band, int n_rbs){
+
+  int scs_index = scs;
+  if (band>256)
+    scs_index++;
+  for (int i=0; i<11; i++) {
+    if(n_rbs == tables_5_3_2[scs][i])
+      return i;
+  }
+  return (-1); // not found
+}
+
+
 // Table 5.2-1 NR operating bands in FR1 & FR2 (3GPP TS 38.101)
 // Table 5.4.2.3-1 Applicable NR-ARFCN per operating band in FR1 & FR2 (3GPP TS 38.101)
 // Notes:
@@ -80,6 +80,7 @@ void SLIV2SL(int SLIV,int *S,int *L);
 int get_dmrs_port(int nl, uint16_t dmrs_ports);
 uint16_t SL_to_bitmap(int startSymbolIndex, int nrOfSymbols);
 int get_nb_periods_per_frame(uint8_t tdd_period);
+int get_supported_band_index(int scs, int band, int n_rbs);
 long rrc_get_max_nr_csrs(uint8_t max_rbs, long b_SRS);

 #define CEILIDIV(a,b) ((a+b-1)/b)
@@ -51,6 +51,7 @@

 static char                    *grouptypes[] = {"ltestats","cpustats"};
 static double                  cpufreq;
+extern notifiedFIFO_t          measur_fifo;
 #define TELNET_NUM_MEASURTYPES (sizeof(grouptypes)/sizeof(char *))

 #define HDR "---------------------------------"
@@ -43,9 +43,9 @@ int main(int argc, char *argv[]) {
    exit(1);
  }

-  uint64_t deb=rdtsc();
+  uint64_t deb=rdtsc_oai();
  usleep(100000);
-  cpuCyclesMicroSec=(rdtsc()-deb)/100000;
+  cpuCyclesMicroSec=(rdtsc_oai()-deb)/100000;
  printf("Cycles per µs: %lu\n",cpuCyclesMicroSec);
  printf("Key" SEP "delay to process" SEP "processing time" SEP "delay to be read answer\n");
  notifiedFIFO_elt_t doneRequest;
@@ -72,11 +72,11 @@ void *one_thread(void *arg) {
  do {
    notifiedFIFO_elt_t *elt=pullNotifiedFifoRemember(&tp->incomingFifo, myThread);

-    if (tp->measurePerf) elt->startProcessingTime=rdtsc();
+    if (tp->measurePerf) elt->startProcessingTime=rdtsc_oai();

    elt->processingFunc(NotifiedFifoData(elt));

-    if (tp->measurePerf) elt->endProcessingTime=rdtsc();
+    if (tp->measurePerf) elt->endProcessingTime=rdtsc_oai();

    if (elt->reponseFifo) {
      // Check if the job is still alive, else it has been aborted
@@ -97,7 +97,7 @@ void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name
  char *measr=getenv("threadPoolMeasurements");
  pool->measurePerf=performanceMeas;
  // force measurement if the output is defined
-  pool->measurePerf=measr!=NULL;
+  pool->measurePerf |= measr!=NULL;

  if (measr) {
    mkfifo(measr,0666);
@@ -27,11 +27,11 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <pthread.h>
+#include <unistd.h>
 #include <sys/syscall.h>
-#include <assertions.h>
-#include <LOG/log.h>
-#include <common/utils/system.h>
-//#include <stdatomic.h>
+#include "assertions.h"
+#include "common/utils/time_meas.h"
+#include "common/utils/system.h"

 #ifdef DEBUG
  #define THREADINIT   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
@@ -60,10 +60,10 @@ typedef struct notifiedFIFO_elt_s {
  struct notifiedFIFO_s *reponseFifo;
  void (*processingFunc)(void *);
  bool malloced;
-  uint64_t creationTime;
-  uint64_t startProcessingTime;
-  uint64_t endProcessingTime;
-  uint64_t returnTime;
+  oai_cputime_t creationTime;
+  oai_cputime_t startProcessingTime;
+  oai_cputime_t endProcessingTime;
+  oai_cputime_t returnTime;
  void *msgData;
 }  notifiedFIFO_elt_t;

@@ -97,12 +97,11 @@ static inline void *NotifiedFifoData(notifiedFIFO_elt_t *elt) {

 static inline void delNotifiedFIFO_elt(notifiedFIFO_elt_t *elt) {
  if (elt->malloced) {
-    elt->malloced=false;
+    elt->malloced = false;
    free(elt);
-  } else
-    printf("delNotifiedFIFO on something not allocated by newNotifiedFIFO\n");
-
-  //LOG_W(UTIL,"delNotifiedFIFO on something not allocated by newNotifiedFIFO\n");
+  }
+  /* it is allowed to call delNotifiedFIFO_elt when the memory is managed by
+   * the caller */
 }

 static inline void initNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf) {
@@ -141,8 +140,7 @@ static inline  notifiedFIFO_elt_t *pullNotifiedFIFO_nothreadSafe(notifiedFIFO_t

  notifiedFIFO_elt_t *ret=nf->outF;

-  if (nf->outF==nf->outF->next)
-    LOG_E(UTIL,"Circular list in thread pool: push several times the same buffer is forbidden\n");
+  AssertFatal(nf->outF != nf->outF->next,"Circular list in thread pool: push several times the same buffer is forbidden\n");

  nf->outF=nf->outF->next;

@@ -174,6 +172,20 @@ static inline  notifiedFIFO_elt_t *pollNotifiedFIFO(notifiedFIFO_t *nf) {
  return ret;
 }

+static inline time_stats_t exec_time_stats_NotifiedFIFO(const notifiedFIFO_elt_t* elt)
+{
+  time_stats_t ts = {0};
+  if (elt->startProcessingTime == 0 && elt->endProcessingTime == 0)
+    return ts; /* no measurements done */
+  ts.in = elt->startProcessingTime;
+  ts.diff = elt->endProcessingTime - ts.in;
+  ts.p_time = ts.diff;
+  ts.diff_square = ts.diff * ts.diff;
+  ts.max = ts.diff;
+  ts.trials = 1;
+  return ts;
+}
+
 // This function aborts all messages matching the key
 // If the queue is used in thread pools, it doesn't cancels already running processing
 // because the message has already been picked
@@ -224,18 +236,18 @@ typedef struct thread_pool {
 } tpool_t;

 static inline void pushTpool(tpool_t *t, notifiedFIFO_elt_t *msg) {
-  if (t->measurePerf) msg->creationTime=rdtsc();
+  if (t->measurePerf) msg->creationTime=rdtsc_oai();

  if ( t->activated)
    pushNotifiedFIFO(&t->incomingFifo, msg);
  else {
    if (t->measurePerf)
-      msg->startProcessingTime=rdtsc();
+      msg->startProcessingTime=rdtsc_oai();

    msg->processingFunc(NotifiedFifoData(msg));

    if (t->measurePerf)
-      msg->endProcessingTime=rdtsc();
+      msg->endProcessingTime=rdtsc_oai();

    if (msg->reponseFifo)
      pushNotifiedFIFO(msg->reponseFifo, msg);
@@ -246,7 +258,7 @@ static inline notifiedFIFO_elt_t *pullTpool(notifiedFIFO_t *responseFifo, tpool_
  notifiedFIFO_elt_t *msg= pullNotifiedFIFO(responseFifo);
  AssertFatal(t->traceFd, "Thread pool used while not initialized");
  if (t->measurePerf)
-    msg->returnTime=rdtsc();
+    msg->returnTime=rdtsc_oai();

  if (t->traceFd > 0)
    if(write(t->traceFd, msg, sizeof(*msg)));
@@ -261,7 +273,7 @@ static inline notifiedFIFO_elt_t *tryPullTpool(notifiedFIFO_t *responseFifo, tpo
    return NULL;

  if (t->measurePerf)
-    msg->returnTime=rdtsc();
+    msg->returnTime=rdtsc_oai();

  if (t->traceFd)
    if(write(t->traceFd, msg, sizeof(*msg)));
@@ -267,6 +267,15 @@ void init_meas(void) {
  AssertFatal(rt==0, "couldn't create cpu measurment thread: %s\n",strerror(errno));
 }

+void send_meas(time_stats_t *ts, int msgid) {
+    if (MEASURE_ENABLED(ts) ) {
+      ts->tstatptr->timestat_id=ts->meas_index;
+      ts->tstatptr->msgid = msgid ;
+      ts->tstatptr->ts = rdtsc_oai();
+      pushNotifiedFIFO(&measur_fifo, ts->tpoolmsg);
+    }
+  }
+
 void end_meas(void) {
    notifiedFIFO_elt_t *nfe = newNotifiedFIFO_elt(sizeof(time_stats_msg_t),0,NULL,NULL);
 	time_stats_msg_t *msg = (time_stats_msg_t *)NotifiedFifoData(nfe);
@@ -31,15 +31,14 @@
 #include <pthread.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
-#include "common/utils/threadPool/thread-pool.h"
 // global var to enable openair performance profiler
 extern int opp_enabled;
 extern double cpu_freq_GHz  __attribute__ ((aligned(32)));;
 // structure to store data to compute cpu measurment
 #if defined(__x86_64__) || defined(__i386__)
-  #define OAI_CPUTIME_TYPE long long
+  typedef long long oai_cputime_t;
 #elif defined(__arm__)
-  #define OAI_CPUTIME_TYPE uint32_t
+  typedef uint32_t oai_cputime_t;
 #else
  #error "building on unsupported CPU architecture"
 #endif
@@ -54,23 +53,23 @@ typedef void(*meas_printfunc_t)(const char* format, ...);
 typedef struct {
  int               msgid;                  /*!< \brief message id, as defined by TIMESTAT_MSGID_X macros */
  int               timestat_id;            /*!< \brief points to the time_stats_t entry in cpumeas table */
-  OAI_CPUTIME_TYPE  ts;                     /*!< \brief time stamp */
+  oai_cputime_t  ts;                        /*!< \brief time stamp */
  meas_printfunc_t  displayFunc;            /*!< \brief function to call when DISPLAY message is received*/
 } time_stats_msg_t;

-
-typedef struct {
-  OAI_CPUTIME_TYPE in;      /*!< \brief time at measure starting point */
-  OAI_CPUTIME_TYPE diff;     /*!< \brief average difference between time at starting point and time at endpoint*/
-  OAI_CPUTIME_TYPE p_time; /*!< \brief absolute process duration */
-  OAI_CPUTIME_TYPE diff_square; /*!< \brief process duration square */
-  OAI_CPUTIME_TYPE max;      /*!< \brief maximum difference between time at starting point and time at endpoint*/
+struct notifiedFIFO_elt_s;
+typedef struct time_stats {
+  oai_cputime_t in;          /*!< \brief time at measure starting point */
+  oai_cputime_t diff;        /*!< \brief average difference between time at starting point and time at endpoint*/
+  oai_cputime_t p_time;      /*!< \brief absolute process duration */
+  oai_cputime_t diff_square; /*!< \brief process duration square */
+  oai_cputime_t max;         /*!< \brief maximum difference between time at starting point and time at endpoint*/
  int trials;                /*!< \brief number of start point - end point iterations */
  int meas_flag;             /*!< \brief 1: stop_meas not called (consecutive calls of start_meas) */
  char *meas_name;           /*!< \brief name to use when printing the measure (not used for PHY simulators)*/
  int meas_index;            /*!< \brief index of this measure in the measure array (not used for PHY simulators)*/
  int meas_enabled;         /*!< \brief per measure enablement flag. send_meas tests this flag, unused today in start_meas and stop_meas*/
-  notifiedFIFO_elt_t *tpoolmsg; /*!< \brief message pushed to the cpu measurment queue to report a measure START or STOP */
+  struct notifiedFIFO_elt_s *tpoolmsg; /*!< \brief message pushed to the cpu measurment queue to report a measure START or STOP */
  time_stats_msg_t *tstatptr;   /*!< \brief pointer to the time_stats_msg_t data in the tpoolmsg, stored here for perf considerations*/
 } time_stats_t;
 #define MEASURE_ENABLED(X)       (X->meas_enabled)
@@ -179,7 +178,7 @@ 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)
+static inline void merge_meas(time_stats_t *dst_ts, const time_stats_t *src_ts)
 {
  if (!opp_enabled)
    return;
@@ -189,25 +188,17 @@ static inline void merge_meas(time_stats_t *dst_ts, time_stats_t *src_ts)
    dst_ts->max = src_ts->max;
 }

-extern notifiedFIFO_t measur_fifo;
 #define CPUMEASUR_SECTION "cpumeasur"

 #define CPUMEASUR_PARAMS_DESC { \
    {"max_cpumeasur",     "Max number of cpu measur entries",      0,       uptr:&max_cpumeasur,           defintval:100,         TYPE_UINT,   0},\
  }

-  void init_meas(void);
-  time_stats_t *register_meas(char *name);
-  #define START_MEAS(X) send_meas(X, TIMESTAT_MSGID_START)
-  #define STOP_MEAS(X)  send_meas(X, TIMESTAT_MSGID_STOP)
-  static inline void send_meas(time_stats_t *ts, int msgid) {
-    if (MEASURE_ENABLED(ts) ) {
-      ts->tstatptr->timestat_id=ts->meas_index;
-      ts->tstatptr->msgid = msgid ;
-      ts->tstatptr->ts = rdtsc_oai();
-      pushNotifiedFIFO(&measur_fifo, ts->tpoolmsg);
-    }
-  }
-  void end_meas(void);
+void init_meas(void);
+time_stats_t *register_meas(char *name);
+#define START_MEAS(X) send_meas(X, TIMESTAT_MSGID_START)
+#define STOP_MEAS(X)  send_meas(X, TIMESTAT_MSGID_STOP)
+void send_meas(time_stats_t *ts, int msgid);
+void end_meas(void);

 #endif
@@ -23,7 +23,6 @@ This tuto for 5G gNB NAS design

 # source files

-executables/ocp-gnb.c: a main loop to create a debuggable gNB, see document SW_archi.md
 openair2/RRC/NR/nr_ngap_gNB.c: skeleton for interface with NGAP
 openair3/NAS/COMMON/milenage.h: a simple milenage implementation, depend only on crypto library
 openair3/NAS/COMMON/NR_NAS_defs.h: messages defined for NAS implemented in C: C struct, C enums and automatic conversion to labels for debug messages
@@ -85,10 +85,6 @@ end
 This tuto for 5G gNB design, with Open Cells main
 {: .text-center}

-# Top file: executables/ocp-gnb.c
-
-the function main() initializes the data from configuration file
-
 # The main thread is in ru_thread()
 The infinite loop:
 ## rx_rf()
@@ -31,11 +31,14 @@ RUN rm -Rf /oai-ran
 WORKDIR /oai-ran
 COPY . .

+#only install address sanitizer for this container, the others don't need it
+RUN yum install -y libasan
+
 #run build_oai to build the target image
 RUN /bin/sh oaienv && \ 
    cd cmake_targets && \
    mkdir -p log && \
-    ./build_oai --phy_simulators --ninja --verbose-ci
+    ./build_oai --phy_simulators --ninja --verbose-ci --sanitize-address

 #start from scratch for target executable
 FROM registry.access.redhat.com/ubi8/ubi:latest as oai-physim
@@ -85,6 +88,7 @@ COPY --from=phy-sim-build \
    /lib64/liblapack.so.3 \
    /lib64/libexslt.so.0 \
    /lib64/libxslt.so.1 \
+    /usr/lib64/libasan.so.5 \
    /oai-ran/cmake_targets/ran_build/build/libdfts.so \
    /oai-ran/cmake_targets/ran_build/build/libSIMU.so \
    /oai-ran/cmake_targets/ran_build/build/libldpc.so \
@@ -55,6 +55,59 @@ int sum(uint8_t *b, int s) {
  return sum;
 }

+
+extern double cpuf;
+
+typedef struct m {
+  uint64_t iterations;
+  uint64_t sum;
+  uint64_t maxArray[11];
+} Meas;
+
+int cmpint(const void *a, const void *b)
+{
+  uint64_t *aa=(uint64_t *)a;
+  uint64_t *bb=(uint64_t *)b;
+  return (int)(*aa-*bb);
+}
+
+static inline void printMeas(char *txt,
+                                    Meas *M,
+                                                        int period)
+{
+  if (M->iterations%period == 0 ) {
+    char txt2[512];
+    sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%"
+            PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
+            txt,
+            M->sum/M->iterations,
+            M->iterations,
+            M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4], M->maxArray[5],
+            M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
+#if T_TRACER
+    LOG_W(PHY,"%s",txt2);
+#else
+    printf("%s",txt2);
+#endif
+  }
+}
+
+void updateTimes(uint64_t start, Meas *M, int period, char *txt)
+{
+  if (start!=0) {
+    uint64_t end=rdtsc_oai();
+    long long diff=(end-start)/(cpuf*1000);
+    M->maxArray[0]=diff;
+    M->sum+=diff;
+    M->iterations++;
+    qsort(M->maxArray, 11, sizeof(uint64_t), cmpint);
+    printMeas(txt,M,period);
+  }
+}
+
+#define initStaticTime(a) static __thread uint64_t a={0}
+#define pickStaticTime(a) do { a=rdtsc_oai(); } while (0)
+#define initRefTimes(a) static __thread Meas a= {0}
 static inline int cmpintRev(const void *a, const void *b) {
  uint64_t *aa=(uint64_t *)a;
  uint64_t *bb=(uint64_t *)b;
@@ -82,7 +135,7 @@ static inline void printMeas2(char *txt, Meas *M, int period, bool MaxMin) {

 static inline void updateTimesReset(uint64_t start, Meas *M, int period, bool MaxMin, char *txt) {
  if (start!=0) {
-    uint64_t end=rdtsc();
+    uint64_t end=rdtsc_oai();
    long long diff=(end-start)/(cpuf*1000);
    M->maxArray[0]=diff;
    M->sum+=diff;
@@ -107,7 +160,7 @@ static inline void updateTimesReset(uint64_t start, Meas *M, int period, bool Ma

 static inline void measTransportTime(uint64_t DuSend, uint64_t CuMicroSec, Meas *M, int period, bool MaxMin, char *txt) {
  if (DuSend!=0) {
-    uint64_t end=rdtsc();
+    uint64_t end=rdtsc_oai();
    long long diff=(end-DuSend)/(cpuf*1000)-CuMicroSec;
    M->maxArray[0]=diff;
    M->sum+=diff;
@@ -894,7 +947,7 @@ void phy_procedures_eNB_TX_fromsplit(uint8_t *bufferZone, int nbBlocks, PHY_VARS
  memcpy(eNB->pbch_pdu,hDL(bufferZone)->pbch_pdu, 4);

  // Remove all scheduled DL, we will populate from the CU sending
-  for (int UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+  for (int UE_id=0; UE_id<NUMBER_OF_DLSCH_MAX; UE_id++) {
    LTE_eNB_DLSCH_t *dlsch0 = eNB->dlsch[UE_id][0];

    if ( dlsch0 && dlsch0->rnti>0 ) {
@@ -1463,7 +1516,7 @@ void DL_cu_fs6(RU_t *ru, L1_rxtx_proc_t *proc, uint64_t  DuClock, uint64_t start
  }

  hDL(bufferZone)->DuClock=DuClock;
-  hDL(bufferZone)->CuSpentMicroSec=(rdtsc()-startCycle)/(cpuf*1000);
+  hDL(bufferZone)->CuSpentMicroSec=(rdtsc_oai()-startCycle)/(cpuf*1000);
  updateTimesReset(startCycle, &CUprocessing, 1000,  true,"CU entire processing from recv to send");
  sendSubFrame(&sockFS6, bufferZone, sizeof(fs6_dl_t), CTsentCUv0 );
  return;
@@ -1476,7 +1529,7 @@ void UL_cu_fs6(RU_t *ru, L1_rxtx_proc_t *proc, uint64_t *TS, uint64_t *DuClock,
  pickStaticTime(begingWait);
  int nb_blocks=receiveSubFrame(&sockFS6, bufferZone, sizeof(bufferZone), CTsentDUv0 );
  * DuClock=hUDP(bufferZone)->senderClock;
-  * startProcessing=rdtsc();
+  * startProcessing=rdtsc_oai();
  updateTimesReset(begingWait, &fullLoop, 1000, false, "CU wait DU");

  if (nb_blocks ==0) {
@@ -87,10 +87,10 @@ AGENT_RRC_xface *agent_rrc_xface[NUM_MAX_ENB]= {0};
 AGENT_MAC_xface *agent_mac_xface[NUM_MAX_ENB]= {0};
 void flexran_agent_slice_update(mid_t module_idP) {
 }
-int proto_agent_start(mod_id_t mod_id, const cudu_params_t *p) {
+int proto_agent_start(mid_t mod_id, const cudu_params_t *p) {
  return 0;
 }
-void proto_agent_stop(mod_id_t mod_id) {
+void proto_agent_stop(mid_t mod_id) {
 }

 static void *ru_thread( void *param );
@@ -300,8 +300,7 @@ void rx_func(void *param) {
 }
 static void dump_L1_meas_stats(PHY_VARS_gNB *gNB, RU_t *ru, char *output) {
  int stroff = 0;
-  stroff += print_meas_log(gNB->phy_proc_tx[0], "L1 Tx processing thread 0", NULL, NULL, output);
-  //stroff += print_meas_log(gNB->phy_proc_tx[1], "L1 Tx processing thread 1", NULL, NULL, output+stroff);
+  stroff += print_meas_log(&gNB->phy_proc_tx, "L1 Tx processing", NULL, NULL, output);
  stroff += print_meas_log(&gNB->dlsch_encoding_stats, "DLSCH encoding", NULL, NULL, output+stroff);
  stroff += print_meas_log(&gNB->phy_proc_rx, "L1 Rx processing", NULL, NULL, output+stroff);
  stroff += print_meas_log(&gNB->ul_indication_stats, "UL Indication", NULL, NULL, output+stroff);
@@ -337,8 +336,7 @@ void *nrL1_stats_thread(void *param) {
  fd=fopen("nrL1_stats.log","w");
  AssertFatal(fd!=NULL,"Cannot open nrL1_stats.log\n");

-  reset_meas(gNB->phy_proc_tx[0]);
-  //reset_meas(gNB->phy_proc_tx[1]);
+  reset_meas(&gNB->phy_proc_tx);
  reset_meas(&gNB->dlsch_encoding_stats);
  reset_meas(&gNB->phy_proc_rx);
  reset_meas(&gNB->ul_indication_stats);
@@ -425,7 +423,7 @@ void init_gNB_Tpool(int inst) {
    s_offset += 3;
  }
  if (getenv("noThreads")) strcpy(pool, "n");
-  initTpool(pool, gNB->threadPool, false);
+  initTpool(pool, gNB->threadPool, cpumeas(CPUMEAS_GETSTATE));
  // ULSCH decoder result FIFO
  gNB->respDecode = (notifiedFIFO_t*) malloc(sizeof(notifiedFIFO_t));
  initNotifiedFIFO(gNB->respDecode);
@@ -450,8 +448,6 @@ void init_gNB_Tpool(int inst) {
    processingData_L1tx_t *msgDataTx = (processingData_L1tx_t *)NotifiedFifoData(msgL1Tx);
    init_DLSCH_struct(gNB, msgDataTx);
    memset(msgDataTx->ssb, 0, 64*sizeof(NR_gNB_SSB_t));
-    reset_meas(&msgDataTx->phy_proc_tx);
-    gNB->phy_proc_tx[i] = &msgDataTx->phy_proc_tx;
    pushNotifiedFIFO(gNB->L1_tx_free,msgL1Tx); // to unblock the process in the beginning
  }

@@ -62,8 +62,6 @@ unsigned short config_frames[4] = {2,9,11,13};
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "UTIL/OPT/opt.h"

-//#include "PHY/TOOLS/time_meas.h"
-
 #include "intertask_interface.h"

 #include "PHY/INIT/phy_init.h"
@@ -167,10 +167,10 @@ void init_nr_ue_vars(PHY_VARS_NR_UE *ue,
  }

  // initialize all signal buffers
-  init_nr_ue_signal(ue, nb_connected_gNB, abstraction_flag);
+  init_nr_ue_signal(ue, nb_connected_gNB);

  // intialize transport
-  init_nr_ue_transport(ue, abstraction_flag);
+  init_nr_ue_transport(ue);

  // init N_TA offset
  init_N_TA_offset(ue);
@@ -766,9 +766,9 @@ void processSlotRX(void *arg) {
 #ifdef UE_SLOT_PARALLELISATION
    phy_procedures_slot_parallelization_nrUE_RX( UE, proc, 0, 0, 1, no_relay, NULL );
 #else
-    uint64_t a=rdtsc();
+    uint64_t a=rdtsc_oai();
    phy_procedures_nrUE_RX(UE, proc, gNB_id, get_nrUE_params()->nr_dlsch_parallel, &rxtxD->txFifo);
-    LOG_D(PHY, "In %s: slot %d, time %lu\n", __FUNCTION__, proc->nr_slot_rx, (rdtsc()-a)/3500);
+    LOG_D(PHY, "In %s: slot %d, time %llu\n", __FUNCTION__, proc->nr_slot_rx, (rdtsc_oai()-a)/3500);
 #endif

    if(IS_SOFTMODEM_NOS1 || get_softmodem_params()->sa){
@@ -61,7 +61,6 @@ unsigned short config_frames[4] = {2,9,11,13};

 #include "UTIL/OPT/opt.h"
 #include "enb_config.h"
-//#include "PHY/TOOLS/time_meas.h"

 #include "intertask_interface.h"

@@ -120,7 +120,6 @@ extern "C"
 #define TIMING_SOURCE       softmodem_params.timing_source
 #define SEND_DMRSSYNC       softmodem_params.send_dmrs_sync
 #define USIM_TEST           softmodem_params.usim_test
-#define USE_256QAM_TABLE    softmodem_params.use_256qam_table
 #define PRB_INTERPOLATION   softmodem_params.prb_interpolation
 #define NFAPI               softmodem_params.nfapi
 #define NSA                 softmodem_params.nsa
@@ -158,14 +157,13 @@ extern int usrp_tx_thread;
    {"basicsim",             CONFIG_HLP_RFSIM,        PARAMFLAG_BOOL, uptr:&basicsim,                     defintval:0,           TYPE_INT,    0},                     \
    {"nokrnmod",             CONFIG_HLP_NOKRNMOD,     PARAMFLAG_BOOL, uptr:&nokrnmod,                     defintval:0,           TYPE_INT,    0},                     \
    {"nbiot-disable",        CONFIG_HLP_DISABLNBIOT,  PARAMFLAG_BOOL, uptr:&nonbiot,                      defuintval:0,          TYPE_INT,    0},                     \
-    {"use-256qam-table",     CONFIG_HLP_256QAM,       PARAMFLAG_BOOL, iptr:&USE_256QAM_TABLE,             defintval:0,           TYPE_INT,    0},                     \
    {"nsa",                  CONFIG_HLP_NSA,          PARAMFLAG_BOOL, iptr:&NSA,                          defintval:0,           TYPE_INT,    0},                     \
    {"node-number",          NULL,                    0,              u16ptr:&NODE_NUMBER,                defuintval:0,          TYPE_UINT16, 0},                     \
    {"usrp-tx-thread-config", CONFIG_HLP_USRP_THREAD, 0,              iptr:&usrp_tx_thread,               defstrval:0,           TYPE_INT,    0},                     \
    {"do-prb-interpolation", CONFIG_HLP_PRBINTER,     PARAMFLAG_BOOL, iptr:&PRB_INTERPOLATION,            defintval:0,           TYPE_INT,    0},                     \
    {"nfapi",                CONFIG_HLP_NFAPI,        0,              u8ptr:&nfapi_mode,                  defintval:0,           TYPE_UINT8,  0},                     \
    {"non-stop",             CONFIG_HLP_NONSTOP,      PARAMFLAG_BOOL, iptr:&NON_STOP,                     defintval:0,           TYPE_INT,    0},                     \
-    {"emulate-l1",           CONFIG_L1_EMULATOR,      PARAMFLAG_BOOL, iptr:&EMULATE_L1,                   defintval:0,           TYPE_INT,    0},                     \
+    {"emulate-l1",           CONFIG_L1_EMULATOR,      PARAMFLAG_BOOL, iptr:&EMULATE_L1,                   defintval:0,           TYPE_INT,    0}                      \
  }

 #define CONFIG_HLP_NSA           "Enable NSA mode \n"
@@ -250,7 +248,6 @@ typedef struct {
  uint32_t       timing_source;
  int            hw_timing_advance;
  uint32_t       send_dmrs_sync;
-  int            use_256qam_table;
  int            prb_interpolation;
  uint8_t        nfapi;
  int            nsa;
@@ -156,7 +156,7 @@ int receiveSubFrame(UDPsock_t *sock, void *bufferZone,  int bufferSize, uint16_t
 int sendSubFrame(UDPsock_t *sock, void *bufferZone, ssize_t secondHeaderSize, uint16_t contentType) {
  commonUDP_t *UDPheader=(commonUDP_t *)bufferZone ;
  UDPheader->contentType=contentType;
-  UDPheader->senderClock=rdtsc();
+  UDPheader->senderClock=rdtsc_oai();
  int nbBlocks=UDPheader->nbBlocks;
  int blockId=0;

@@ -46,7 +46,9 @@
 #define FAPI_NR_DL_CONFIG_TYPE_RA_DLSCH 0x03
 #define FAPI_NR_DL_CONFIG_TYPE_SI_DLSCH 0x04
 #define FAPI_NR_DL_CONFIG_TYPE_P_DLSCH 0x05
-#define FAPI_NR_DL_CONFIG_TYPES 0x05
+#define FAPI_NR_DL_CONFIG_TYPE_CSI_RS 0x06
+#define FAPI_NR_DL_CONFIG_TYPE_CSI_IM 0x07
+#define FAPI_NR_DL_CONFIG_TYPES 0x07

 #define FAPI_NR_CCE_REG_MAPPING_TYPE_INTERLEAVED 0x01
 #define FAPI_NR_CCE_REG_MAPPING_TYPE_NON_INTERLEAVED 0x02
@@ -473,11 +473,53 @@ typedef struct {
  fapi_nr_dl_config_dlsch_pdu_rel15_t dlsch_config_rel15;
 } fapi_nr_dl_config_dlsch_pdu;

+
+typedef struct {
+  uint16_t bwp_size;//
+  uint16_t bwp_start;//
+  uint8_t  subcarrier_spacing;//
+  uint8_t  cyclic_prefix;//
+  uint16_t start_rb;
+  uint16_t nr_of_rbs;
+  uint8_t  csi_type;//Value: 0:TRS 1:CSI-RS NZP 2:CSI-RS ZP
+  uint8_t  row;//Row entry into the CSI Resource location table. [TS38.211, sec 7.4.1.5.3 and table 7.4.1.5.3-1] Value: 1-18
+  uint16_t freq_domain;//Value: Up to the 12 LSBs, actual size is determined by the Row parameter
+  uint8_t  symb_l0;//The time domain location l0 and firstOFDMSymbolInTimeDomain Value: 0->13
+  uint8_t  symb_l1;//
+  uint8_t  cdm_type;
+  uint8_t  freq_density;//The density field, p and comb offset (for dot5).0: dot5 (even RB), 1: dot5 (odd RB), 2: one, 3: three
+  uint16_t scramb_id;//ScramblingID of the CSI-RS [TS38.214, sec 5.2.2.3.1] Value: 0->1023
+} fapi_nr_dl_config_csirs_pdu_rel15_t;
+
+
+typedef struct {
+  uint16_t bwp_size;
+  uint16_t bwp_start;
+  uint8_t  subcarrier_spacing;
+  uint16_t start_rb;
+  uint16_t nr_of_rbs;
+  uint8_t k_csiim[4];
+  uint8_t l_csiim[4];
+} fapi_nr_dl_config_csiim_pdu_rel15_t;
+
+
+typedef struct {
+  fapi_nr_dl_config_csirs_pdu_rel15_t csirs_config_rel15;
+} fapi_nr_dl_config_csirs_pdu;
+
+
+typedef struct {
+  fapi_nr_dl_config_csiim_pdu_rel15_t csiim_config_rel15;
+} fapi_nr_dl_config_csiim_pdu;
+
+
 typedef struct {
  uint8_t pdu_type;
  union {
    fapi_nr_dl_config_dci_pdu dci_config_pdu;
    fapi_nr_dl_config_dlsch_pdu dlsch_config_pdu;
+    fapi_nr_dl_config_csirs_pdu csirs_config_pdu;
+    fapi_nr_dl_config_csiim_pdu csiim_config_pdu;
  };
 } fapi_nr_dl_config_request_pdu_t;

@@ -25,6 +25,7 @@
 #include <string.h>
 #include "assertions.h"
 #include "SIMULATION/TOOLS/sim.h"
+#include "common/utils/load_module_shlib.h"
 #include "PHY/CODING/nrLDPC_extern.h"
 //#include "openair1/SIMULATION/NR_PHY/nr_unitary_defs.h"
 #include "openair1/PHY/CODING/nrLDPC_decoder_LYC/nrLDPC_decoder_LYC.h"
@@ -118,15 +119,13 @@ int test_ldpc(short No_iteration,
  //short test_input[block_length];
  unsigned char *test_input[MAX_NUM_NR_DLSCH_SEGMENTS]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};;
  //short *c; //padded codeword
-  unsigned char *estimated_output[MAX_NUM_DLSCH_SEGMENTS];
-  unsigned char *estimated_output_bit[MAX_NUM_DLSCH_SEGMENTS];
-  unsigned char *test_input_bit;
+  unsigned char estimated_output[MAX_NUM_DLSCH_SEGMENTS][block_length];
+  memset(estimated_output, 0, sizeof(estimated_output));
  unsigned char *channel_input[MAX_NUM_DLSCH_SEGMENTS];
-  unsigned char *channel_output_uncoded[MAX_NUM_DLSCH_SEGMENTS];
  unsigned char *channel_input_optim[MAX_NUM_DLSCH_SEGMENTS];
-  double *channel_output;
-  double *modulated_input[MAX_NUM_DLSCH_SEGMENTS];
-  char *channel_output_fixed[MAX_NUM_DLSCH_SEGMENTS];
+  //double channel_output[68 * 384];
+  double modulated_input[MAX_NUM_DLSCH_SEGMENTS][68 * 384] = { 0 };
+  char channel_output_fixed[MAX_NUM_DLSCH_SEGMENTS][68  * 384] = { 0 };
  unsigned int i,j,trial=0;
  short BG=0,nrows=0;//,ncols;
  int no_punctured_columns,removed_bit;
@@ -155,24 +154,12 @@ int test_ldpc(short No_iteration,
  // generate input block
  for(j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
    test_input[j]=(unsigned char *)malloc16(sizeof(unsigned char) * block_length/8);
+    memset(test_input[j], 0, sizeof(unsigned char) * block_length / 8);
    channel_input[j] = (unsigned char *)malloc16(sizeof(unsigned char) * 68*384);
+    memset(channel_input[j], 0, sizeof(unsigned char) * 68 * 384);
    channel_input_optim[j] = (unsigned char *)malloc16(sizeof(unsigned char) * 68*384);
-    channel_output_uncoded[j] = (unsigned char *)malloc16(sizeof(unsigned char) * 68*384);
-    estimated_output[j] = (unsigned char*) malloc16(sizeof(unsigned char) * block_length);
-    estimated_output_bit[j] = (unsigned char*) malloc16(sizeof(unsigned char) * block_length);
-    modulated_input[j] = (double *)malloc16(sizeof(double) * 68*384);
-    channel_output_fixed[j]  =  (char *)malloc16(sizeof( char) * 68*384);
+    memset(channel_input_optim[j], 0, sizeof(unsigned char) * 68 * 384);
  }
-  //modulated_input = (double *)malloc(sizeof(double) * 68*384);
-  //channel_output  = (double *)malloc(sizeof(double) * 68*384);
-  //channel_output_fixed  = (char *)malloc16(sizeof(char) * 68*384);
-  //modulated_input = (double *)calloc(68*384, sizeof(double));
-  channel_output  =  (double *)calloc(68*384, sizeof(double));
-  //channel_output_fixed  =  (double *)calloc(68*384, sizeof(double));
-  //channel_output_fixed  =  (unsigned char*)calloc(68*384, sizeof(unsigned char*));
-  //estimated_output = (unsigned char*) malloc16(sizeof(unsigned char) * block_length);///8);
-  //estimated_output_bit = (unsigned char*) malloc16(sizeof(unsigned char) * block_length);
-  test_input_bit = (unsigned char*) malloc16(sizeof(unsigned char) * block_length);

  reset_meas(&time);
  reset_meas(time_optim);
@@ -319,7 +306,6 @@ int test_ldpc(short No_iteration,
        for (i = 0; i < block_length+(nrows-no_punctured_columns) * Zc - removed_bit; i++)
          if (channel_input[j][i]!=channel_input_optim[j][i]) {
            printf("differ in seg %u pos %u (%u,%u)\n", j, i, channel_input[j][i], channel_input_optim[j][i]);
-            free(channel_output);
            return (-1);
          }
      //else{
@@ -367,12 +353,9 @@ int test_ldpc(short No_iteration,
        //channel_output_fixed[i] = (char)quantize(1,channel_output_fixed[i],qbits);

        //Uncoded BER
-        if (channel_output_fixed[j][i]<0)
-            channel_output_uncoded[j][i]=1;  //QPSK demod
-        else
-            channel_output_uncoded[j][i]=0;
+        unsigned char channel_output_uncoded = channel_output_fixed[j][i]<0 ? 1 /* QPSK demod */ : 0;

-        if (channel_output_uncoded[j][i] != channel_input_optim[j][i-2*Zc])
+        if (channel_output_uncoded != channel_input_optim[j][i-2*Zc])
 	  *errors_bit_uncoded = (*errors_bit_uncoded) + 1;

 	}
@@ -423,12 +406,10 @@ int test_ldpc(short No_iteration,

      for (i=0; i<block_length; i++)
        {
-          estimated_output_bit[j][i] = (estimated_output[j][i/8]&(1<<(i&7)))>>(i&7);
-          test_input_bit[i] = (test_input[j][i/8]&(1<<(i&7)))>>(i&7); // Further correct for multiple segments
-          if (estimated_output_bit[j][i] != test_input_bit[i])
-          {
+          unsigned char estoutputbit = (estimated_output[j][i/8]&(1<<(i&7)))>>(i&7);
+          unsigned char inputbit = (test_input[j][i/8]&(1<<(i&7)))>>(i&7); // Further correct for multiple segments
+          if (estoutputbit != inputbit)
            *errors_bit = (*errors_bit) + 1;
-          }
        }

      //if (*errors == 1000)
@@ -460,17 +441,8 @@ int test_ldpc(short No_iteration,
  for(j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
    free(test_input[j]);
    free(channel_input[j]);
-    free(channel_output_uncoded[j]);
    free(channel_input_optim[j]);
-    free(modulated_input[j]);
-    free(channel_output_fixed[j]);
-    free(estimated_output[j]);
-    free(estimated_output_bit[j]);
  }
-  //free(modulated_input);
-  free(channel_output);
-  //free(channel_output_fixed);
-  //free(estimated_output);

  nrLDPC_free_mem(p_nrLDPC_procBuf);

@@ -728,5 +700,8 @@ int main(int argc, char *argv[])
  }
  fclose(fd);

+  loader_reset();
+  logTerm();
+
  return(0);
 }
@@ -20,7 +20,7 @@

 int main(int argc, char *argv[])
 {
-  //Default simulation values (Aim for iterations = 1000000.)
+  //Default simulation values (Aim for iterations = 1000000.) 
  int decoder_int16=0;
  int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, 2=UCI
  double SNRstart = -20.0, SNRstop = 0.0, SNRinc= 0.5; //dB
@@ -158,20 +158,25 @@ if (logFlag){
 #endif
 }

-  uint8_t testArrayLength = ceil(testLength / 32.0);
-  uint8_t coderArrayLength = ceil(coderLength / 32.0);
-  uint32_t testInput[testArrayLength]; //generate randomly
+  const uint8_t testArrayLength = ceil(testLength / 32.0);
+  const uint8_t coderArrayLength = ceil(coderLength / 32.0);
+  // in the polar code, often uint64_t arrays are used, but we work with
+  // uint32_t arrays below, so realArrayLength is the length that always
+  // satisfies uint64_t array length
+  const uint8_t realArrayLength = ((testArrayLength + 1) / 2) * 2;
+  printf("testArrayLength %d realArrayLength %d\n", testArrayLength, realArrayLength);
+  uint32_t testInput[realArrayLength]; //generate randomly
  uint32_t encoderOutput[coderArrayLength];
-  uint32_t estimatedOutput[testArrayLength]; //decoder output
-  memset(testInput,0,sizeof(uint32_t) * testArrayLength);
+  uint32_t estimatedOutput[realArrayLength]; //decoder output
+  memset(testInput,0,sizeof(uint32_t) * realArrayLength); // does not reset all
  memset(encoderOutput,0,sizeof(uint32_t) * coderArrayLength);
-  memset(estimatedOutput,0,sizeof(uint32_t) * testArrayLength);
+  memset(estimatedOutput,0,sizeof(uint32_t) * realArrayLength);
  uint8_t encoderOutputByte[coderLength];
  double modulatedInput[coderLength]; //channel input
  double channelOutput[coderLength];  //add noise
  int16_t channelOutput_int16[coderLength];

-  t_nrPolar_params *currentPtr = nr_polar_params(polarMessageType, testLength, aggregation_level, 1, NULL);
+  t_nrPolar_params *currentPtr = nr_polar_params(polarMessageType, testLength, aggregation_level, true);

 #ifdef DEBUG_DCI_POLAR_PARAMS
  uint32_t dci_pdu[4];
@@ -206,7 +211,8 @@ if (logFlag){
 		  modulated_input[i]=(-1)/sqrt(2);
 	  channel_output[i] = modulated_input[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
  }
-  decoderState = polar_decoder_dci(channel_output, dci_est, currentPtrDCI, NR_POLAR_DECODER_LISTSIZE, rnti);
+  decoderState = polar_decoder_dci(channel_output, dci_est, NR_POLAR_DECODER_LISTSIZE, rnti,
+                                   1, size, aggregation_level);
  printf("dci_est: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", dci_est[0], dci_est[1], dci_est[2], dci_est[3]);
  free(encoder_outputByte);
  free(channel_output);
@@ -239,13 +245,13 @@ if (logFlag){

 		  start_meas(&timeEncoder);
 		  if (decoder_int16==1) {
-			  polar_encoder_fast((uint64_t *)testInput, encoderOutput, 0, 0, currentPtr);
+			  polar_encoder_fast((uint64_t *)testInput, encoderOutput, 0, 0, polarMessageType, testLength, aggregation_level);
 			  //polar_encoder_fast((uint64_t*)testInput, (uint64_t*)encoderOutput,0,0,currentPtr);
 		  } else { //0 --> PBCH, 1 --> DCI, -1 --> UCI
 			  if (polarMessageType == 0)
-				  polar_encoder(testInput, encoderOutput, currentPtr);
+				  polar_encoder(testInput, encoderOutput, polarMessageType, testLength, aggregation_level);
 			  else if (polarMessageType == 1)
-				  polar_encoder_dci(testInput, encoderOutput, currentPtr, rnti);
+                            polar_encoder_dci(testInput, encoderOutput, rnti, polarMessageType, testLength, aggregation_level);
 		  }
 		  stop_meas(&timeEncoder);

@@ -276,19 +282,20 @@ if (logFlag){
      start_meas(&timeDecoder);

      if (decoder_int16==1) {
-    	  decoderState = polar_decoder_int16(channelOutput_int16, (uint64_t *)estimatedOutput, 0, currentPtr);
+    	  decoderState = polar_decoder_int16(channelOutput_int16, (uint64_t *)estimatedOutput, 0,
+                                             polarMessageType, testLength, aggregation_level);
      } else { //0 --> PBCH, 1 --> DCI, -1 --> UCI
    	  if (polarMessageType == 0) {
-    		  decoderState = polar_decoder(channelOutput,
-    				                       estimatedOutput,
-										   currentPtr,
-										   decoderListSize);
+            decoderState = polar_decoder(channelOutput,
+                                         estimatedOutput,
+                                         decoderListSize,
+                                         polarMessageType, testLength, aggregation_level);
    	  } else if (polarMessageType == 1) {
-    		  decoderState = polar_decoder_dci(channelOutput,
-    				  	  	  	  	  	  	   estimatedOutput,
-											   currentPtr,
-											   decoderListSize,
-											   rnti);
+            decoderState = polar_decoder_dci(channelOutput,
+                                             estimatedOutput,
+                                             decoderListSize,
+                                             rnti,
+                                             polarMessageType, testLength, aggregation_level);
    	  }
      }
      stop_meas(&timeDecoder);
@@ -334,9 +341,9 @@ if (logFlag){
      decoderState=0;
      nBitError=0;
      blockErrorState=0;
-	  memset(testInput,0,sizeof(uint32_t) * testArrayLength);
+	  memset(testInput,0,sizeof(uint32_t) * realArrayLength);
 	  memset(encoderOutput,0,sizeof(uint32_t) * coderArrayLength);
-	  memset(estimatedOutput,0,sizeof(uint32_t) * testArrayLength);
+	  memset(estimatedOutput,0,sizeof(uint32_t) * realArrayLength);
    }

    //Calculate error statistics for the SNR.
@@ -31,7 +31,7 @@
 #ifndef __NR_LDPC_TYPES__H__
 #define __NR_LDPC_TYPES__H__

-#include "PHY/TOOLS/time_meas.h"
+#include "time_meas.h"
 #include "nrLDPCdecoder_defs.h"
 // ==============================================================================
 // TYPES
@@ -33,7 +33,6 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <types.h>
 #include "assertions.h"
 #include "common/utils/LOG/log.h"

@@ -35,7 +35,6 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <types.h>
 #include "defs.h"
 #include "assertions.h"
 #include "openair1/PHY/CODING/nrLDPC_defs.h"
@@ -280,4 +279,4 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,int

 int nrLDPC_encod(unsigned char **test_input,unsigned char **channel_input,int Zc,int Kb,short block_length, short BG, encoder_implemparams_t *impp) {
  return ldpc_encoder_orig(test_input[0],channel_input[0],Zc,Kb,block_length,BG,impp->gen_code);
-}
+}
@@ -36,7 +36,7 @@
 #include <types.h>
 #include "assertions.h"
 #include "common/utils/LOG/log.h"
-#include "PHY/TOOLS/time_meas.h"
+#include "time_meas.h"
 #include "defs.h"

 #include "ldpc384_byte.c"
@@ -33,10 +33,9 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <types.h>
 #include "assertions.h"
 #include "common/utils/LOG/log.h"
-#include "PHY/TOOLS/time_meas.h"
+#include "time_meas.h"
 #include "openair1/PHY/CODING/nrLDPC_defs.h"
 #include "ldpc_encode_parity_check.c"
 #include "ldpc_generate_coefficient.c"
@@ -33,10 +33,9 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <types.h>
 #include "assertions.h"
 #include "common/utils/LOG/log.h"
-#include "PHY/TOOLS/time_meas.h"
+#include "time_meas.h"
 #include "openair1/PHY/CODING/nrLDPC_defs.h"
 #include "ldpc_encode_parity_check.c" 
 #include "ldpc_generate_coefficient.c"
@@ -33,10 +33,9 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <types.h>
 #include "assertions.h"
 #include "common/utils/LOG/log.h"
-#include "PHY/TOOLS/time_meas.h"
+#include "time_meas.h"
 #include "openair1/PHY/CODING/nrLDPC_defs.h"

 #include "ldpc_encode_parity_check.c"
@@ -29,12 +29,13 @@ uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits){
 	uint8_t crcPolynomialSize = 24;
 	uint8_t temp1[crcPolynomialSize], temp2[crcPolynomialSize];

-	uint8_t **crc_generator_matrix = malloc(payloadSizeBits * sizeof(uint8_t *));
+	uint8_t **crc_generator_matrix = malloc(payloadSizeBits*sizeof(uint8_t *) + payloadSizeBits*crcPolynomialSize*sizeof(uint8_t));
 	if (crc_generator_matrix)
 	  for (int i = 0; i < payloadSizeBits; i++)
-		  crc_generator_matrix[i] = malloc(crcPolynomialSize * sizeof(uint8_t));
+	    crc_generator_matrix[i] = ((uint8_t*)&crc_generator_matrix[payloadSizeBits])+i*crcPolynomialSize;

-	for (int i = 0; i < crcPolynomialSize; i++) crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];
+	for (int i = 0; i < crcPolynomialSize; i++)
+	  crc_generator_matrix[payloadSizeBits-1][i]=crcPolynomialPattern[i+1];

 	for (int i = payloadSizeBits-2; i >= 0; i--){
 		for (int j = 0; j < crcPolynomialSize-1; j++) temp1[j]=crc_generator_matrix[i+1][j+1];
@@ -39,19 +39,44 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "assertions.h"

+static inline void updateCrcChecksum2(int xlen,
+				      int ylen,
+				      uint8_t crcChecksum[xlen][ylen],
+				      int gxlen,
+				      int gylen,
+				      uint8_t crcGen[gxlen][gylen],
+				      uint8_t listSize,
+				      uint32_t i2,
+				      uint8_t len)
+{
+  for (uint8_t i = 0; i < listSize; i++) {
+    for (uint8_t j = 0; j < len; j++) {
+      crcChecksum[j][i+listSize] = ( (crcChecksum[j][i] + crcGen[i2][j]) % 2 );
+    }
+  }
+}
+
 int8_t polar_decoder(double *input,
                     uint32_t *out,
-                     const t_nrPolar_params *polarParams,
-                     uint8_t listSize)
+                     uint8_t listSize,
+                     int8_t messageType,
+                     uint16_t messageLength,
+                     uint8_t aggregation_level
+                     )
 {
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, true);
  //Assumes no a priori knowledge.
-  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
-  double *pathMetric = malloc(sizeof(double)*(2*listSize));
-  uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
+  uint8_t bit[polarParams->N][polarParams->n+1][2*listSize];
+  memset(bit,0,sizeof bit);
+  uint8_t bitUpdated[polarParams->N][polarParams->n+1]; //0=False, 1=True
+  memset(bitUpdated,0,sizeof bitUpdated);
+  uint8_t llrUpdated[polarParams->N][polarParams->n+1]; //0=False, 1=True
+  memset(llrUpdated,0,sizeof llrUpdated);
+  double  llr[polarParams->N][polarParams->n+1][2*listSize];
+  uint8_t crcChecksum[polarParams->crcParityBits][2*listSize];
+  memset(crcChecksum,0,sizeof crcChecksum);
+  double  pathMetric[2*listSize];
+  uint8_t crcState[2*listSize]; //0=False, 1=True

  for (int i=0; i<(2*listSize); i++) {
    pathMetric[i] = 0;
@@ -63,13 +88,8 @@ int8_t polar_decoder(double *input,
    bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
  }

-  uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
-  uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2
-
-  for (int i = 0; i < polarParams->K; i++) {
-    extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-    tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-  }
+  uint8_t extended_crc_generator_matrix[polarParams->K][polarParams->crcParityBits]; //G_P3
+  uint8_t tempECGM[polarParams->K][polarParams->crcParityBits]; //G_P2

  for (int i=0; i<polarParams->payloadBits; i++) {
    for (int j=0; j<polarParams->crcParityBits; j++) {
@@ -102,7 +122,7 @@ int8_t polar_decoder(double *input,
    }
  }

-  double *d_tilde = malloc(sizeof(double) * polarParams->N);
+  double d_tilde[polarParams->N];
  nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);

  for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
@@ -117,31 +137,33 @@ int8_t polar_decoder(double *input,
  uint8_t listIndex[2*listSize], copyIndex;

  for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1));
+    updateLLR(currentListSize, currentBit, 0, polarParams->N, polarParams->n+1, 2*listSize, llr, llrUpdated, bit, bitUpdated);

    if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit);
+      updatePathMetric(pathMetric, currentListSize, 0, currentBit, polarParams->N, polarParams->n+1, 2*listSize, llr);
    } else { //Information or CRC bit.
-      updatePathMetric2(pathMetric, llr, currentListSize, currentBit);
+      updatePathMetric2(pathMetric, currentListSize, currentBit, polarParams->N, polarParams->n+1, 2*listSize, llr);

      for (int i = 0; i < currentListSize; i++) {
-        for (int j = 0; j < polarParams->N; j++) {
-          for (int k = 0; k < (polarParams->n+1); k++) {
+      for (int j = 0; j < polarParams->N; j++) {
+	for (int k = 0; k < (polarParams->n+1); k++) {
            bit[j][k][i+currentListSize]=bit[j][k][i];
            llr[j][k][i+currentListSize]=llr[j][k][i];
          }
-        }
+	}
      }

-      for (int i = 0; i < currentListSize; i++) {
-        bit[currentBit][0][i]=0;
-        crcState[i+currentListSize]=crcState[i];
-      }
+	for (int i = 0; i < currentListSize; i++) {
+	  bit[currentBit][0][i]=0;
+	  crcState[i+currentListSize]=crcState[i];
+	}

      for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;

      bitUpdated[currentBit][0]=1;
-      updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
+      updateCrcChecksum2(polarParams->crcParityBits, 2*listSize, crcChecksum,
+			 polarParams->K, polarParams->crcParityBits, extended_crc_generator_matrix, 
+                         currentListSize, nonFrozenBit, polarParams->crcParityBits);
      currentListSize*=2;

      //Keep only the best "listSize" number of entries.
@@ -246,14 +268,7 @@ int8_t polar_decoder(double *input,

      if (decoderIterationCheck==0) {
        //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
-        free(d_tilde);
-        free(pathMetric);
-        free(crcState);
-        nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-        nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-        nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-        free(tempECGM);
-        return(-1);
+        polarReturn(-1);
      }

      nonFrozenBit++;
@@ -282,33 +297,34 @@ int8_t polar_decoder(double *input,
    }
  }

-  free(d_tilde);
-  free(pathMetric);
-  free(crcState);
-  nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-  nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-  nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-  nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
-  nr_free_uint8_2D_array(tempECGM, polarParams->K);
  /*
   * Return bits.
   */
  nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  return(0);
+
+  polarReturn 0;
 }

 int8_t polar_decoder_dci(double *input,
                         uint32_t *out,
-                         const t_nrPolar_params *polarParams,
                         uint8_t listSize,
-                         uint16_t n_RNTI) {
-  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-  double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-  uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
-  double *pathMetric = malloc(sizeof(double)*(2*listSize));
-  uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
+                         uint16_t n_RNTI,
+                         int8_t messageType,
+                         uint16_t messageLength,
+                         uint8_t aggregation_level ) {
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, true);
+
+  uint8_t bit[polarParams->N][polarParams->n+1][2*listSize];
+  memset(bit,0,sizeof bit);
+  uint8_t bitUpdated[polarParams->N][polarParams->n+1]; //0=False, 1=True
+  memset(bitUpdated,0,sizeof bitUpdated);
+  uint8_t llrUpdated[polarParams->N][polarParams->n+1]; //0=False, 1=True
+  memset(llrUpdated,0,sizeof llrUpdated);
+  double  llr[polarParams->N][polarParams->n+1][2*listSize];
+  uint8_t crcChecksum[polarParams->crcParityBits][2*listSize];
+  memset(crcChecksum,0,sizeof crcChecksum);
+  double  pathMetric[2*listSize];
+  uint8_t crcState[2*listSize]; //0=False, 1=True
  uint8_t extended_crc_scrambling_pattern[polarParams->crcParityBits];

  for (int i=0; i<(2*listSize); i++) {
@@ -321,13 +337,8 @@ int8_t polar_decoder_dci(double *input,
    bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
  }

-  uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3: K-by-P
-  uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2: K-by-P
-
-  for (int i = 0; i < polarParams->K; i++) {
-    extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-    tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-  }
+  uint8_t extended_crc_generator_matrix[polarParams->K][polarParams->crcParityBits]; //G_P3: K-by-P
+  uint8_t tempECGM[polarParams->K][polarParams->crcParityBits]; //G_P2: K-by-P

  for (int i=0; i<polarParams->payloadBits; i++) {
    for (int j=0; j<polarParams->crcParityBits; j++) {
@@ -366,17 +377,19 @@ int8_t polar_decoder_dci(double *input,
    extended_crc_scrambling_pattern[i]=(n_RNTI>>(23-i))&1;
  }

-  double *d_tilde = malloc(sizeof(double) * polarParams->N);
+  double d_tilde[polarParams->N];
  nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);

-  for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
+  for (int j = 0; j < polarParams->N; j++)
+    llr[j][polarParams->n][0]=d_tilde[j];

  /*
   * SCL polar decoder.
   */

  for (int i=0; i<polarParams->crcParityBits; i++) {
-    for (int j=0; j<polarParams->crcParityBits; j++) crcChecksum[i][0]=crcChecksum[i][0]+polarParams->crc_generator_matrix[j][i];
+    for (int j=0; j<polarParams->crcParityBits; j++)
+      crcChecksum[i][0]=crcChecksum[i][0]+polarParams->crc_generator_matrix[j][i];

    crcChecksum[i][0]=(crcChecksum[i][0]%2);
  }
@@ -388,12 +401,12 @@ int8_t polar_decoder_dci(double *input,
  uint8_t listIndex[2*listSize], copyIndex;

  for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++) {
-    updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1));
+    updateLLR(currentListSize, currentBit, 0, polarParams->N, polarParams->n+1, 2*listSize, llr, llrUpdated, bit, bitUpdated);

    if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-      updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit);
+      updatePathMetric(pathMetric, currentListSize, 0, currentBit,polarParams->N, polarParams->n+1, 2*listSize, llr);
    } else { //Information or CRC bit.
-      updatePathMetric2(pathMetric, llr, currentListSize, currentBit);
+      updatePathMetric2(pathMetric, currentListSize, currentBit, polarParams->N, polarParams->n+1, 2*listSize, llr);

      for (int i = 0; i < currentListSize; i++) {
        for (int j = 0; j < polarParams->N; j++) {
@@ -412,7 +425,9 @@ int8_t polar_decoder_dci(double *input,
      for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;

      bitUpdated[currentBit][0]=1;
-      updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
+      updateCrcChecksum2(polarParams->crcParityBits, 2*listSize, crcChecksum,
+			 polarParams->K, polarParams->crcParityBits, extended_crc_generator_matrix,
+			 currentListSize, nonFrozenBit, polarParams->crcParityBits);
      currentListSize*=2;

      //Keep only the best "listSize" number of entries.
@@ -513,18 +528,12 @@ int8_t polar_decoder_dci(double *input,
        }
      }

-      for (uint8_t i = 0; i < currentListSize; i++) decoderIterationCheck+=crcState[i];
+      for (uint8_t i = 0; i < currentListSize; i++)
+	decoderIterationCheck+=crcState[i];

      if (decoderIterationCheck==0) {
        //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
-        free(d_tilde);
-        free(pathMetric);
-        free(crcState);
-        nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-        nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-        nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-        free(tempECGM);
-        return(-1);
+        polarReturn -1;
      }

      nonFrozenBit++;
@@ -553,19 +562,12 @@ int8_t polar_decoder_dci(double *input,
    }
  }

-  free(d_tilde);
-  free(pathMetric);
-  free(crcState);
-  nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-  nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-  nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-  nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
-  nr_free_uint8_2D_array(tempECGM, polarParams->K);
  /*
   * Return bits.
   */
  nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  return(0);
+
+  polarReturn 0;
 }

 void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
@@ -604,8 +606,11 @@ void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
 uint32_t polar_decoder_int16(int16_t *input,
                             uint64_t *out,
                             uint8_t ones_flag,
-                             const t_nrPolar_params *polarParams)
+                             int8_t messageType,
+                             uint16_t messageLength,
+                             uint8_t aggregation_level )
 {
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, true);
  int16_t d_tilde[polarParams->N];// = malloc(sizeof(double) * polarParams->N);
  nr_polar_rate_matching_int16(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);

@@ -702,5 +707,6 @@ uint32_t polar_decoder_int16(int16_t *input,
         rxcrc,polarParams->payloadBits);
 #endif
  out[0]=Ar;
-  return(crc^rxcrc);
+
+  polarReturn crc^rxcrc;
 }
@@ -36,51 +36,25 @@

 //#define DEBUG_NEW_IMPL 1

-void updateLLR(double ***llr,
-			   uint8_t **llrU,
-			   uint8_t ***bit,
-			   uint8_t **bitU,
-			   uint8_t listSize,
-			   uint16_t row,
-			   uint16_t col,
-			   uint16_t xlen,
-			   uint8_t ylen)
-{
-	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
-	for (uint8_t i=0; i<listSize; i++) {
-		if (( (row) % (2*offset) ) >= offset ) {
-			if(bitU[row-offset][col]==0) updateBit(bit, bitU, listSize, (row-offset), col, xlen, ylen);
-			if(llrU[row-offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row-offset), (col+1), xlen, ylen);
-			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen);
-			llr[row][col][i] = (pow((-1),bit[row-offset][col][i])*llr[row-offset][col+1][i]) + llr[row][col+1][i];
-		} else {
-			if(llrU[row][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, row, (col+1), xlen, ylen);
-			if(llrU[row+offset][col+1]==0) updateLLR(llr, llrU, bit, bitU, listSize, (row+offset), (col+1), xlen, ylen);
-			computeLLR(llr, row, col, i, offset);
-		}
-	}
-	llrU[row][col]=1;

-	//	printf("LLR (a %f, b %f): llr[%d][%d] %f\n",32*a,32*b,col,row,32*llr[col][row]);
-}
-
-void updateBit(uint8_t ***bit,
-			   uint8_t **bitU,
-			   uint8_t listSize,
-			   uint16_t row,
-			   uint16_t col,
-			   uint16_t xlen,
-			   uint8_t ylen)
+static inline void updateBit(uint8_t listSize,
+			     uint16_t row,
+			     uint16_t col,
+			     uint16_t xlen,
+			     uint8_t ylen,
+			     int zlen,
+			     uint8_t bit[xlen][ylen][zlen],
+			     uint8_t bitU[xlen][ylen])
 {
 	uint16_t offset = ( xlen/(pow(2,(ylen-col))) );

 	for (uint8_t i=0; i<listSize; i++) {
 		if (( (row) % (2*offset) ) >= offset ) {
-			if (bitU[row][col-1]==0) updateBit(bit, bitU, listSize, row, (col-1), xlen, ylen);
+		  if (bitU[row][col-1]==0) updateBit(listSize, row, (col-1), xlen, ylen, zlen, bit, bitU);
 			bit[row][col][i] = bit[row][col-1][i];
 		} else {
-			if (bitU[row][col-1]==0) updateBit(bit, bitU, listSize, row, (col-1), xlen, ylen);
-			if (bitU[row+offset][col-1]==0) updateBit(bit, bitU, listSize, (row+offset), (col-1), xlen, ylen);
+		  if (bitU[row][col-1]==0) updateBit(listSize, row, (col-1), xlen, ylen, zlen, bit, bitU);
+		  if (bitU[row+offset][col-1]==0) updateBit(listSize, (row+offset), (col-1), xlen, ylen, zlen, bit, bitU);
 			bit[row][col][i] = ( (bit[row][col-1][i]+bit[row+offset][col-1][i]) % 2);
 		}
 	}
@@ -88,11 +62,60 @@ void updateBit(uint8_t ***bit,
 	bitU[row][col]=1;
 }

+static inline void computeLLR(uint16_t row,
+			      uint16_t col,
+			      uint8_t i,
+			      uint16_t offset,
+			      int xlen,
+			      int ylen,
+			      int zlen,
+			      double llr[xlen][ylen][zlen])
+{
+  double a = llr[row][col + 1][i];
+  double b = llr[row + offset][col + 1][i];
+  llr[row][col][i] = log((exp(a + b) + 1) / (exp(a) + exp(b))); //eq. (8a)
+}
+
+
+void updateLLR(uint8_t listSize,
+	       uint16_t row,
+	       uint16_t col,
+	        uint16_t xlen,
+	       uint8_t ylen,
+	       int zlen,
+	       double  llr[xlen][ylen][zlen],
+	       uint8_t llrU[xlen][ylen],
+	       uint8_t bit[xlen][ylen][zlen],
+	       uint8_t bitU[xlen][ylen]
+	       )
+{
+	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
+	for (uint8_t i=0; i<listSize; i++) {
+		if (( (row) % (2*offset) ) >= offset ) {
+		  if(bitU[row-offset][col]==0) updateBit(listSize, (row-offset), col, xlen, ylen, zlen, bit, bitU);
+		  if(llrU[row-offset][col+1]==0) updateLLR(listSize, (row-offset), (col+1), xlen, ylen, zlen, llr, llrU, bit, bitU );
+		  if(llrU[row][col+1]==0) updateLLR(listSize, row, (col+1), xlen, ylen, zlen, llr, llrU, bit, bitU);
+			llr[row][col][i] = (pow((-1),bit[row-offset][col][i])*llr[row-offset][col+1][i]) + llr[row][col+1][i];
+		} else {
+		  if(llrU[row][col+1]==0) updateLLR(listSize, row, (col+1), xlen, ylen, zlen, llr, llrU, bit, bitU );
+		  if(llrU[row+offset][col+1]==0) updateLLR(listSize, (row+offset), (col+1), xlen, ylen, zlen, llr, llrU, bit, bitU );
+		  computeLLR(row, col, i, offset, xlen, ylen, zlen, llr);
+		}
+	}
+	llrU[row][col]=1;
+
+	//	printf("LLR (a %f, b %f): llr[%d][%d] %f\n",32*a,32*b,col,row,32*llr[col][row]);
+}
+
 void updatePathMetric(double *pathMetric,
-		              double ***llr,
-					  uint8_t listSize,
-					  uint8_t bitValue,
-					  uint16_t row)
+		      uint8_t listSize,
+		      uint8_t bitValue,
+		      uint16_t row,
+		      int xlen,
+		      int ylen,
+		      int zlen,
+		      double llr[xlen][ylen][zlen]
+		      )
 {
 	int8_t multiplier = (2*bitValue) - 1;
 	for (uint8_t i=0; i<listSize; i++)
@@ -101,11 +124,14 @@ void updatePathMetric(double *pathMetric,
 }

 void updatePathMetric2(double *pathMetric,
-					   double ***llr,
-					   uint8_t listSize,
-					   uint16_t row)
+		       uint8_t listSize,
+		       uint16_t row,
+		       int xlen,
+		       int ylen,
+		       int zlen,
+		       double llr[xlen][ylen][zlen])
 {
-	double *tempPM = malloc(sizeof(double) * listSize);
+	double tempPM[listSize];
 	memcpy(tempPM, pathMetric, (sizeof(double) * listSize));

 	uint8_t bitValue = 0;
@@ -118,48 +144,8 @@ void updatePathMetric2(double *pathMetric,
 	for (uint8_t i = listSize; i < 2*listSize; i++)
 		pathMetric[i] = tempPM[(i-listSize)] + log(1 + exp(multiplier * llr[row][0][(i-listSize)])); //eq. (11b)

-	free(tempPM);
 }

-void computeLLR(double ***llr,
-				uint16_t row,
-				uint16_t col,
-				uint8_t i,
-				uint16_t offset)
-{
-	double a = llr[row][col + 1][i];
-	double b = llr[row + offset][col + 1][i];
-	llr[row][col][i] = log((exp(a + b) + 1) / (exp(a) + exp(b))); //eq. (8a)
-}
-
-void updateCrcChecksum(uint8_t **crcChecksum,
-					   uint8_t **crcGen,
-					   uint8_t listSize,
-					   uint32_t i2,
-					   uint8_t len)
-{
-	for (uint8_t i = 0; i < listSize; i++) {
-		for (uint8_t j = 0; j < len; j++) {
-			crcChecksum[j][i] = ( (crcChecksum[j][i] + crcGen[i2][j]) % 2 );
-		}
-	}
-}
-
-void updateCrcChecksum2(uint8_t **crcChecksum,
-						uint8_t **crcGen,
-						uint8_t listSize,
-						uint32_t i2,
-						uint8_t len)
-{
-	for (uint8_t i = 0; i < listSize; i++) {
-		for (uint8_t j = 0; j < len; j++) {
-			crcChecksum[j][i+listSize] = ( (crcChecksum[j][i] + crcGen[i2][j]) % 2 );
-		}
-	}
-}
-
-
-
 decoder_node_t *new_decoder_node(int first_leaf_index, int level) {

  decoder_node_t *node=(decoder_node_t *)malloc(sizeof(decoder_node_t));
@@ -222,6 +208,23 @@ decoder_node_t *add_nodes(int level, int first_leaf_index, t_nrPolar_params *pol
  return(new_node);
 }

+void delete_nodes(decoder_node_t * n) {
+  if (n) {
+    if(n->left)
+      delete_nodes(n->left);
+    if(n->right)
+      delete_nodes(n->right);
+    free(n->alpha);
+    free(n->beta);
+    free(n);
+  }
+}
+
+void delete_decoder_tree(t_nrPolar_params *polarParams) {
+  if (polarParams->tree.root)
+    delete_nodes(polarParams->tree.root);
+}
+
 void build_decoder_tree(t_nrPolar_params *polarParams)
 {
  polarParams->tree.num_nodes=0;
@@ -79,9 +79,10 @@ typedef struct decoder_tree_t_s {

 struct nrPolar_params {
  //messageType: 0=PBCH, 1=DCI, -1=UCI
-  int idx; //idx = (messageType * messageLength * aggregation_prime);
-  struct nrPolar_params *nextPtr;

+  struct nrPolar_params *nextPtr __attribute__((aligned(16)));
+  bool busy;
+  uint32_t idx;
  uint8_t n_max;
  uint8_t i_il;
  uint8_t i_seg;
@@ -138,34 +139,46 @@ typedef struct nrPolar_params t_nrPolar_params;

 void polar_encoder(uint32_t *input,
                   uint32_t *output,
-                   const t_nrPolar_params *polarParams);
+                   int8_t messageType,
+                   uint16_t messageLength,
+                   uint8_t aggregation_level);

 void polar_encoder_dci(uint32_t *in,
                       uint32_t *out,
-                       const t_nrPolar_params *polarParams,
-                       uint16_t n_RNTI);
+                       uint16_t n_RNTI,
+                       int8_t messageType,
+                       uint16_t messageLength,
+                       uint8_t aggregation_level);

 void polar_encoder_fast(uint64_t *A,
                        void *out,
                        int32_t crcmask,
                        uint8_t ones_flag,
-                        const t_nrPolar_params *polarParams);
+                        int8_t messageType,
+                        uint16_t messageLength,
+                        uint8_t aggregation_level);

 int8_t polar_decoder(double *input,
                     uint32_t *output,
-                     const t_nrPolar_params *polarParams,
-                     uint8_t listSize);
+                     uint8_t listSize,
+                     int8_t messageType,
+                     uint16_t messageLength,
+                     uint8_t aggregation_level);

 uint32_t polar_decoder_int16(int16_t *input,
                             uint64_t *out,
                             uint8_t ones_flag,
-                             const t_nrPolar_params *polarParams);
+                             int8_t messageType,
+                             uint16_t messageLength,
+                             uint8_t aggregation_level);

 int8_t polar_decoder_dci(double *input,
                         uint32_t *out,
-                         const t_nrPolar_params *polarParams,
                         uint8_t listSize,
-                         uint16_t n_RNTI);
+                         uint16_t n_RNTI,
+                         int8_t messageType,
+                         uint16_t messageLength,
+                         uint8_t aggregation_level);

 void generic_polar_decoder(const t_nrPolar_params *pp,
                           decoder_node_t *node);
@@ -183,13 +196,12 @@ void build_decoder_tree(t_nrPolar_params *pp);
 void build_polar_tables(t_nrPolar_params *polarParams);
 void init_polar_deinterleaver_table(t_nrPolar_params *polarParams);

-void nr_polar_print_polarParams(t_nrPolar_params *polarParams);
+void nr_polar_print_polarParams(void);

 t_nrPolar_params *nr_polar_params (int8_t messageType,
                                   uint16_t messageLength,
                                   uint8_t aggregation_level,
-				   int decoder_flag,
-				   t_nrPolar_params **polarList_ext);
+				   int decoder_flag);

 uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level);

@@ -278,34 +290,6 @@ void nr_matrix_multiplication_uint8_1D_uint8_2D(uint8_t *matrix1,
    uint16_t row,
    uint16_t col);

-uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen,
-                                   uint16_t ylen,
-                                   uint16_t zlen);
-
-uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen,
-                                  uint16_t ylen);
-
-double ***nr_alloc_double_3D_array(uint16_t xlen,
-                                   uint16_t ylen,
-                                   uint16_t zlen);
-
-double **nr_alloc_double_2D_array(uint16_t xlen,
-                                  uint16_t ylen);
-
-void nr_free_double_3D_array(double ***input,
-                             uint16_t xlen,
-                             uint16_t ylen);
-
-void nr_free_double_2D_array(double **input,
-                             uint16_t xlen);
-
-void nr_free_uint8_3D_array(uint8_t ***input,
-                            uint16_t xlen,
-                            uint16_t ylen);
-
-void nr_free_uint8_2D_array(uint8_t **input,
-                            uint16_t xlen);
-
 void nr_sort_asc_double_1D_array_ind(double *matrix,
                                     uint8_t *ind,
                                     uint8_t len);
@@ -316,52 +300,33 @@ void nr_sort_asc_int16_1D_array_ind(int32_t *matrix,

 void nr_free_double_2D_array(double **input, uint16_t xlen);

-void updateLLR(double ***llr,
-               uint8_t **llrU,
-               uint8_t ***bit,
-               uint8_t **bitU,
-               uint8_t listSize,
-               uint16_t row,
-               uint16_t col,
-               uint16_t xlen,
-               uint8_t ylen);
-
-void updateBit(uint8_t ***bit,
-               uint8_t **bitU,
-               uint8_t listSize,
-               uint16_t row,
-               uint16_t col,
-               uint16_t xlen,
-               uint8_t ylen);
-
+void updateLLR(uint8_t listSize,
+	       uint16_t row,
+	       uint16_t col,
+	        uint16_t xlen,
+	       uint8_t ylen,
+	       int zlen,
+	       double  llr[xlen][ylen][zlen],
+	       uint8_t llrU[xlen][ylen],
+	       uint8_t bit[xlen][ylen][zlen],
+	       uint8_t bitU[xlen][ylen]
+	       );
 void updatePathMetric(double *pathMetric,
-                      double ***llr,
-                      uint8_t listSize,
-                      uint8_t bitValue,
-                      uint16_t row);
-
+		      uint8_t listSize,
+		      uint8_t bitValue,
+		      uint16_t row,
+		      int xlen,
+		      int ylen,
+		      int zlen,
+		      double llr[xlen][ylen][zlen]
+		      );
 void updatePathMetric2(double *pathMetric,
-                       double ***llr,
-                       uint8_t listSize,
-                       uint16_t row);
-
-void computeLLR(double ***llr,
-                uint16_t row,
-                uint16_t col,
-                uint8_t i,
-                uint16_t offset);
-
-void updateCrcChecksum(uint8_t **crcChecksum,
-                       uint8_t **crcGen,
-                       uint8_t listSize,
-                       uint32_t i2,
-                       uint8_t len);
-
-void updateCrcChecksum2(uint8_t **crcChecksum,
-                        uint8_t **crcGen,
-                        uint8_t listSize,
-                        uint32_t i2,
-                        uint8_t len);
+		       uint8_t listSize,
+		       uint16_t row,
+		       int xlen,
+		       int ylen,
+		       int zlen,
+		       double llr[xlen][ylen][zlen]);

 //Also nr_polar_rate_matcher
 static inline void nr_polar_interleaver(uint8_t *input,
@@ -379,5 +344,13 @@ static inline void nr_polar_deinterleaver(uint8_t *input,
 {
 	for (int i=0; i<size; i++) output[pattern[i]]=input[i];
 }
+void delete_decoder_tree(t_nrPolar_params *);
+
+extern pthread_mutex_t PolarListMutex;
+#define polarReturn                          \
+pthread_mutex_lock(&PolarListMutex);            \
+polarParams->busy=false;                         \
+pthread_mutex_unlock(&PolarListMutex);          \
+return

 #endif
@@ -43,7 +43,10 @@

 void polar_encoder(uint32_t *in,
                   uint32_t *out,
-                   const t_nrPolar_params *polarParams) {
+                   int8_t messageType,
+                   uint16_t messageLength,
+                   uint8_t aggregation_level) {
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, false);
  if (1) {//polarParams->idx == 0 || polarParams->idx == 1) { //PBCH or PDCCH
    /*
    uint64_t B = (((uint64_t)*in)&((((uint64_t)1)<<32)-1)) | (((uint64_t)crc24c((uint8_t*)in,polarParams->payloadBits)>>8)<<polarParams->payloadBits);
@@ -57,10 +60,10 @@ void polar_encoder(uint32_t *in,
     */
    //Calculate CRC.
    nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_A,
-    										   polarParams->crc_generator_matrix,
-											   polarParams->nr_polar_crc,
-											   polarParams->payloadBits,
-											   polarParams->crcParityBits);
+                                               polarParams->crc_generator_matrix,
+                                               polarParams->nr_polar_crc,
+                                               polarParams->payloadBits,
+                                               polarParams->crcParityBits);

    for (uint8_t i = 0; i < polarParams->crcParityBits; i++)
      polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
@@ -150,12 +153,19 @@ void polar_encoder(uint32_t *in,

 #endif
  nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
+
+  polarReturn;
+
 }

 void polar_encoder_dci(uint32_t *in,
                       uint32_t *out,
-                       const t_nrPolar_params *polarParams,
-                       uint16_t n_RNTI) {
+                       uint16_t n_RNTI,
+                       int8_t messageType,
+                       uint16_t messageLength,
+                       uint8_t aggregation_level) {
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, false);
+
 #ifdef DEBUG_POLAR_ENCODER_DCI
  printf("[polar_encoder_dci] in: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", in[0], in[1], in[2], in[3]);
 #endif
@@ -249,6 +259,7 @@ void polar_encoder_dci(uint32_t *in,
  printf("\n[polar_encoder_dci] out: ");
  for (int i = 0; i < outputInd; i++) printf("[%d]->0x%08x\t", i, out[i]);
 #endif
+  polarReturn;
 }

 static inline void polar_rate_matching(const t_nrPolar_params *polarParams,void *in,void *out) __attribute__((always_inline));
@@ -334,7 +345,7 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
  AssertFatal(polarParams->N==512 || polarParams->N==256 || polarParams->N==128,"N = %d, not done yet\n",polarParams->N);
  // build G bit vectors for information bit positions and convert the bit as bytes tables in nr_polar_kronecker_power_matrices.c to 64 bit packed vectors.
  // keep only rows of G which correspond to information/crc bits
-  polarParams->G_N_tab = (uint64_t **)malloc((polarParams->K + polarParams->n_pc) * sizeof(int64_t *));
+  polarParams->G_N_tab = (uint64_t **)calloc((polarParams->K + polarParams->n_pc),sizeof(int64_t *));
  int k=0;

  for (int i=0; i<polarParams->N; i++) {
@@ -418,11 +429,14 @@ void polar_encoder_fast(uint64_t *A,
                        void *out,
                        int32_t crcmask,
                        uint8_t ones_flag,
-                        const t_nrPolar_params *polarParams) {
+                        int8_t messageType,
+                        uint16_t messageLength,
+                        uint8_t aggregation_level) {
+                        
+  t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, false);
  //  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
  AssertFatal(polarParams->K < 129, "K = %d > 128, is not supported yet\n",polarParams->K);
  AssertFatal(polarParams->payloadBits < 65, "payload bits = %d > 64, is not supported yet\n",polarParams->payloadBits);
-  uint64_t B[4]= {0,0,0,0},Cprime[4]= {0,0,0,0};
  int bitlen = polarParams->payloadBits;
  // append crc
  AssertFatal(bitlen<129,"support for payloads <= 128 bits\n");
@@ -451,9 +465,12 @@ void polar_encoder_fast(uint64_t *A,
    A32_flip[1+offset]=((uint8_t *)&Aprime)[2];
    A32_flip[2+offset]=((uint8_t *)&Aprime)[1];
    A32_flip[3+offset]=((uint8_t *)&Aprime)[0];
-    if      (polarParams->crcParityBits == 24) tcrc = (uint64_t)(((crcmask^(crc24c(A32_flip,8*offset+bitlen)>>8)))&0xffffff);
-    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)(((crcmask^(crc11(A32_flip,bitlen)>>21)))&0x7ff);
-    else if (polarParams->crcParityBits == 6) tcrc = (uint64_t)(((crcmask^(crc6(A32_flip,bitlen)>>26)))&0x3f);
+    if      (polarParams->crcParityBits == 24)
+      tcrc = (uint64_t)(((crcmask^(crc24c(A32_flip,8*offset+bitlen)>>8)))&0xffffff);
+    else if (polarParams->crcParityBits == 11)
+      tcrc = (uint64_t)(((crcmask^(crc11(A32_flip,bitlen)>>21)))&0x7ff);
+    else if (polarParams->crcParityBits == 6)
+      tcrc = (uint64_t)(((crcmask^(crc6(A32_flip,bitlen)>>26)))&0x3f);
  } else if (bitlen<=64) {
    uint8_t A64_flip[8+offset];
    if (ones_flag) {
@@ -470,8 +487,10 @@ void polar_encoder_fast(uint64_t *A,
    A64_flip[5+offset]=((uint8_t *)&Aprime)[2];
    A64_flip[6+offset]=((uint8_t *)&Aprime)[1];
    A64_flip[7+offset]=((uint8_t *)&Aprime)[0];
-    if (polarParams->crcParityBits == 24)      tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,8*offset+bitlen)>>8)))&0xffffff;
-    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)((crcmask^(crc11(A64_flip,bitlen)>>21)))&0x7ff;
+    if (polarParams->crcParityBits == 24)
+      tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,8*offset+bitlen)>>8)))&0xffffff;
+    else if (polarParams->crcParityBits == 11)
+      tcrc = (uint64_t)((crcmask^(crc11(A64_flip,bitlen)>>21)))&0x7ff;
  }
  else if (bitlen<=128) {
    uint8_t A128_flip[16+offset];
@@ -481,38 +500,37 @@ void polar_encoder_fast(uint64_t *A,
      A128_flip[2] = 0xff;
    }
    uint128_t Aprime= (uint128_t)(((uint128_t)*A)<<(128-bitlen));
-    A128_flip[0+offset]=((uint8_t*)&Aprime)[15];	  A128_flip[1+offset]=((uint8_t*)&Aprime)[14];
-    A128_flip[2+offset]=((uint8_t*)&Aprime)[13];	  A128_flip[3+offset]=((uint8_t*)&Aprime)[12];
-    A128_flip[4+offset]=((uint8_t*)&Aprime)[11];	  A128_flip[5+offset]=((uint8_t*)&Aprime)[10];
-    A128_flip[6+offset] =((uint8_t*)&Aprime)[9];	  A128_flip[7+offset] =((uint8_t*)&Aprime)[8];
-    A128_flip[8+offset] =((uint8_t*)&Aprime)[7];	  A128_flip[9+offset] =((uint8_t*)&Aprime)[6];
-    A128_flip[10+offset]=((uint8_t*)&Aprime)[5];	  A128_flip[11+offset]=((uint8_t*)&Aprime)[4];
-    A128_flip[12+offset]=((uint8_t*)&Aprime)[3];	  A128_flip[13+offset]=((uint8_t*)&Aprime)[2];
-    A128_flip[14+offset]=((uint8_t*)&Aprime)[1];	  A128_flip[15+offset]=((uint8_t*)&Aprime)[0];
-    if (polarParams->crcParityBits == 24) tcrc = (uint64_t)((crcmask^(crc24c(A128_flip,8*offset+bitlen)>>8)))&0xffffff;
-    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)((crcmask^(crc11(A128_flip,bitlen)>>21)))&0x7ff;
+    for (int i=0; i<16 ; i++)
+      A128_flip[i+offset]=((uint8_t*)&Aprime)[15-i];
+    if (polarParams->crcParityBits == 24)
+      tcrc = (uint64_t)((crcmask^(crc24c(A128_flip,8*offset+bitlen)>>8)))&0xffffff;
+    else if (polarParams->crcParityBits == 11)
+      tcrc = (uint64_t)((crcmask^(crc11(A128_flip,bitlen)>>21)))&0x7ff;
  }

  int n;
  // this is number of quadwords in the bit string
-  int quadwlen = (polarParams->K>>6);
-
-  if ((polarParams->K&63) > 0) quadwlen++;
+  int quadwlen = (polarParams->K+63)/64;

  // Create the B bit string as
  // 0, 0, ..., 0, a'_0, a'_1, ..., a'_A-1, p_0, p_1, ..., p_{N_parity-1}

  //??? b_{N'-1} b_{N'-2} ... b_{N'-A} b_{N'-A-1} ... b_{N'-A-Nparity} = a_{N-1} a_{N-2} ... a_{N-A} p_{N_parity-1} ... p_0
-
-  for (n=0; n<quadwlen; n++) if (n==0) B[n] = (A[n] << polarParams->crcParityBits) | tcrc;
-                             else      B[n] = (A[n] << polarParams->crcParityBits) | (A[n-1]>>(64-polarParams->crcParityBits));
+  uint64_t B[4]= {0};
+  B[0] = (A[0] << polarParams->crcParityBits) | tcrc;
+  for (n=1; n<quadwlen; n++)
+    if ((bitlen+63)/64 > n)
+      B[n] = (A[n] << polarParams->crcParityBits) | (A[n-1]>>(64-polarParams->crcParityBits));
+    else
+      B[n] = (A[n-1]>>(64-polarParams->crcParityBits));

  uint8_t *Bbyte = (uint8_t *)B;

  // for each byte of B, lookup in corresponding table for 64-bit word corresponding to that byte and its position
+  uint64_t Cprime[4]= {0};
  if (polarParams->K<65)
    Cprime[0] = polarParams->cprime_tab0[0][Bbyte[0]] |
-                polarParams->cprime_tab0[1][Bbyte[1]] |
+      polarParams->cprime_tab0[1][Bbyte[1]] |
                polarParams->cprime_tab0[2][Bbyte[2]] |
                polarParams->cprime_tab0[3][Bbyte[3]] |
                polarParams->cprime_tab0[4][Bbyte[4]] |
@@ -684,4 +702,7 @@ void polar_encoder_fast(uint64_t *A,
  }
  memset((void*)out,0,polarParams->encoderLength>>3);
  polar_rate_matching(polarParams,(void *)D, out);
+
+  polarReturn;
+
 }
@@ -43,163 +43,6 @@ void nr_matrix_multiplication_uint8_1D_uint8_2D(uint8_t *matrix1, uint8_t **matr
 	}
 }

-uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
-	uint8_t ***output;
-	int i, j;
-
-	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_uint8_3D_array] Problem at 1D allocation");
-		return NULL;
-	}
-	for (i = 0; i < xlen; i++)
-		output[i] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_uint8_3D_array] Problem at 2D allocation");
-			nr_free_uint8_3D_array(output, xlen, ylen);
-			return NULL;
-		}
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			output[i][j] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			if ((output[i][j] = malloc(zlen * sizeof *output[i][j])) == NULL) {
-				perror("[nr_alloc_uint8_3D_array] Problem at 3D allocation");
-				nr_free_uint8_3D_array(output, xlen, ylen);
-				return NULL;
-			}
-
-	return output;
-}
-
-uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen, uint16_t ylen) {
-	uint8_t **output;
-	int i, j;
-
-	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_uint8_2D_array] Problem at 1D allocation");
-		return NULL;
-	}
-	for (i = 0; i < xlen; i++)
-		output[i] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_uint8_2D_array] Problem at 2D allocation");
-			nr_free_uint8_2D_array(output, xlen);
-			return NULL;
-		}
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			output[i][j] = 0;
-
-	return output;
-}
-
-double ***nr_alloc_double_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
-	double ***output;
-	int i, j;
-
-	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_double_3D_array] Problem at 1D allocation");
-		return NULL;
-	}
-	for (i = 0; i < xlen; i++)
-		output[i] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_double_3D_array] Problem at 2D allocation");
-			nr_free_double_3D_array(output, xlen, ylen);
-			return NULL;
-		}
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			output[i][j] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			if ((output[i][j] = malloc(zlen * sizeof *output[i][j])) == NULL) {
-				perror("[nr_alloc_double_3D_array] Problem at 3D allocation");
-				nr_free_double_3D_array(output, xlen, ylen);
-				return NULL;
-			}
-
-	return output;
-}
-
-double **nr_alloc_double_2D_array(uint16_t xlen, uint16_t ylen) {
-  double **output;
-  int i, j;
-  
-  if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-    perror("[nr_alloc_double_3D_array] Problem at 1D allocation");
-    return NULL;
-  }
-  for (i = 0; i < xlen; i++)
-    output[i] = NULL;
-  
-  
-  for (i = 0; i < xlen; i++)
-    if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-      perror("[nr_alloc_double_2D_array] Problem at 2D allocation");
-      nr_free_double_2D_array(output, xlen);
-      return NULL;
-    }
-  for (i = 0; i < xlen; i++)
-    for (j = 0; j < ylen; j++)
-      output[i][j] = 0;
-  
-
-  return output;
-}
-
-void nr_free_double_3D_array(double ***input, uint16_t xlen, uint16_t ylen) {
-	int i, j;
-
-	for (i = 0; i < xlen; i++) {
-		for (j = 0; j < ylen; j++) {
-			free(input[i][j]);
-		}
-		free(input[i]);
-	}
-	free(input);
-}
-
-void nr_free_double_2D_array(double **input, uint16_t xlen) {
-  int i;
-
-  for (i = 0; i < xlen; i++) {
-    free(input[i]);
-  }
-  free(input);
-}
-
-void nr_free_uint8_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen) {
-	int i, j;
-
-	for (i = 0; i < xlen; i++) {
-		for (j = 0; j < ylen; j++) {
-			free(input[i][j]);
-		}
-		free(input[i]);
-	}
-	free(input);
-}
-
-void nr_free_uint8_2D_array(uint8_t **input, uint16_t xlen) {
-  for (int i = 0; i < xlen; i++) free(input[i]);
-  free(input);
-}
-
 // Modified Bubble Sort.
 void nr_sort_asc_double_1D_array_ind(double *matrix, uint8_t *ind, uint8_t len) {
 	int swaps;
@@ -33,178 +33,236 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "PHY/NR_TRANSPORT/nr_dci.h"

+#define PolarKey ((messageType<<24)|(messageLength<<8)|aggregation_level)
+static t_nrPolar_params * PolarList=NULL;
+pthread_mutex_t PolarListMutex=PTHREAD_MUTEX_INITIALIZER;
+
 static int intcmp(const void *p1,const void *p2) {
  return(*(int16_t *)p1 > *(int16_t *)p2);
 }

-static void nr_polar_init(t_nrPolar_params * *polarParams,
-                          int8_t messageType,
+static void nr_polar_delete_list(t_nrPolar_params * polarParams) {
+  if (!polarParams)
+    return;
+  if (polarParams->nextPtr)
+    nr_polar_delete_list(polarParams->nextPtr);
+  
+  delete_decoder_tree(polarParams);
+  //From build_polar_tables()
+  for (int k=0; k < polarParams->K + polarParams->n_pc; k++)
+    if (polarParams->G_N_tab[k]) 
+      free(polarParams->G_N_tab[k]);
+  free(polarParams->G_N_tab);
+  free(polarParams->rm_tab);
+  if (polarParams->crc_generator_matrix)
+    free(polarParams->crc_generator_matrix);
+  //polar_encoder vectors:
+  free(polarParams->nr_polar_crc);
+  free(polarParams->nr_polar_aPrime);
+  free(polarParams->nr_polar_APrime);
+  free(polarParams->nr_polar_D);
+  free(polarParams->nr_polar_E);
+    //Polar Coding vectors
+  free(polarParams->nr_polar_U);
+  free(polarParams->nr_polar_CPrime);
+  free(polarParams->nr_polar_B);
+  free(polarParams->nr_polar_A);
+  free(polarParams->interleaving_pattern);
+  free(polarParams->deinterleaving_pattern);
+  free(polarParams->rate_matching_pattern);
+  free(polarParams->information_bit_pattern);
+  free(polarParams->Q_I_N);
+  free(polarParams->Q_F_N);
+  free(polarParams->Q_PC_N);
+  free(polarParams->channel_interleaver_pattern);
+  free(polarParams);
+}
+
+static void nr_polar_delete(void) {
+  pthread_mutex_lock(&PolarListMutex);
+  nr_polar_delete_list(PolarList);
+  PolarList=NULL;
+  pthread_mutex_unlock(&PolarListMutex);  
+}
+
+t_nrPolar_params * nr_polar_params(int8_t messageType,
                          uint16_t messageLength,
                          uint8_t aggregation_level,
 			  int decoder_flag) {
-  t_nrPolar_params *currentPtr = *polarParams;
-  uint16_t aggregation_prime = (messageType >= 2) ? aggregation_level : nr_polar_aggregation_prime(aggregation_level);
-
+  // The lock is weak, because we never delete in the list, only at exit time
+  // therefore, returning t_nrPolar_params * from the list is safe for future usage
+  pthread_mutex_lock(&PolarListMutex);
+  if(!PolarList)
+    atexit(nr_polar_delete);
+  
+  t_nrPolar_params *currentPtr = PolarList;
  //Parse the list. If the node is already created, return without initialization.
  while (currentPtr != NULL) {
    //printf("currentPtr->idx %d, (%d,%d)\n",currentPtr->idx,currentPtr->payloadBits,currentPtr->encoderLength);
    //LOG_D(PHY,"Looking for index %d\n",(messageType * messageLength * aggregation_prime));
-    if (currentPtr->idx == (messageType * messageLength * aggregation_prime)) return;
-    else currentPtr = currentPtr->nextPtr;
+    if (currentPtr->busy == false && currentPtr->idx == PolarKey ) {
+      currentPtr->busy=true;
+      pthread_mutex_unlock(&PolarListMutex);
+      if (decoder_flag && !currentPtr->tree.root)
+        build_decoder_tree(currentPtr);
+      return currentPtr ;
+    }
+    else
+      currentPtr = currentPtr->nextPtr;
  }

  //  printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams);
  //Else, initialize and add node to the end of the linked list.
  t_nrPolar_params *newPolarInitNode = calloc(sizeof(t_nrPolar_params),1);
- 
-  if (newPolarInitNode != NULL) {
-    //   LOG_D(PHY,"Setting new polarParams index %d, messageType %d, messageLength %d, aggregation_prime %d\n",(messageType * messageLength * aggregation_prime),messageType,messageLength,aggregation_prime);
-    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);
+  newPolarInitNode->busy=true;
+  pthread_mutex_unlock(&PolarListMutex);

-    if (messageType == 0) { //PBCH
-      newPolarInitNode->n_max = NR_POLAR_PBCH_N_MAX;
-      newPolarInitNode->i_il = NR_POLAR_PBCH_I_IL;
-      newPolarInitNode->i_seg = NR_POLAR_PBCH_I_SEG;
-      newPolarInitNode->n_pc = NR_POLAR_PBCH_N_PC;
-      newPolarInitNode->n_pc_wm = NR_POLAR_PBCH_N_PC_WM;
-      newPolarInitNode->i_bil = NR_POLAR_PBCH_I_BIL;
-      newPolarInitNode->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS;
-      newPolarInitNode->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS;
-      newPolarInitNode->encoderLength = NR_POLAR_PBCH_E;
-      newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS;
-      newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P
-      //printf("Initializing polar parameters for PBCH (K %d, E %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength);
-    } else if (messageType == 1) { //DCI
-      newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX;
-      newPolarInitNode->i_il = NR_POLAR_DCI_I_IL;
-      newPolarInitNode->i_seg = NR_POLAR_DCI_I_SEG;
-      newPolarInitNode->n_pc = NR_POLAR_DCI_N_PC;
-      newPolarInitNode->n_pc_wm = NR_POLAR_DCI_N_PC_WM;
-      newPolarInitNode->i_bil = NR_POLAR_DCI_I_BIL;
-      newPolarInitNode->crcParityBits = NR_POLAR_DCI_CRC_PARITY_BITS;
-      newPolarInitNode->payloadBits = messageLength;
-      newPolarInitNode->encoderLength = aggregation_level*108;
-      newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
-      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 == 2) { //UCI PUCCH2
-      AssertFatal(aggregation_level>2,"Aggregation level (%d) for PUCCH 2 encoding is NPRB and should be > 2\n",aggregation_level);
-      AssertFatal(messageLength>11,"Message length %d is too short for polar encoding of UCI\n",messageLength);
-      newPolarInitNode->n_max = NR_POLAR_PUCCH_N_MAX;
-      newPolarInitNode->i_il = NR_POLAR_PUCCH_I_IL;
-      newPolarInitNode->encoderLength = aggregation_level * 16;
+  AssertFatal(newPolarInitNode != NULL, "[nr_polar_init] New t_nrPolar_params * could not be created");
+  
+  //   LOG_D(PHY,"Setting new polarParams index %d, messageType %d, messageLength %d, aggregation_prime %d\n",(messageType * messageLength * aggregation_prime),messageType,messageLength,aggregation_prime);
+  newPolarInitNode->idx = PolarKey;
+  newPolarInitNode->nextPtr = NULL;
+  //printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
+  
+  if (messageType == 0) { //PBCH
+    newPolarInitNode->n_max = NR_POLAR_PBCH_N_MAX;
+    newPolarInitNode->i_il = NR_POLAR_PBCH_I_IL;
+    newPolarInitNode->i_seg = NR_POLAR_PBCH_I_SEG;
+    newPolarInitNode->n_pc = NR_POLAR_PBCH_N_PC;
+    newPolarInitNode->n_pc_wm = NR_POLAR_PBCH_N_PC_WM;
+    newPolarInitNode->i_bil = NR_POLAR_PBCH_I_BIL;
+    newPolarInitNode->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS;
+    newPolarInitNode->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS;
+    newPolarInitNode->encoderLength = NR_POLAR_PBCH_E;
+    newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS;
+    newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P
+    //printf("Initializing polar parameters for PBCH (K %d, E %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength);
+  } else if (messageType == 1) { //DCI
+    newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX;
+    newPolarInitNode->i_il = NR_POLAR_DCI_I_IL;
+    newPolarInitNode->i_seg = NR_POLAR_DCI_I_SEG;
+    newPolarInitNode->n_pc = NR_POLAR_DCI_N_PC;
+    newPolarInitNode->n_pc_wm = NR_POLAR_DCI_N_PC_WM;
+    newPolarInitNode->i_bil = NR_POLAR_DCI_I_BIL;
+    newPolarInitNode->crcParityBits = NR_POLAR_DCI_CRC_PARITY_BITS;
+    newPolarInitNode->payloadBits = messageLength;
+    newPolarInitNode->encoderLength = aggregation_level*108;
+    newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
+    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 == 2) { //UCI PUCCH2
+    AssertFatal(aggregation_level>2,"Aggregation level (%d) for PUCCH 2 encoding is NPRB and should be > 2\n",aggregation_level);
+    AssertFatal(messageLength>11,"Message length %d is too short for polar encoding of UCI\n",messageLength);
+    newPolarInitNode->n_max = NR_POLAR_PUCCH_N_MAX;
+    newPolarInitNode->i_il = NR_POLAR_PUCCH_I_IL;
+    newPolarInitNode->encoderLength = aggregation_level * 16;

-      newPolarInitNode->i_seg = 0;
+    newPolarInitNode->i_seg = 0;
      
-      if ((messageLength >= 360 && newPolarInitNode->encoderLength >= 1088)||
-	  (messageLength >= 1013)) newPolarInitNode->i_seg = 1;
+    if ((messageLength >= 360 && newPolarInitNode->encoderLength >= 1088)||
+        (messageLength >= 1013)) newPolarInitNode->i_seg = 1;

-      newPolarInitNode->crcParityBits = 11;
-      newPolarInitNode->n_pc = 0;
-      newPolarInitNode->n_pc_wm = 0;
+    newPolarInitNode->crcParityBits = 11;
+    newPolarInitNode->n_pc = 0;
+    newPolarInitNode->n_pc_wm = 0;

-      if (messageLength < 20) {
-	newPolarInitNode->crcParityBits = 6;
-	newPolarInitNode->n_pc = 3;
-	if ((newPolarInitNode->encoderLength - messageLength - 6 + 3) < 193) newPolarInitNode->n_pc_wm = 1; 
-      }
-
-
-
-      newPolarInitNode->i_bil = NR_POLAR_PUCCH_I_BIL;
-
-      newPolarInitNode->payloadBits = messageLength;
-      newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS;
-      //newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
-      //LOG_D(PHY,"New polar node, encoderLength %d, aggregation_level %d\n",newPolarInitNode->encoderLength,aggregation_level);
-    } else {
-      AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
+    if (messageLength < 20) {
+      newPolarInitNode->crcParityBits = 6;
+      newPolarInitNode->n_pc = 3;
+      if ((newPolarInitNode->encoderLength - messageLength - 6 + 3) < 193) newPolarInitNode->n_pc_wm = 1; 
    }

-    newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
-    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++)
-      newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i;

-    newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
-    uint16_t *J = malloc(sizeof(uint16_t) * newPolarInitNode->N);
-    nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern,
-                                   J,
-                                   nr_polar_subblock_interleaver_pattern,
-                                   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));
+    newPolarInitNode->i_bil = NR_POLAR_PUCCH_I_BIL;

-    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,
-                              J,
-                              newPolarInitNode->Q_0_Nminus1,
-                              newPolarInitNode->K,
-                              newPolarInitNode->N,
-                              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);
-    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);
-    if (decoder_flag == 1) build_decoder_tree(newPolarInitNode);
-    build_polar_tables(newPolarInitNode);
-    init_polar_deinterleaver_table(newPolarInitNode);
-    //printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes);
+    newPolarInitNode->payloadBits = messageLength;
+    newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS;
+    //newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
+    //LOG_D(PHY,"New polar node, encoderLength %d, aggregation_level %d\n",newPolarInitNode->encoderLength,aggregation_level);
  } else {
-    AssertFatal(1 == 0, "[nr_polar_init] New t_nrPolar_params * could not be created");
+    AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
  }

-  //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;
+  newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
+  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++)
+    newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i;
+
+  newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
+  uint16_t J[newPolarInitNode->N];
+  nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern,
+                                 J,
+                                 nr_polar_subblock_interleaver_pattern,
+                                 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,
+                            J,
+                            newPolarInitNode->Q_0_Nminus1,
+                            newPolarInitNode->K,
+                            newPolarInitNode->N,
+                            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);
+  newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
+  nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern,
+                                       newPolarInitNode->i_bil,
+                                       newPolarInitNode->encoderLength);
+  if (decoder_flag == 1) 
+    build_decoder_tree(newPolarInitNode);
+  build_polar_tables(newPolarInitNode);
+  init_polar_deinterleaver_table(newPolarInitNode);
+  //printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes);
+
+  newPolarInitNode->nextPtr=PolarList;
+  PolarList=newPolarInitNode;
+  return newPolarInitNode;
 }

-void nr_polar_print_polarParams(t_nrPolar_params *polarParams) {
+void nr_polar_print_polarParams() {
  uint8_t i = 0;

-  if (polarParams == NULL) {
+  if (PolarList == NULL) {
    printf("polarParams is empty.\n");
  } else {
+    t_nrPolar_params * polarParams=PolarList;
    while (polarParams != NULL) {
-      printf("polarParams[%d] = %d\n", i, polarParams->idx);
+      printf("polarParams[%d] = %d, %d, %d\n", i,
+             polarParams->idx>>24, (polarParams->idx>>8)&0xFFFF, polarParams->idx&0xFF);
      polarParams = polarParams->nextPtr;
      i++;
    }
@@ -213,31 +271,6 @@ void nr_polar_print_polarParams(t_nrPolar_params *polarParams) {
  return;
 }

-t_nrPolar_params *nr_polar_params (int8_t messageType,
-                                   uint16_t messageLength,
-                                   uint8_t aggregation_level,
-	 		           int decoding_flag,
-				   t_nrPolar_params **polarList_ext) {
-  static t_nrPolar_params *polarList = NULL;
-  nr_polar_init(polarList_ext != NULL ? polarList_ext : &polarList, 
-		messageType,messageLength,aggregation_level,decoding_flag);
-  t_nrPolar_params *polarParams=polarList_ext != NULL ? *polarList_ext : polarList;
-  const int tag=messageType * messageLength * (messageType>=2 ? aggregation_level : nr_polar_aggregation_prime(aggregation_level));
-
-
-	
-  while (polarParams != NULL) {
-    //    LOG_D(PHY,"nr_polar_params : tag %d (from nr_polar_init %d)\n",tag,polarParams->idx);
-    if (polarParams->idx == tag)
-      return polarParams;
-
-    polarParams = polarParams->nextPtr;
-  }
-
-  AssertFatal(false,"Polar Init tables internal failure, no polarParams found\n");
-  return NULL;
-}
-
 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;
@@ -242,37 +242,9 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
  common_vars->debugBuff = (int32_t*)malloc16_clear(fp->samples_per_frame*sizeof(int32_t)*100);	
  common_vars->debugBuff_sample_offset = 0; 

-
-  // Channel estimates for SRS
-/*
-  for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
-    srs_vars[UE_id].srs_ch_estimates      = (int32_t **)malloc16( 64*sizeof(int32_t *) );
-    srs_vars[UE_id].srs_ch_estimates_time = (int32_t **)malloc16( 64*sizeof(int32_t *) );
-
-    for (i=0; i<64; i++) {
-      srs_vars[UE_id].srs_ch_estimates[i]      = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size );
-      srs_vars[UE_id].srs_ch_estimates_time[i] = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
-    }
-  } //UE_id
-*/
-  /*generate_ul_ref_sigs_rx();
-
-  init_ulsch_power_LUT();*/
-
-/*
-  // SRS
-  for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
-    srs_vars[UE_id].srs = (int32_t *)malloc16_clear(2*fp->ofdm_symbol_size*sizeof(int32_t));
-  }
-*/
  // PRACH
  prach_vars->prachF = (int16_t *)malloc16_clear( 1024*2*sizeof(int16_t) );
  prach_vars->rxsigF = (int16_t **)malloc16_clear(Prx*sizeof(int16_t*));
-  /* 
-  for (i=0;i<Prx;i++){
-    prach_vars->rxsigF[i] = (int16_t *)malloc16_clear( 1024*2*sizeof(int16_t) );
-  }
-  */
  prach_vars->prach_ifft       = (int32_t *)malloc16_clear(1024*2*sizeof(int32_t));

  init_prach_list(gNB);
@@ -328,51 +300,102 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
 void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
 {
  NR_DL_FRAME_PARMS* const fp       = &gNB->frame_parms;
-  NR_gNB_COMMON *const common_vars  = &gNB->common_vars;
-  NR_gNB_PUSCH **const pusch_vars   = gNB->pusch_vars;
-  /*LTE_eNB_SRS *const srs_vars        = gNB->srs_vars;
-  LTE_eNB_PRACH *const prach_vars    = &gNB->prach_vars;*/
-  uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
-  int Ptx=gNB->gNB_config.carrier_config.num_tx_ant.value;
+  const int Ptx = gNB->gNB_config.carrier_config.num_tx_ant.value;
+  const int Prx = gNB->gNB_config.carrier_config.num_rx_ant.value;
+  const int max_ul_mimo_layers = 4; // taken from phy_init_nr_gNB()
+  const int n_buf = Prx * max_ul_mimo_layers;

+  uint32_t ***pdcch_dmrs = gNB->nr_gold_pdcch_dmrs;
+  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+    for (int symb = 0; symb < fp->symbols_per_slot; symb++)
+      free_and_zero(pdcch_dmrs[slot][symb]);
+    free_and_zero(pdcch_dmrs[slot]);
+  }
+  free_and_zero(pdcch_dmrs);
+
+  uint32_t ****pdsch_dmrs = gNB->nr_gold_pdsch_dmrs;
+  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+    for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
+      for (int q = 0; q < NR_MAX_NB_CODEWORDS; q++)
+        free_and_zero(pdsch_dmrs[slot][symb][q]);
+      free_and_zero(pdsch_dmrs[slot][symb]);
+    }
+    free_and_zero(pdsch_dmrs[slot]);
+  }
+  free_and_zero(gNB->nr_gold_pdsch_dmrs);
+
+  uint32_t ****pusch_dmrs = gNB->nr_gold_pusch_dmrs;
+  for(int nscid = 0; nscid < 2; nscid++) {
+    for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+      for (int symb = 0; symb < fp->symbols_per_slot; symb++)
+        free_and_zero(pusch_dmrs[nscid][slot][symb]);
+      free_and_zero(pusch_dmrs[nscid][slot]);
+    }
+    free_and_zero(pusch_dmrs[nscid]);
+  }
+  free_and_zero(pusch_dmrs);
+
+  uint32_t ***csi_rs = gNB->nr_gold_csi_rs;
+  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+    for (int symb = 0; symb < fp->symbols_per_slot; symb++)
+      free_and_zero(csi_rs[slot][symb]);
+    free_and_zero(csi_rs[slot]);
+  }
+  free_and_zero(csi_rs);
+
+  for (int id = 0; id < NUMBER_OF_NR_SRS_MAX; id++) {
+    for (int i = 0; i < Prx; i++){
+      free_and_zero(gNB->nr_srs_info[id]->srs_received_signal[i]);
+      free_and_zero(gNB->nr_srs_info[id]->srs_ls_estimated_channel[i]);
+      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_freq[i]);
+      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time[i]);
+      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i]);
+    }
+    free_and_zero(gNB->nr_srs_info[id]->srs_generated_signal);
+    free_and_zero(gNB->nr_srs_info[id]->noise_power);
+    free_and_zero(gNB->nr_srs_info[id]->srs_received_signal);
+    free_and_zero(gNB->nr_srs_info[id]->srs_ls_estimated_channel);
+    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_freq);
+    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time);
+    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted);
+    free_and_zero(gNB->nr_srs_info[id]);
+  }
+
+  free_ul_reference_signal_sequences();
+  free_gnb_lowpapr_sequences();
+
+  reset_nr_transport(gNB);
+
+  NR_gNB_COMMON * common_vars = &gNB->common_vars;
  for (int i = 0; i < Ptx; i++) {
    free_and_zero(common_vars->txdataF[i]);
-    /* rxdataF[i] is not allocated -> don't free */
+    free_and_zero(common_vars->beam_id[i]);
+  }
+
+  for (int i = 0; i < Prx; ++i) {
+    free_and_zero(common_vars->rxdataF[i]);
+    free_and_zero(common_vars->rxdata[i]);
  }

  free_and_zero(common_vars->txdataF);
+  free_and_zero(common_vars->rxdata);
  free_and_zero(common_vars->rxdataF);
-  // PDCCH DMRS sequences
-  free_and_zero(pdcch_dmrs);
-/*
-  // Channel estimates for SRS
-  for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) {
-    for (i=0; i<64; i++) {
-      free_and_zero(srs_vars[UE_id].srs_ch_estimates[i]);
-      free_and_zero(srs_vars[UE_id].srs_ch_estimates_time[i]);
-    }
+  free_and_zero(common_vars->beam_id);

-    free_and_zero(srs_vars[UE_id].srs_ch_estimates);
-    free_and_zero(srs_vars[UE_id].srs_ch_estimates_time);
-  } //UE_id
-
-  //free_ul_ref_sigs();
-
-  for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) free_and_zero(srs_vars[UE_id].srs);
+  free_and_zero(common_vars->debugBuff);

+  NR_gNB_PRACH* prach_vars = &gNB->prach_vars;
  free_and_zero(prach_vars->prachF);
+  free_and_zero(prach_vars->rxsigF);
+  free_and_zero(prach_vars->prach_ifft);

-  for (i = 0; i < 64; i++) free_and_zero(prach_vars->prach_ifft[0][i]);
-
-  free_and_zero(prach_vars->prach_ifft[0]);
-  free_and_zero(prach_vars->rxsigF[0]);
-*/
+  NR_gNB_PUSCH** pusch_vars = gNB->pusch_vars;
  for (int ULSCH_id=0; ULSCH_id<gNB->number_of_nr_ulsch_max; ULSCH_id++) {
-    for (int i = 0; i < fp->nb_antennas_rx; i++) {
+    for (int i = 0; i < Prx; i++) {
      free_and_zero(pusch_vars[ULSCH_id]->rxdataF_ext[i]);
      free_and_zero(pusch_vars[ULSCH_id]->rxdataF_ext2[i]);
    }
-    for (int i = 0; i < 4*fp->nb_antennas_rx; i++) {
+    for (int i = 0; i < n_buf; i++) {
      free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates[i]);
      free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates_ext[i]);
      free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates_time[i]);
@@ -392,8 +415,8 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates_ext);
    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_ptrs_estimates);
    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_ptrs_estimates_ext);
-    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates_time);
    free_and_zero(pusch_vars[ULSCH_id]->ptrs_phase_per_slot);
+    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_estimates_time);
    free_and_zero(pusch_vars[ULSCH_id]->ul_valid_re_per_slot);
    free_and_zero(pusch_vars[ULSCH_id]->rxdataF_comp);
    free_and_zero(pusch_vars[ULSCH_id]->ul_ch_mag0);
@@ -405,14 +428,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
    free_and_zero(pusch_vars[ULSCH_id]->llr);
    free_and_zero(pusch_vars[ULSCH_id]);
  } //ULSCH_id
-/*
-  for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) gNB->UE_stats_ptr[UE_id] = NULL;
-*/
-
-
-  free_gnb_lowpapr_sequences();
-
-
 }

 //Adding nr_schedule_handler
@@ -553,6 +568,16 @@ void init_DLSCH_struct(PHY_VARS_gNB *gNB, processingData_L1tx_t *msg) {
  }
 }

+void reset_DLSCH_struct(const PHY_VARS_gNB *gNB, processingData_L1tx_t *msg)
+{
+  const NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  const nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
+  const uint16_t grid_size = cfg->carrier_config.dl_grid_size[fp->numerology_index].value;
+  for (int i=0; i<gNB->number_of_nr_dlsch_max; i++)
+    for (int j=0; j<2; j++)
+      free_gNB_dlsch(&msg->dlsch[i][j], grid_size);
+}
+
 void init_nr_transport(PHY_VARS_gNB *gNB) {
  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
  LOG_I(PHY, "Initialise nr transport\n");
@@ -577,7 +602,7 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {

    for (int j=0; j<2; j++) {
      // ULSCH for data
-      gNB->ulsch[i][j] = new_gNB_ulsch(MAX_LDPC_ITERATIONS, fp->N_RB_UL, 0);
+      gNB->ulsch[i][j] = new_gNB_ulsch(MAX_LDPC_ITERATIONS, fp->N_RB_UL);

      if (!gNB->ulsch[i][j]) {
        LOG_E(PHY,"Can't get gNB ulsch structures\n");
@@ -593,3 +618,18 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {

  //fp->pucch_config_common.deltaPUCCH_Shift = 1;
 }
+
+void reset_nr_transport(PHY_VARS_gNB *gNB)
+{
+  const NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+
+  for (int i = 0; i < NUMBER_OF_NR_PUCCH_MAX; i++)
+    free_gNB_pucch(gNB->pucch[i]);
+
+  for (int i = 0; i < NUMBER_OF_NR_SRS_MAX; i++)
+    free_gNB_srs(gNB->srs[i]);
+
+  for (int i=0; i<gNB->number_of_nr_ulsch_max; i++)
+    for (int j=0; j<2; j++)
+      free_gNB_ulsch(&gNB->ulsch[i][j], fp->N_RB_UL);
+}
@@ -174,17 +174,13 @@ void nr_phy_free_RU(RU_t *ru)

  LOG_I(PHY, "Feeing RU signal buffers (if_south %s) nb_tx %d\n", ru_if_types[ru->if_south], ru->nb_tx);

-  free_and_zero(ru->nr_frame_parms);
-  free_and_zero(ru->frame_parms);
-
  if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so free memory for time-domain signals
-    int32_t *ptr;
-    for (i = 0; i < ru->nb_tx; i++) {
-      ptr=&ru->common.txdata[i][-ru->sf_extension];
-      free_and_zero(ptr);
-    }
-    for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdata[i]);
+    for (i = 0; i < ru->nb_tx; i++)
+      free_and_zero(ru->common.txdata[i]);
    free_and_zero(ru->common.txdata);
+
+    for (i = 0; i < ru->nb_rx; i++)
+      free_and_zero(ru->common.rxdata[i]);
    free_and_zero(ru->common.rxdata);
  } // else: IF5 or local RF -> nothing to free()

@@ -193,7 +189,7 @@ void nr_phy_free_RU(RU_t *ru)
    free_and_zero(ru->common.rxdata_7_5kHz);

    // free beamforming input buffers (TX)
-    for (i = 0; i < 15; i++) free_and_zero(ru->common.txdataF[i]);
+    for (i = 0; i < ru->nb_tx; i++) free_and_zero(ru->common.txdataF[i]);
    free_and_zero(ru->common.txdataF);

    // free IFFT input buffers (TX)
@@ -205,15 +201,21 @@ void nr_phy_free_RU(RU_t *ru)
    free_and_zero(ru->common.rxdataF);

    for (j=0;j<NUMBER_OF_NR_RU_PRACH_OCCASIONS_MAX;j++) {
-      for (i = 0; i < ru->nb_rx; i++) {
+      for (i = 0; i < ru->nb_rx; i++)
 	free_and_zero(ru->prach_rxsigF[j][i]);
-      }
+      free_and_zero(ru->prach_rxsigF[j]);
    }
-    for (i = 0; i < ru->num_gNB; i++) {
-      for (p = 0; p < 15; p++) {
-	  for (j=0; j<ru->nb_tx; j++) free_and_zero(ru->beam_weights[i][p][j]);
-	  free_and_zero(ru->beam_weights[i][p]);
+
+    if (ru->do_precoding == 1) {
+      for (i = 0; i < ru->num_gNB; i++) {
+        for (p = 0; p < ru->nb_log_antennas; p++) {
+            for (j=0; j<ru->nb_tx; j++) free_and_zero(ru->beam_weights[i][p][j]);
+            free_and_zero(ru->beam_weights[i][p]);
+        }
      }
+      for(i=0; i< ru->nb_tx; ++i)
+        free_and_zero(ru->common.beam_id[i]);
+      free_and_zero(ru->common.beam_id);
    }
  }
  free_and_zero(ru->common.sync_corr);
@@ -111,6 +111,49 @@ void phy_init_nr_ue__PDSCH(NR_UE_PDSCH *const pdsch,
  }
 }

+void phy_term_nr_ue__PDSCH(NR_UE_PDSCH* pdsch, const NR_DL_FRAME_PARMS *const fp)
+{
+  for (int i = 0; i < fp->nb_antennas_rx; i++) {
+    for (int j = 0; j < NR_MAX_NB_LAYERS; j++) {
+      const int idx = j * fp->nb_antennas_rx + i;
+      for (int k = 0; k < NR_MAX_NB_LAYERS; k++)
+        free_and_zero(pdsch->rho[i][j*NR_MAX_NB_LAYERS+k]);
+      free_and_zero(pdsch->rxdataF_comp0[idx]);
+      free_and_zero(pdsch->dl_ch_estimates[idx]);
+      free_and_zero(pdsch->dl_ch_estimates_ext[idx]);
+      free_and_zero(pdsch->dl_bf_ch_estimates[idx]);
+      free_and_zero(pdsch->dl_bf_ch_estimates_ext[idx]);
+      free_and_zero(pdsch->dl_ch_mag0[idx]);
+      free_and_zero(pdsch->dl_ch_magb0[idx]);
+      free_and_zero(pdsch->dl_ch_magr0[idx]);
+    }
+    free_and_zero(pdsch->rxdataF_ext[i]);
+    free_and_zero(pdsch->rxdataF_uespec_pilots[i]);
+    free_and_zero(pdsch->ptrs_phase_per_slot[i]);
+    free_and_zero(pdsch->ptrs_re_per_slot[i]);
+    free_and_zero(pdsch->dl_ch_ptrs_estimates_ext[i]);
+    free_and_zero(pdsch->rho[i]);
+  }
+  free_and_zero(pdsch->pmi_ext);
+  free_and_zero(pdsch->llr[0]);
+  free_and_zero(pdsch->layer_llr[0]);
+  free_and_zero(pdsch->llr128);
+  free_and_zero(pdsch->rxdataF_ext);
+  free_and_zero(pdsch->rxdataF_uespec_pilots);
+  free_and_zero(pdsch->rxdataF_comp0);
+  free_and_zero(pdsch->rho);
+  free_and_zero(pdsch->dl_ch_estimates);
+  free_and_zero(pdsch->dl_ch_estimates_ext);
+  free_and_zero(pdsch->dl_bf_ch_estimates);
+  free_and_zero(pdsch->dl_bf_ch_estimates_ext);
+  free_and_zero(pdsch->dl_ch_mag0);
+  free_and_zero(pdsch->dl_ch_magb0);
+  free_and_zero(pdsch->dl_ch_magr0);
+  free_and_zero(pdsch->ptrs_phase_per_slot);
+  free_and_zero(pdsch->ptrs_re_per_slot);
+  free_and_zero(pdsch->dl_ch_ptrs_estimates_ext);
+}
+
 void phy_init_nr_ue_PUSCH(NR_UE_PUSCH *const pusch,
                          const NR_DL_FRAME_PARMS *const fp) {
  AssertFatal( pusch, "pusch==0" );
@@ -120,9 +163,14 @@ void phy_init_nr_ue_PUSCH(NR_UE_PUSCH *const pusch,
  }
 }

-int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
-                      int nb_connected_gNB,
-                      uint8_t abstraction_flag) {
+void phy_term_nr_ue_PUSCH(NR_UE_PUSCH *pusch)
+{
+  for (int i = 0; i < NR_MAX_NB_LAYERS; i++)
+    free_and_zero(pusch->txdataF_layers[i]);
+}
+
+int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
+{
  // create shortcuts
  NR_DL_FRAME_PARMS *const fp            = &ue->frame_parms;
  NR_UE_COMMON *const common_vars        = &ue->common_vars;
@@ -134,10 +182,7 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
  int gNB_id;
  int th_id;
  uint32_t ****pusch_dmrs;
-  uint16_t N_n_scid[2] = {0,1}; // [HOTFIX] This is a temporary implementation of scramblingID0 and scramblingID1 which are given by DMRS-UplinkConfig
-  int n_scid;
-  abstraction_flag = 0;
-  LOG_I(PHY, "Initializing UE vars (abstraction %u) for gNB TXant %u, UE RXant %u\n", abstraction_flag, fp->nb_antennas_tx, fp->nb_antennas_rx);
+  LOG_I(PHY, "Initializing UE vars for gNB TXant %u, UE RXant %u\n", fp->nb_antennas_tx, fp->nb_antennas_rx);
  phy_init_nr_top(ue);
  // many memory allocation sizes are hard coded
  AssertFatal( fp->nb_antennas_rx <= 4, "hard coded allocation for ue_common_vars->dl_ch_estimates[gNB_id]" );
@@ -191,7 +236,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
  ///////////
  ue->nr_gold_pusch_dmrs = (uint32_t ****)malloc16(fp->slots_per_frame*sizeof(uint32_t ***));
  pusch_dmrs             = ue->nr_gold_pusch_dmrs;
-  n_scid = 0; // This quantity is indicated by higher layer parameter dmrs-SeqInitialization

  for (slot=0; slot<fp->slots_per_frame; slot++) {
    pusch_dmrs[slot] = (uint32_t ***)malloc16(fp->symbols_per_slot*sizeof(uint32_t **));
@@ -208,7 +252,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
    }
  }

-  nr_init_pusch_dmrs(ue, N_n_scid, n_scid);
  ///////////
  ////////////////////////////////////////////////////////////////////////////////////////////

@@ -230,29 +273,27 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
  for (i=0; i<10; i++)
    ue->tx_power_dBm[i]=-127;

-  if (abstraction_flag == 0) {
-    // init TX buffers
-    common_vars->txdata  = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t *) );
-    common_vars->txdataF = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t *) );
+  // init TX buffers
+  common_vars->txdata  = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t *) );
+  common_vars->txdataF = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t *) );

-    for (i=0; i<fp->nb_antennas_tx; i++) {
-      common_vars->txdata[i]  = (int32_t *)malloc16_clear( fp->samples_per_subframe*10*sizeof(int32_t) );
-      common_vars->txdataF[i] = (int32_t *)malloc16_clear( fp->samples_per_slot_wCP*sizeof(int32_t) );
-    }
+  for (i=0; i<fp->nb_antennas_tx; i++) {
+    common_vars->txdata[i]  = (int32_t *)malloc16_clear( fp->samples_per_subframe*10*sizeof(int32_t) );
+    common_vars->txdataF[i] = (int32_t *)malloc16_clear( fp->samples_per_slot_wCP*sizeof(int32_t) );
+  }

-    // init RX buffers
-    common_vars->rxdata   = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
+  // init RX buffers
+  common_vars->rxdata   = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
+
+  for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+    common_vars->common_vars_rx_data_per_thread[th_id].rxdataF  = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
+  }
+
+  for (i=0; i<fp->nb_antennas_rx; i++) {
+    common_vars->rxdata[i] = (int32_t *) malloc16_clear( (2*(fp->samples_per_frame)+2048)*sizeof(int32_t) );

    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-      common_vars->common_vars_rx_data_per_thread[th_id].rxdataF  = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
-    }
-
-    for (i=0; i<fp->nb_antennas_rx; i++) {
-      common_vars->rxdata[i] = (int32_t *) malloc16_clear( (2*(fp->samples_per_frame)+2048)*sizeof(int32_t) );
-
-      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        common_vars->common_vars_rx_data_per_thread[th_id].rxdataF[i] = (int32_t *)malloc16_clear( sizeof(int32_t)*(fp->samples_per_slot_wCP) );
-      }
+      common_vars->common_vars_rx_data_per_thread[th_id].rxdataF[i] = (int32_t *)malloc16_clear( sizeof(int32_t)*(fp->samples_per_slot_wCP) );
    }
  }

@@ -271,9 +312,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
    }
  }

-  ue->scramblingID_pdcch = fp->Nid_cell;
-  nr_gold_pdcch(ue,fp->Nid_cell);
-
  //PDSCH DMRS init (eNB offset = 0)
  ue->nr_gold_pdsch[0] = (uint32_t ****)malloc16(fp->slots_per_frame*sizeof(uint32_t ***));
  uint32_t ****pdsch_dmrs = ue->nr_gold_pdsch[0];
@@ -293,12 +331,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
    }
  }

-  // initializing the scrambling IDs for PDSCH DMRS
-  for (int i=0; i<2; i++)
-    ue->scramblingID[i]=fp->Nid_cell;
-
-  nr_gold_pdsch(ue,ue->scramblingID);
-
  // DLSCH
  for (gNB_id = 0; gNB_id < ue->n_connected_gNB; gNB_id++) {
    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
@@ -330,129 +362,119 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
      ue->nr_srs_info->srs_estimated_channel_time_shifted[i] = (int32_t *) malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
    }

-    if (abstraction_flag == 0) {
-      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        phy_init_nr_ue__PDSCH( ue->pdsch_vars[th_id][gNB_id], fp );
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      phy_init_nr_ue__PDSCH( ue->pdsch_vars[th_id][gNB_id], fp );
+    }
+
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      ue->pdsch_vars[th_id][gNB_id]->llr_shifts          = (uint8_t *)malloc16_clear(7*2*fp->N_RB_DL*12);
+      ue->pdsch_vars[th_id][gNB_id]->llr_shifts_p        = ue->pdsch_vars[0][gNB_id]->llr_shifts;
+      ue->pdsch_vars[th_id][gNB_id]->llr[1]              = (int16_t *)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
+      ue->pdsch_vars[th_id][gNB_id]->layer_llr[1]        = (int16_t *)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
+      ue->pdsch_vars[th_id][gNB_id]->llr128_2ndstream    = (int16_t **)malloc16_clear( sizeof(int16_t *) );
+    }
+
+
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext      = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+    }
+
+    for (i=0; i<fp->nb_antennas_rx; i++)
+      for (j=0; j<4; j++) {
+        const int idx = (j*fp->nb_antennas_rx)+i;
+        const size_t num = 7*2*fp->N_RB_DL*12+4;
+
+        for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+          ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext[idx] = (int32_t *)malloc16_clear( sizeof(int32_t) * num );
+        }
      }

-      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        ue->pdsch_vars[th_id][gNB_id]->llr_shifts          = (uint8_t *)malloc16_clear(7*2*fp->N_RB_DL*12);
-        ue->pdsch_vars[th_id][gNB_id]->llr_shifts_p        = ue->pdsch_vars[0][gNB_id]->llr_shifts;
-        ue->pdsch_vars[th_id][gNB_id]->llr[1]              = (int16_t *)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
-        ue->pdsch_vars[th_id][gNB_id]->layer_llr[1]        = (int16_t *)malloc16_clear( (8*(3*8*8448))*sizeof(int16_t) );
-        ue->pdsch_vars[th_id][gNB_id]->llr128_2ndstream    = (int16_t **)malloc16_clear( sizeof(int16_t *) );
-      }
-
-
-      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext      = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      }
-
-      for (i=0; i<fp->nb_antennas_rx; i++)
-        for (j=0; j<4; j++) {
-          const int idx = (j*fp->nb_antennas_rx)+i;
-          const size_t num = 7*2*fp->N_RB_DL*12+4;
-
-          for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-            ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext[idx] = (int32_t *)malloc16_clear( sizeof(int32_t) * num );
-          }
+    //const size_t num = 7*2*fp->N_RB_DL*12+4;
+    for (k=0; k<8; k++) { //harq_pid
+      for (l=0; l<8; l++) { //round
+        for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+          ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l] = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+          ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l] = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+          ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l]    = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+          ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l]   = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
        }

-      //const size_t num = 7*2*fp->N_RB_DL*12+4;
-      for (k=0; k<8; k++) { //harq_pid
-        for (l=0; l<8; l++) { //round
-          for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-            ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l] = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-            ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l] = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-            ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l]    = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-            ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l]   = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-          }
+        for (int i=0; i<fp->nb_antennas_rx; i++)
+          for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
+            const int idx = (j*fp->nb_antennas_rx)+i;

-          for (int i=0; i<fp->nb_antennas_rx; i++)
-            for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
-              const int idx = (j*fp->nb_antennas_rx)+i;
-
-              for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-                ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
-                ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l][idx] = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
-                ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l][idx]    = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
-                ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l][idx]   = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
-              }
+            for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+              ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
+              ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l][idx] = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
+              ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l][idx]    = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
+              ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l][idx]   = (int32_t *)malloc16_clear(7*2*sizeof(int32_t)*(fp->N_RB_DL*12));
            }
-        }
-      }
-
-      // 100 PRBs * 12 REs/PRB * 4 PDCCH SYMBOLS * 2 LLRs/RE
-      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-        ue->pdcch_vars[th_id][gNB_id]->llr                 = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
-        ue->pdcch_vars[th_id][gNB_id]->llr16               = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
-        ue->pdcch_vars[th_id][gNB_id]->wbar                = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
-        ue->pdcch_vars[th_id][gNB_id]->e_rx                = (int16_t *)malloc16_clear( 4*2*100*12 );
-        ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp        = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-        ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext       = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-        ue->pdcch_vars[th_id][gNB_id]->rho                 = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
-        ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext         = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-        ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-        // Channel estimates
-        ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates      = (int32_t **)malloc16_clear(4*fp->nb_antennas_rx*sizeof(int32_t *));
-        ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time = (int32_t **)malloc16_clear(4*fp->nb_antennas_rx*sizeof(int32_t *));
-
-        for (i=0; i<fp->nb_antennas_rx; i++) {
-          ue->pdcch_vars[th_id][gNB_id]->rho[i] = (int32_t *)malloc16_clear( sizeof(int32_t)*(100*12*4));
-
-          for (j=0; j<4; j++) {
-            int idx = (j*fp->nb_antennas_rx)+i;
-            ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->symbols_per_slot*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
-            ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
-            //  size_t num = 7*2*fp->N_RB_DL*12;
-            size_t num = 4*273*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
-            ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp[idx]        = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
-            ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext[idx]       = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
-            ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext[idx]         = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
-            ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext[idx] = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
          }
-        }
      }
+    }

-      // PBCH
-      pbch_vars[gNB_id]->rxdataF_ext         = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->rxdataF_comp        = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates     = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates_ext = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->dl_ch_estimates_time = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
-      pbch_vars[gNB_id]->llr                 = (int16_t *)malloc16_clear( 1920 ); //
-      prach_vars[gNB_id]->prachF             = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
-      prach_vars[gNB_id]->prach              = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+    // 100 PRBs * 12 REs/PRB * 4 PDCCH SYMBOLS * 2 LLRs/RE
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      ue->pdcch_vars[th_id][gNB_id]->llr                 = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      ue->pdcch_vars[th_id][gNB_id]->llr16               = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      ue->pdcch_vars[th_id][gNB_id]->wbar                = (int16_t *)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      ue->pdcch_vars[th_id][gNB_id]->e_rx                = (int16_t *)malloc16_clear( 4*2*100*12 );
+      ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp        = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+      ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext       = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+      ue->pdcch_vars[th_id][gNB_id]->rho                 = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
+      ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext         = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+      ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+      // Channel estimates
+      ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates      = (int32_t **)malloc16_clear(4*fp->nb_antennas_rx*sizeof(int32_t *));
+      ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time = (int32_t **)malloc16_clear(4*fp->nb_antennas_rx*sizeof(int32_t *));

      for (i=0; i<fp->nb_antennas_rx; i++) {
-        pbch_vars[gNB_id]->rxdataF_ext[i]    = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
+        ue->pdcch_vars[th_id][gNB_id]->rho[i] = (int32_t *)malloc16_clear( sizeof(int32_t)*(100*12*4));

-        for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
+        for (j=0; j<4; j++) {
          int idx = (j*fp->nb_antennas_rx)+i;
-          pbch_vars[gNB_id]->rxdataF_comp[idx]        = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
-          pbch_vars[gNB_id]->dl_ch_estimates[idx]     = (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
-          pbch_vars[gNB_id]->dl_ch_estimates_time[idx]= (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
-          pbch_vars[gNB_id]->dl_ch_estimates_ext[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
+          ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->symbols_per_slot*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
+          ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+          //  size_t num = 7*2*fp->N_RB_DL*12;
+          size_t num = 4*273*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
+          ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp[idx]        = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
+          ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext[idx]       = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
+          ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext[idx]         = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
+          ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext[idx] = (int32_t *)malloc16_clear(sizeof(int32_t) * num);
        }
      }
    }

+    // PBCH
+    pbch_vars[gNB_id]->rxdataF_ext         = (int32_t **)malloc16( fp->nb_antennas_rx*sizeof(int32_t *) );
+    pbch_vars[gNB_id]->rxdataF_comp        = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+    pbch_vars[gNB_id]->dl_ch_estimates     = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+    pbch_vars[gNB_id]->dl_ch_estimates_ext = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+    pbch_vars[gNB_id]->dl_ch_estimates_time = (int32_t **)malloc16_clear( 4*fp->nb_antennas_rx*sizeof(int32_t *) );
+    pbch_vars[gNB_id]->llr                 = (int16_t *)malloc16_clear( 1920 ); //
+    prach_vars[gNB_id]->prachF             = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+    prach_vars[gNB_id]->prach              = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      pbch_vars[gNB_id]->rxdataF_ext[i]    = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
+
+      for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
+        int idx = (j*fp->nb_antennas_rx)+i;
+        pbch_vars[gNB_id]->rxdataF_comp[idx]        = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
+        pbch_vars[gNB_id]->dl_ch_estimates[idx]     = (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
+        pbch_vars[gNB_id]->dl_ch_estimates_time[idx]= (int32_t *)malloc16_clear( sizeof(int32_t)*7*2*sizeof(int)*(fp->ofdm_symbol_size) );
+        pbch_vars[gNB_id]->dl_ch_estimates_ext[idx] = (int32_t *)malloc16_clear( sizeof(int32_t)*20*12*4 );
+      }
+    }
+
    pbch_vars[gNB_id]->decoded_output = (uint8_t *)malloc16_clear(64);
  }

  // initialization for the last instance of pdsch_vars (used for MU-MIMO)
  for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-    ue->pdsch_vars[th_id][gNB_id] = (NR_UE_PDSCH *)malloc16_clear(sizeof(NR_UE_PDSCH));
-  }
-
-  if (abstraction_flag == 0) {
-    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
-      //phy_init_lte_ue__PDSCH( ue->pdsch_vars[th_id][gNB_id], fp );
-      ue->pdsch_vars[th_id][gNB_id]->llr[1] = (int16_t *)malloc16_clear((8*(3*8*8448))*sizeof(int16_t));
-      ue->pdsch_vars[th_id][gNB_id]->layer_llr[1] = (int16_t *)malloc16_clear((8*(3*8*8448))*sizeof(int16_t));
-    }
-  } else { //abstraction == 1
-    ue->sinr_dB = (double *) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
+    ue->pdsch_vars[th_id][gNB_id] = malloc16_clear(sizeof(NR_UE_PDSCH));
+    ue->pdsch_vars[th_id][gNB_id]->llr[1] = malloc16_clear((8*(3*8*8448))*sizeof(int16_t));
+    ue->pdsch_vars[th_id][gNB_id]->layer_llr[1] = malloc16_clear((8*(3*8*8448))*sizeof(int16_t));
  }

  ue->sinr_CQI_dB = (double *) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
@@ -473,25 +495,224 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
  return 0;
 }

-void init_nr_ue_transport(PHY_VARS_NR_UE *ue,
-                          int abstraction_flag) {
+void term_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
+{
+  const NR_DL_FRAME_PARMS* fp = &ue->frame_parms;
+  phy_term_nr_top();
+
+  for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++) {
+    for (int gNB_id = 0; gNB_id < ue->n_connected_gNB; gNB_id++) {
+      phy_term_nr_ue_PUSCH(ue->pusch_vars[th_id][gNB_id]);
+      free_and_zero(ue->pusch_vars[th_id][gNB_id]);
+      free_and_zero(ue->pucch_vars[th_id][gNB_id]);
+    }
+  }
+
+  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+    for (int symb = 0; symb < fp->symbols_per_slot; symb++) {
+      for (int q = 0; q < NR_MAX_NB_CODEWORDS; q++)
+        free_and_zero(ue->nr_gold_pusch_dmrs[slot][symb][q]);
+      free_and_zero(ue->nr_gold_pusch_dmrs[slot][symb]);
+    }
+    free_and_zero(ue->nr_gold_pusch_dmrs[slot]);
+  }
+  free_and_zero(ue->nr_gold_pusch_dmrs);
+
+  NR_UE_COMMON* common_vars = &ue->common_vars;
+
+  for (int i = 0; i < fp->nb_antennas_tx; i++) {
+    free_and_zero(common_vars->txdata[i]);
+    free_and_zero(common_vars->txdataF[i]);
+  }
+
+  free_and_zero(common_vars->txdata);
+  free_and_zero(common_vars->txdataF);
+
+  for (int i = 0; i < fp->nb_antennas_rx; i++) {
+    free_and_zero(common_vars->rxdata[i]);
+    for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++)
+      free_and_zero(common_vars->common_vars_rx_data_per_thread[th_id].rxdataF[i]);
+  }
+  for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++) {
+    free_and_zero(common_vars->common_vars_rx_data_per_thread[th_id].rxdataF);
+  }
+  free_and_zero(common_vars->rxdata);
+
+  for (int slot = 0; slot < fp->slots_per_frame; slot++) {
+    for (int symb = 0; symb < fp->symbols_per_slot; symb++)
+      free_and_zero(ue->nr_gold_pdcch[0][slot][symb]);
+    free_and_zero(ue->nr_gold_pdcch[0][slot]);
+  }
+  free_and_zero(ue->nr_gold_pdcch[0]);
+
+  for (int slot=0; slot<fp->slots_per_frame; slot++) {
+    for (int symb=0; symb<fp->symbols_per_slot; symb++) {
+      for (int q=0; q<NR_MAX_NB_CODEWORDS; q++) 
+        free_and_zero(ue->nr_gold_pdsch[0][slot][symb][q]);
+      free_and_zero(ue->nr_gold_pdsch[0][slot][symb]);
+    }
+    free_and_zero(ue->nr_gold_pdsch[0][slot]);
+  }
+  free_and_zero(ue->nr_gold_pdsch[0]);
+
+  for (int gNB_id = 0; gNB_id < ue->n_connected_gNB; gNB_id++) {
+
+    // PDSCH
+    for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++) {
+      for (int k = 0; k < 8; k++) { //harq_pid
+        for (int l = 0; l < 8; l++) { //round
+          for (int i = 0; i < fp->nb_antennas_rx; i++) {
+            for (int j = 0; j < 4; j++) { //frame_parms->nb_antennas_tx; j++)
+              const int idx = j * fp->nb_antennas_rx + i;
+              free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l][idx]);
+              free_and_zero(ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l][idx]);
+              free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l][idx]);
+              free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l][idx]);
+            }
+          }
+
+          free_and_zero(ue->pdsch_vars[th_id][gNB_id]->rxdataF_comp1[k][l]);
+          free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho_ext[k][l]);
+          free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_mag1[k][l]);
+          free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_magb1[k][l]);
+        }
+      }
+
+      for (int i = 0; i < fp->nb_antennas_rx; i++) {
+        for (int j = 0; j < 4; j++) {
+          const int idx = (j*fp->nb_antennas_rx)+i;
+          free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext[idx]);
+        }
+      }
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]->llr_shifts);
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]->llr[1]);
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]->layer_llr[1]);
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]->llr128_2ndstream);
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]->dl_ch_rho2_ext);
+
+      phy_term_nr_ue__PDSCH(ue->pdsch_vars[th_id][gNB_id], fp);
+      free_and_zero(ue->pdsch_vars[th_id][gNB_id]);
+    }
+
+    for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++) {
+      for (int i = 0; i < fp->nb_antennas_rx; i++) {
+        for (int j = 0; j < 4; j++) {
+          int idx = j * fp->nb_antennas_rx + i;
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates[idx]);
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time[idx]);
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp[idx]);
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext[idx]);
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext[idx]);
+          free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext[idx]);
+        }
+        free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rho[i]);
+      }
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->llr);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->llr16);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->wbar);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->e_rx);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rxdataF_comp);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_rho_ext);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rho);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->rxdataF_ext);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_ext);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates);
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]->dl_ch_estimates_time);
+
+      free_and_zero(ue->pdcch_vars[th_id][gNB_id]);
+    }
+
+    for (int i = 0; i < fp->nb_antennas_rx; i++) {
+      free_and_zero(ue->nr_srs_info->srs_received_signal[i]);
+      free_and_zero(ue->nr_srs_info->srs_ls_estimated_channel[i]);
+      free_and_zero(ue->nr_srs_info->srs_estimated_channel_freq[i]);
+      free_and_zero(ue->nr_srs_info->srs_estimated_channel_time[i]);
+      free_and_zero(ue->nr_srs_info->srs_estimated_channel_time_shifted[i]);
+    }
+    free_and_zero(ue->nr_srs_info->srs_generated_signal);
+    free_and_zero(ue->nr_srs_info->noise_power);
+    free_and_zero(ue->nr_srs_info->srs_received_signal);
+    free_and_zero(ue->nr_srs_info->srs_ls_estimated_channel);
+    free_and_zero(ue->nr_srs_info->srs_estimated_channel_freq);
+    free_and_zero(ue->nr_srs_info->srs_estimated_channel_time);
+    free_and_zero(ue->nr_srs_info->srs_estimated_channel_time_shifted);
+    free_and_zero(ue->nr_srs_info);
+
+    free_and_zero(ue->srs_vars[gNB_id]);
+
+    for (int i = 0; i < fp->nb_antennas_rx; i++) {
+      free_and_zero(ue->pbch_vars[gNB_id]->rxdataF_ext[i]);
+
+      for (int j = 0; j < 4; j++) {
+        int idx = (j*fp->nb_antennas_rx)+i;
+        free_and_zero(ue->pbch_vars[gNB_id]->rxdataF_comp[idx]);
+        free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates[idx]);
+        free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates_time[idx]);
+        free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates_ext[idx]);
+      }
+    }
+
+    free_and_zero(ue->pbch_vars[gNB_id]->rxdataF_ext);
+    free_and_zero(ue->pbch_vars[gNB_id]->rxdataF_comp);
+    free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates);
+    free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates_ext);
+    free_and_zero(ue->pbch_vars[gNB_id]->dl_ch_estimates_time);
+    free_and_zero(ue->pbch_vars[gNB_id]->llr);
+    free_and_zero(ue->pbch_vars[gNB_id]->decoded_output);
+    free_and_zero(ue->pbch_vars[gNB_id]);
+
+    free_and_zero(ue->prach_vars[gNB_id]->prachF);
+    free_and_zero(ue->prach_vars[gNB_id]->prach);
+    free_and_zero(ue->prach_vars[gNB_id]);
+  }
+
+  const int gNB_id = ue->n_connected_gNB;
+  for (int th_id = 0; th_id < RX_NB_TH_MAX; th_id++) {
+    free_and_zero(ue->pdsch_vars[th_id][gNB_id]->llr[1]);
+    free_and_zero(ue->pdsch_vars[th_id][gNB_id]->layer_llr[1]);
+    free_and_zero(ue->pdsch_vars[th_id][gNB_id]);
+  }
+
+  free_and_zero(ue->sinr_CQI_dB);
+}
+
+void term_nr_ue_transport(PHY_VARS_NR_UE *ue)
+{
+  const int N_RB_DL = ue->frame_parms.N_RB_DL;
+  for (int i = 0; i < NUMBER_OF_CONNECTED_gNB_MAX; i++) {
+    for (int j = 0; j < 2; j++) {
+      for (int k = 0; k < RX_NB_TH_MAX; k++) {
+        free_nr_ue_dlsch(&ue->dlsch[k][i][j], N_RB_DL);
+        free_nr_ue_ulsch(&ue->ulsch[k][i][j], N_RB_DL);
+      }
+    }
+
+    free_nr_ue_dlsch(&ue->dlsch_SI[i], N_RB_DL);
+    free_nr_ue_dlsch(&ue->dlsch_ra[i], N_RB_DL);
+  }
+
+  free_nr_ue_dlsch(&ue->dlsch_MCH[0], N_RB_DL);
+}
+
+void init_nr_ue_transport(PHY_VARS_NR_UE *ue)
+{
  for (int i = 0; i < NUMBER_OF_CONNECTED_gNB_MAX; i++) {
    for (int j=0; j<2; j++) {
      for (int k=0; k<RX_NB_TH_MAX; k++) {
-        AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NR_MAX_DLSCH_HARQ_PROCESSES,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
+        AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NR_MAX_DLSCH_HARQ_PROCESSES,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL))!=NULL,"Can't get ue dlsch structures\n");
        LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[k][i][j]);
-        AssertFatal((ue->ulsch[k][i][j]  = new_nr_ue_ulsch(ue->frame_parms.N_RB_UL, NR_MAX_ULSCH_HARQ_PROCESSES, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
+        AssertFatal((ue->ulsch[k][i][j]  = new_nr_ue_ulsch(ue->frame_parms.N_RB_UL, NR_MAX_ULSCH_HARQ_PROCESSES))!=NULL,"Can't get ue ulsch structures\n");
        LOG_D(PHY,"ulsch[%d][%d][%d] => %p\n",k,i,j,ue->ulsch[k][i][j]);
      }
    }

-    ue->dlsch_SI[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
-    ue->dlsch_ra[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
+    ue->dlsch_SI[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL);
+    ue->dlsch_ra[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL);
    ue->transmission_mode[i] = ue->frame_parms.nb_antenna_ports_gNB==1 ? 1 : 2;
  }

  //ue->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
-  ue->dlsch_MCH[0]  = new_nr_ue_dlsch(1,NR_MAX_DLSCH_HARQ_PROCESSES,NSOFT,MAX_LDPC_ITERATIONS_MBSFN,ue->frame_parms.N_RB_DL,0);
+  ue->dlsch_MCH[0]  = new_nr_ue_dlsch(1,NR_MAX_DLSCH_HARQ_PROCESSES,NSOFT,MAX_LDPC_ITERATIONS_MBSFN,ue->frame_parms.N_RB_DL);

  for(int i=0; i<5; i++)
    ue->dl_stats[i] = 0;
@@ -555,3 +776,9 @@ void phy_init_nr_top(PHY_VARS_NR_UE *ue) {
  //init_unscrambling_lut();
  //set_taus_seed(1328);
 }
+
+void phy_term_nr_top(void)
+{
+  free_ul_reference_signal_sequences();
+  free_context_synchro_nr();
+}
@@ -57,6 +57,7 @@ int l1_north_init_eNB(void);
 int phy_init_top(LTE_DL_FRAME_PARMS *frame_parms);

 void phy_init_nr_top(PHY_VARS_NR_UE *ue);
+void phy_term_nr_top(void);


 /*!
@@ -395,8 +396,9 @@ int nr_get_ssb_start_symbol(NR_DL_FRAME_PARMS *fp,uint8_t i_ssb);
 int nr_init_frame_parms(nfapi_nr_config_request_scf_t *config, NR_DL_FRAME_PARMS *frame_parms);
 int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms, fapi_nr_config_request_t *config, uint16_t nr_band);
 void nr_init_frame_parms_ue_sa(NR_DL_FRAME_PARMS *frame_parms, uint64_t downlink_frequency, int32_t uplink_frequency_offset, uint8_t mu, uint16_t nr_band);
-int init_nr_ue_signal(PHY_VARS_NR_UE *ue,int nb_connected_eNB,uint8_t abstraction_flag);
-void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag);
+int init_nr_ue_signal(PHY_VARS_NR_UE *ue,int nb_connected_eNB);
+void term_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB);
+void init_nr_ue_transport(PHY_VARS_NR_UE *ue);
 void init_N_TA_offset(PHY_VARS_NR_UE *ue);
 void nr_dump_frame_parms(NR_DL_FRAME_PARMS *frame_parms);
 int phy_init_nr_gNB(PHY_VARS_gNB *gNB, unsigned char is_secondary_gNB, unsigned char lowmem_flag);
@@ -405,11 +407,13 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu,
 void phy_free_nr_gNB(PHY_VARS_gNB *gNB);
 int l1_north_init_gNB(void);
 void init_nr_transport(PHY_VARS_gNB *gNB);
+void reset_nr_transport(PHY_VARS_gNB *gNB);

 void init_dfts(void);

 void fill_subframe_mask(PHY_VARS_eNB *eNB);
 void init_DLSCH_struct(PHY_VARS_gNB *gNB, processingData_L1tx_t *msg);
+void reset_DLSCH_struct(const PHY_VARS_gNB *gNB, processingData_L1tx_t *msg);

 /** @} */
 #endif
@@ -6481,7 +6481,7 @@ void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t subframe,unsigned int *c
  sprintf(fname,"dlsch%d_rxF_r%d_uespec0.m",eNB_id,round);
  sprintf(vname,"dl%d_rxF_r%d_uespec0",eNB_id,round);
  LOG_M(fname,vname,ue->pdsch_vars[ue->current_thread_id[subframe]][eNB_id]->rxdataF_uespec_pilots[0],
-        12*(ue->frame_parms.N_RB_DL)*NSYMB,1,1);
+        12*(ue->frame_parms.N_RB_DL),1,1);
  /*
    LOG_M("dlsch%d_ch_ext01.m","dl01_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[1],12*N_RB_DL*NSYMB,1,1);
    LOG_M("dlsch%d_ch_ext10.m","dl10_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[2],12*N_RB_DL*NSYMB,1,1);
@@ -122,23 +122,20 @@ int16_t *base_sequence_less_than_36(unsigned int M_ZC,
 *********************************************************************/

 int16_t get_index_for_dmrs_lowpapr_seq(int16_t num_dmrs_res) {
-  
-  int16_t index = -1;
- 
-  if (num_dmrs_res >= dmrs_ul_allocated_res[(MAX_INDEX_DMRS_UL_ALLOCATED_REs-1)]) 
+
+  int16_t index = num_dmrs_res/6 - 1;
+
+  if (index >= MAX_INDEX_DMRS_UL_ALLOCATED_REs)
    index = MAX_INDEX_DMRS_UL_ALLOCATED_REs-1;
-  else 
-    index = (num_dmrs_res/6) -1;

  for (;index >= 0; index--) {
    if (dmrs_ul_allocated_res[index] == num_dmrs_res)
      break;
-
  }

-  LOG_D(PHY, "num_dmrs_res: %d    INDEX RETURNED:  %d", num_dmrs_res, index);  
-  return index;  
+  LOG_D(PHY, "num_dmrs_res: %d    INDEX RETURNED:  %d", num_dmrs_res, index);

+  return index;
 }

 /*******************************************************************
@@ -204,6 +201,11 @@ int16_t *base_sequence_36_or_larger(unsigned int Msc_RS,

 void generate_lowpapr_typ1_refsig_sequences(unsigned int scaling)
 {
+  /* prevent multiple calls, relevant when both UE & gNB initialize this */
+  static bool already_called = false;
+  if (already_called) return;
+  already_called = true;
+
 	unsigned int u,Msc_RS;
  unsigned int v = 0; // sequence hopping and group hopping are not supported yet

@@ -223,6 +225,11 @@ void generate_lowpapr_typ1_refsig_sequences(unsigned int scaling)

 void generate_ul_reference_signal_sequences(unsigned int scaling)
 {
+  /* prevent multiple calls, relevant when both UE & gNB initialize this */
+  static bool already_called = false;
+  if (already_called) return;
+  already_called = true;
+
 	unsigned int u,v,Msc_RS;

 #if 0
@@ -295,10 +302,10 @@ void free_ul_reference_signal_sequences(void)
    for (u=0; u < U_GROUP_NUMBER; u++) {
      for (v=0; v < V_BASE_SEQUENCE_NUMBER; v++) {
        if (rv_ul_ref_sig[u][v][Msc_RS])
-          free16(rv_ul_ref_sig[u][v][Msc_RS],2*sizeof(int16_t)*ul_allocated_re[Msc_RS]);
+          free_and_zero(rv_ul_ref_sig[u][v][Msc_RS]);
        if ((v==0) && (Msc_RS < MAX_INDEX_DMRS_UL_ALLOCATED_REs))
          if (dmrs_lowpaprtype1_ul_ref_sig[u][v][Msc_RS])
-            free16(dmrs_lowpaprtype1_ul_ref_sig[u][v][Msc_RS],2*sizeof(int16_t)*dmrs_ul_allocated_res[Msc_RS]);        
+            free_and_zero(dmrs_lowpaprtype1_ul_ref_sig[u][v][Msc_RS]);
      }
    }
  }
@@ -321,7 +328,7 @@ void free_gnb_lowpapr_sequences(void)
    v=0;
    for (u=0; u < U_GROUP_NUMBER; u++) {      
      if (gNB_dmrs_lowpaprtype1_sequence[u][v][Msc_RS])
-        free16(gNB_dmrs_lowpaprtype1_sequence[u][v][Msc_RS],2*sizeof(int16_t)*dmrs_ul_allocated_res[Msc_RS]);
+        free_and_zero(gNB_dmrs_lowpaprtype1_sequence[u][v][Msc_RS]);
    }
  }
 }
@@ -130,11 +130,8 @@ void nr_generate_dci(nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15,
    uint16_t Nid    = dci_pdu->ScramblingId;
    uint16_t scrambling_RNTI = dci_pdu->ScramblingRNTI;

-    t_nrPolar_params *currentPtr = nr_polar_params(NR_POLAR_DCI_MESSAGE_TYPE, 
-						   dci_pdu->PayloadSizeBits,
-						   dci_pdu->AggregationLevel,
-						   0,NULL);
-    polar_encoder_fast((uint64_t*)dci_pdu->Payload, (void*)encoder_output, n_RNTI,1,currentPtr);
+    polar_encoder_fast((uint64_t*)dci_pdu->Payload, (void*)encoder_output, n_RNTI, 1, 
+                       NR_POLAR_DCI_MESSAGE_TYPE, dci_pdu->PayloadSizeBits, dci_pdu->AggregationLevel);
 #ifdef DEBUG_CHANNEL_CODING
    printf("polar rnti %x,length %d, L %d\n",n_RNTI, dci_pdu->PayloadSizeBits,pdcch_pdu_rel15->dci_pdu->AggregationLevel);
    printf("DCI PDU: [0]->0x%lx \t [1]->0x%lx\n",
@@ -55,42 +55,39 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB) {
  NR_gNB_DLSCH_t *dlsch = *dlschptr;
  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated

-  if (dlsch) {
-    if (N_RB != 273) {
-      a_segments = a_segments*N_RB;
-      a_segments = a_segments/273 +1;
-    }
-    
-#ifdef DEBUG_DLSCH_FREE
-    LOG_D(PHY,"Freeing dlsch %p\n",dlsch);
-#endif
-    NR_DL_gNB_HARQ_t *harq = &dlsch->harq_process;
-    
-    if (harq->b) {
-      free16(harq->b, a_segments * 1056);
-      harq->b = NULL;
-#ifdef DEBUG_DLSCH_FREE
-      LOG_D(PHY, "Freeing harq->b (%p)\n", harq->b);
-#endif
-    }
-    
-#ifdef DEBUG_DLSCH_FREE
-    LOG_D(PHY, "Freeing dlsch process %d c (%p)\n", i, harq->c);
-#endif
-    
-    for (r = 0; r < a_segments; r++) {
-#ifdef DEBUG_DLSCH_FREE
-      LOG_D(PHY, "Freeing dlsch process %d c[%d] (%p)\n", i, r, harq->c[r]);
-#endif
-      
-      if (harq->c[r]) {
-	free16(harq->c[r], 1056);
-	harq->c[r] = NULL;
-      }
-    }
-    free16(dlsch, sizeof(NR_gNB_DLSCH_t));
-    *dlschptr = NULL;
+  if (N_RB != 273) {
+    a_segments = a_segments*N_RB;
+    a_segments = a_segments/273 +1;
  }
+
+  NR_DL_gNB_HARQ_t *harq = &dlsch->harq_process;
+  if (harq->b) {
+    free16(harq->b, a_segments * 1056);
+    harq->b = NULL;
+  }
+  for (r = 0; r < a_segments; r++) {
+    free(harq->c[r]);
+    harq->c[r] = NULL;
+  }
+  free(harq->pdu);
+
+  for (int aa = 0; aa < 64; aa++)
+    free(dlsch->calib_dl_ch_estimates[aa]);
+  free(dlsch->calib_dl_ch_estimates);
+
+  for (int q=0; q<NR_MAX_NB_CODEWORDS; q++)
+    free(dlsch->mod_symbs[q]);
+
+  for (int layer = 0; layer < NR_MAX_NB_LAYERS; layer++) {
+    free(dlsch->txdataF_precoding[layer]);
+    free(dlsch->txdataF[layer]);
+    for (int aa = 0; aa < 64; aa++)
+      free(dlsch->ue_spec_bf_weights[layer][aa]);
+    free(dlsch->ue_spec_bf_weights[layer]);
+  }
+
+  free(dlsch);
+  *dlschptr = NULL;
 }

 NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
@@ -299,8 +299,8 @@ int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,

  /// CRC, coding and rate matching
  polar_encoder_fast (&a_reversed, (void*)pbch->pbch_e, 0, 0,
-                      nr_polar_params( NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL,0,NULL)
-                     );
+                      NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL);
+
 #ifdef DEBUG_PBCH_ENCODING
  printf("Channel coding:\n");

@@ -92,6 +92,5 @@ uint8_t get_l0(uint16_t dlDmrsSymbPos) {
    if ((mask&1) == 1) break;
    mask>>=1;
  }
-  AssertFatal(l0 < 4,"impossible l0 %d\n",l0);
  return (l0);
 }
@@ -106,6 +106,8 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
                              uint8_t abstraction_flag,
                              uint16_t N_RB);

+void free_gNB_dlsch(NR_gNB_DLSCH_t **dlschptr, uint16_t N_RB);
+
 /** \brief This function is the top-level entry point to PUSCH demodulation, after frequency-domain transformation and channel estimation.  It performs
    - RB extraction (signal and channel estimates)
    - channel compensation (matched filtering)
@@ -296,6 +298,7 @@ int16_t find_nr_prach(PHY_VARS_gNB *gNB,int frame,int slot, find_type_t type);
 int16_t find_nr_prach_ru(RU_t *ru,int frame,int slot, find_type_t type);

 NR_gNB_PUCCH_t *new_gNB_pucch(void);
+void free_gNB_pucch(NR_gNB_PUCCH_t *pucch);

 void nr_fill_pucch(PHY_VARS_gNB *gNB,
                   int frame,
@@ -308,6 +311,7 @@ int nr_find_pucch(uint16_t rnti,
                  PHY_VARS_gNB *gNB);

 NR_gNB_SRS_t *new_gNB_srs(void);
+void free_gNB_srs(NR_gNB_SRS_t *srs);

 int nr_find_srs(uint16_t rnti,
                int frame,
@@ -33,9 +33,9 @@
 #include "PHY/defs_gNB.h"
 #include "common/utils/threadPool/thread-pool.h"

-void free_gNB_ulsch(NR_gNB_ULSCH_t **ulsch,uint8_t N_RB_UL);
+void free_gNB_ulsch(NR_gNB_ULSCH_t **ulsch, uint16_t N_RB_UL);

-NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint16_t N_RB_UL, uint8_t abstraction_flag);
+NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations, uint16_t N_RB_UL);


 /*! \brief Perform PUSCH decoding. TS 38.212 V15.4.0 subclause 6.2
@@ -54,60 +54,40 @@

 //extern double cpuf;

-void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr,uint8_t N_RB_UL)
+void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr, uint16_t N_RB_UL)
 {

  int i,r;
  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS;  //number of segments to be allocated
  NR_gNB_ULSCH_t *ulsch = *ulschptr;

-  if (ulsch) {
-    if (N_RB_UL != 273) {
-      a_segments = a_segments*N_RB_UL;
-      a_segments = a_segments/273 +1;
-    }  
-
-
-    for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
-
-      if (ulsch->harq_processes[i]) {
-        if (ulsch->harq_processes[i]->b) {
-          free16(ulsch->harq_processes[i]->b,a_segments*1056);
-          ulsch->harq_processes[i]->b = NULL;
-        }
-        for (r=0; r<a_segments; r++) {
-          free16(ulsch->harq_processes[i]->c[r],(8448)*sizeof(uint8_t));
-          ulsch->harq_processes[i]->c[r] = NULL;
-        }
-        for (r=0; r<a_segments; r++) {
-          if (ulsch->harq_processes[i]->d[r]) {
-            free16(ulsch->harq_processes[i]->d[r],(68*384)*sizeof(int16_t));
-            ulsch->harq_processes[i]->d[r] = NULL;
-          }
-        }
-        for (r=0; r<a_segments; r++) {
-          if (ulsch->harq_processes[i]->w[r]) {
-            free16(ulsch->harq_processes[i]->w[r],(3*(6144+64))*sizeof(int16_t));
-            ulsch->harq_processes[i]->w[r] = NULL;
-          }
-        }
-        for (r=0; r<a_segments; r++) {
-          if (ulsch->harq_processes[i]->p_nrLDPC_procBuf[r]){
-            nrLDPC_free_mem(ulsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
-            ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
-          }
-        }
-        free16(ulsch->harq_processes[i],sizeof(NR_UL_gNB_HARQ_t));
-        ulsch->harq_processes[i] = NULL;
-      }
-    }
-    free16(ulsch,sizeof(NR_gNB_ULSCH_t));
-    *ulschptr = NULL;
+  if (N_RB_UL != 273) {
+    a_segments = a_segments*N_RB_UL;
+    a_segments = a_segments/273 +1;
  }
+
+  for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
+    if (ulsch->harq_processes[i]) {
+      if (ulsch->harq_processes[i]->b) {
+        free_and_zero(ulsch->harq_processes[i]->b);
+        ulsch->harq_processes[i]->b = NULL;
+      }
+      for (r=0; r<a_segments; r++) {
+        free_and_zero(ulsch->harq_processes[i]->c[r]);
+        free_and_zero(ulsch->harq_processes[i]->d[r]);
+        free_and_zero(ulsch->harq_processes[i]->w[r]);
+        nrLDPC_free_mem(ulsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
+        ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
+      }
+      free_and_zero(ulsch->harq_processes[i]);
+      ulsch->harq_processes[i] = NULL;
+    }
+  }
+  free_and_zero(*ulschptr);
 }


-NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint16_t N_RB_UL, uint8_t abstraction_flag)
+NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations, uint16_t N_RB_UL)
 {

  NR_gNB_ULSCH_t *ulsch;
@@ -129,13 +109,11 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint16_t N_RB_UL, uint
    
    ulsch->harq_processes[i] = (NR_UL_gNB_HARQ_t *)malloc16_clear(sizeof(NR_UL_gNB_HARQ_t));
    ulsch->harq_processes[i]->b = (uint8_t*)malloc16_clear(ulsch_bytes);
-    if (abstraction_flag == 0) {
-      for (r=0; r<a_segments; r++) {
-	ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
-	ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16_clear(8448*sizeof(uint8_t));
-	ulsch->harq_processes[i]->d[r] = (int16_t*)malloc16_clear((68*384)*sizeof(int16_t));
-	ulsch->harq_processes[i]->w[r] = (int16_t*)malloc16_clear((3*(6144+64))*sizeof(int16_t));
-      }
+    for (r=0; r<a_segments; r++) {
+      ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
+      ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16_clear(8448*sizeof(uint8_t));
+      ulsch->harq_processes[i]->d[r] = (int16_t*)malloc16_clear((68*384)*sizeof(int16_t));
+      ulsch->harq_processes[i]->w[r] = (int16_t*)malloc16_clear((3*(6144+64))*sizeof(int16_t));
    }
  }
  
@@ -62,6 +62,11 @@ NR_gNB_PUCCH_t *new_gNB_pucch(void){
    return (pucch);
 }

+void free_gNB_pucch(NR_gNB_PUCCH_t *pucch)
+{
+  free_and_zero(pucch);
+}
+
 int nr_find_pucch(uint16_t rnti,
                  int frame,
                  int slot,
@@ -1533,7 +1538,6 @@ void nr_decode_pucch2(PHY_VARS_gNB *gNB,
  }
  else { // polar coded case

-    t_nrPolar_params *currentPtr = nr_polar_params(2,nb_bit,pucch_pdu->prb_size,1,&gNB->uci_polarParams);
    __m64 *rp_re[Prx2][2];
    __m64 *rp2_re[Prx2][2];
    __m64 *rp_im[Prx2][2];
@@ -1660,7 +1664,7 @@ void nr_decode_pucch2(PHY_VARS_gNB *gNB,
      } // half_prb
    } // symb
    // run polar decoder on llrs
-    decoderState = polar_decoder_int16((int16_t*)llrs, decodedPayload, 0, currentPtr);
+    decoderState = polar_decoder_int16((int16_t*)llrs, decodedPayload, 0, 2,nb_bit,pucch_pdu->prb_size);
    LOG_D(PHY,"UCI decoderState %d, payload[0] %llu\n",decoderState,(unsigned long long)decodedPayload[0]);
    if (decoderState>0) decoderState=1;
    corr_dB = dB_fixed64(corr);
@@ -49,6 +49,11 @@ NR_gNB_SRS_t *new_gNB_srs(void){
  return (srs);
 }

+void free_gNB_srs(NR_gNB_SRS_t *srs)
+{
+  free_and_zero(srs);
+}
+
 int nr_find_srs(uint16_t rnti,
                int frame,
                int slot,
@@ -642,6 +642,7 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                                unsigned short p,
                                unsigned char symbol,
                                unsigned short BWPStart,
+                                uint8_t config_type,
                                unsigned short bwp_start_subcarrier,
                                unsigned short nb_rb_pdsch)
 {
@@ -653,10 +654,6 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
  int16_t *fl=NULL,*fm=NULL,*fr=NULL,*fml=NULL,*fmr=NULL,*fmm=NULL,*fdcl=NULL,*fdcr=NULL,*fdclh=NULL,*fdcrh=NULL, *frl=NULL, *frr=NULL;
  int ch_offset,symbol_offset;

-  NR_UE_DLSCH_t  **dlsch = ue->dlsch[proc->thread_id][gNB_id];
-  const unsigned char harq_pid = dlsch[0]->current_harq_pid;
-  NR_DL_UE_HARQ_t *dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
-
  uint8_t nushift;
  int **dl_ch_estimates  =ue->pdsch_vars[proc->thread_id][gNB_id]->dl_ch_estimates;
  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[proc->thread_id].rxdataF;
@@ -678,7 +675,6 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
  if (is_SI) {
    rb_offset -= BWPStart;
  }
-  uint8_t config_type = dlsch0_harq->dmrsConfigType;
  int8_t delta = get_delta(p, config_type);

  // checking if re-initialization of scrambling IDs is needed
@@ -72,6 +72,7 @@ int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                                unsigned short p,
                                unsigned char symbol,
                                unsigned short BWPStart,
+                                uint8_t config_type,
                                unsigned short bwp_start_subcarrier,
                                unsigned short nb_rb_pdsch);

@@ -130,76 +130,75 @@ void nr_pdcch_demapping_deinterleaving(uint32_t *llr,

  */
  int c = 0, r = 0;
-  uint16_t bundle_j = 0, f_bundle_j = 0, f_reg = 0;
+  uint16_t f_bundle_j = 0;
  uint32_t coreset_C = 0;
  uint16_t index_z, index_llr;
  int coreset_interleaved = 0;
+  int N_regs = coreset_nbr_rb*coreset_time_dur;

  if (reg_bundle_size_L != 0) { // interleaving will be done only if reg_bundle_size_L != 0
    coreset_interleaved = 1;
-    coreset_C = (uint32_t) (coreset_nbr_rb / (coreset_interleaver_size_R * reg_bundle_size_L));
+    coreset_C = (uint32_t) (N_regs / (coreset_interleaver_size_R * reg_bundle_size_L));
  } else {
    reg_bundle_size_L = 6;
  }

+  int B_rb = reg_bundle_size_L/coreset_time_dur; // nb of RBs occupied by each REG bundle
+  int num_bundles_per_cce = 6/reg_bundle_size_L;
+  int max_bundles = NR_MAX_PDCCH_AGG_LEVEL*num_bundles_per_cce;
+  int f_bundle_j_list[max_bundles];

-  int f_bundle_j_list[(2*NR_MAX_PDCCH_AGG_LEVEL) - 1] = {};
-
-  for (int reg = 0; reg < coreset_nbr_rb; reg++) {
-    if ((reg % reg_bundle_size_L) == 0) {
+  // for each bundle
+  for (int nb = 0; nb < max_bundles; nb++) {
+    if (coreset_interleaved == 0) f_bundle_j = nb;
+    else {
      if (r == coreset_interleaver_size_R) {
        r = 0;
        c++;
      }
-
-      bundle_j = (c * coreset_interleaver_size_R) + r;
-      f_bundle_j = ((r * coreset_C) + c + n_shift) % (coreset_nbr_rb / reg_bundle_size_L);
-
-      if (coreset_interleaved == 0) f_bundle_j = bundle_j;
-
-      f_bundle_j_list[reg / 6] = f_bundle_j;
-
+      f_bundle_j = ((r * coreset_C) + c + n_shift) % (N_regs / reg_bundle_size_L);
+      r++;
    }
-    if ((reg % reg_bundle_size_L) == 0) r++;
+    f_bundle_j_list[nb] = f_bundle_j;
  }

-  // Get cce_list indices by reg_idx in ascending order
-  int f_bundle_j_list_id = 0;
-  int f_bundle_j_list_ord[(2*NR_MAX_PDCCH_AGG_LEVEL)-1] = {};
+  // Get cce_list indices by bundle index in ascending order
+  int f_bundle_j_list_ord[number_of_candidates][max_bundles];
  for (int c_id = 0; c_id < number_of_candidates; c_id++ ) {
-    f_bundle_j_list_id = CCE[c_id];
-    for (int p = 0; p < NR_MAX_PDCCH_AGG_LEVEL; p++) {
-      for (int p2 = CCE[c_id]; p2 < CCE[c_id] + L[c_id]; p2++) {
-        AssertFatal(p2<2*NR_MAX_PDCCH_AGG_LEVEL,"number_of_candidates %d : p2 %d,  CCE[%d] %d, L[%d] %d\n",number_of_candidates,p2,c_id,CCE[c_id],c_id,L[c_id]);
-        if (f_bundle_j_list[p2] == p) {
-          AssertFatal(f_bundle_j_list_id < 2*NR_MAX_PDCCH_AGG_LEVEL,"f_bundle_j_list_id %d\n",f_bundle_j_list_id);
-          f_bundle_j_list_ord[f_bundle_j_list_id] = p;
+    int start_bund_cand = CCE[c_id]*num_bundles_per_cce;
+    int max_bund_per_cand = L[c_id]*num_bundles_per_cce;
+    int f_bundle_j_list_id = 0;
+    for(int nb = 0; nb < max_bundles; nb++) {
+      for(int bund_cand = start_bund_cand; bund_cand < start_bund_cand+max_bund_per_cand; bund_cand++){
+        if (f_bundle_j_list[bund_cand] == nb) {
+          f_bundle_j_list_ord[c_id][f_bundle_j_list_id] = nb;
          f_bundle_j_list_id++;
-          break;
+
        }
      }
    }
  }

-  int rb = 0;
+  int rb_count = 0;
+  int data_sc = 9; // 9 sub-carriers with data per PRB
  for (int c_id = 0; c_id < number_of_candidates; c_id++ ) {
    for (int symbol_idx = start_symbol; symbol_idx < start_symbol+coreset_time_dur; symbol_idx++) {
-      for (int cce_count = CCE[c_id/coreset_time_dur]+c_id%coreset_time_dur; cce_count < CCE[c_id/coreset_time_dur]+c_id%coreset_time_dur+L[c_id]; cce_count += coreset_time_dur) {
-        for (int reg_in_cce_idx = 0; reg_in_cce_idx < NR_NB_REG_PER_CCE; reg_in_cce_idx++) {
-
-          f_reg = (f_bundle_j_list_ord[cce_count] * reg_bundle_size_L) + reg_in_cce_idx;
-          index_z = 9 * rb;
-          index_llr = (uint16_t) (f_reg + symbol_idx * coreset_nbr_rb) * 9;
-
-          for (int i = 0; i < 9; i++) {
-            z[index_z + i] = llr[index_llr + i];
+      for (int cce_count = 0; cce_count < L[c_id]; cce_count ++) {
+        for (int k=0; k<NR_NB_REG_PER_CCE/reg_bundle_size_L; k++) { // loop over REG bundles
+          int f = f_bundle_j_list_ord[c_id][k+NR_NB_REG_PER_CCE*cce_count/reg_bundle_size_L];
+          for(int rb=0; rb<B_rb; rb++) { // loop over the RBs of the bundle
+            index_z = data_sc * rb_count;
+            index_llr = (uint16_t) (f*B_rb + rb + symbol_idx * coreset_nbr_rb) * data_sc;
+            for (int i = 0; i < data_sc; i++) {
+              z[index_z + i] = llr[index_llr + i];
 #ifdef NR_PDCCH_DCI_DEBUG
-            LOG_I(PHY,"[cce_count=%d,reg_in_cce_idx=%d,bundle_j=%d,symbol_idx=%d,candidate=%d] z[%d]=(%d,%d) <-> \t[f_reg=%d,fbundle_j=%d] llr[%d]=(%d,%d) \n",
-                  cce_count,reg_in_cce_idx,bundle_j,symbol_idx,c_id,(index_z + i),*(int16_t *) &z[index_z + i],*(1 + (int16_t *) &z[index_z + i]),
-                   f_reg,f_bundle_j,(index_llr + i),*(int16_t *) &llr[index_llr + i], *(1 + (int16_t *) &llr[index_llr + i]));
+              LOG_I(PHY,"[candidate=%d,symbol_idx=%d,cce=%d,REG bundle=%d,PRB=%d] z[%d]=(%d,%d) <-> \t llr[%d]=(%d,%d) \n",
+                    c_id,symbol_idx,cce_count,k,f*B_rb + rb,(index_z + i),*(int16_t *) &z[index_z + i],*(1 + (int16_t *) &z[index_z + i]),
+                    (index_llr + i),*(int16_t *) &llr[index_llr + i], *(1 + (int16_t *) &llr[index_llr + i]));
 #endif
+            }
+            rb_count++;
          }
-          rb++;
        }
      }
    }
@@ -783,15 +782,7 @@ int32_t nr_rx_pdcch(PHY_VARS_NR_UE *ue,
                                    rel15->number_of_candidates,
                                    rel15->CCE,
                                    rel15->L);
-    /*
-    nr_pdcch_unscrambling(rel15->rnti,
-                          frame_parms,
-                          slot,
-                          pdcch_vars->e_rx,
-                          rel15->coreset.duration*n_rb*9*2,
-                          // get_nCCE(n_pdcch_symbols, frame_parms, mi) * 72,
-                          rel15->coreset.pdcch_dmrs_scrambling_id);
-    */
+
  LOG_D(PHY,"we end nr_pdcch_unscrambling()\n");
  LOG_D(PHY,"Ending nr_rx_pdcch() function\n");

@@ -832,14 +823,18 @@ void nr_pdcch_unscrambling(int16_t *z,
 /* This function compares the received DCI bits with
 * re-encoded DCI bits and returns the number of mismatched bits
 */
-uint16_t nr_dci_false_detection(uint64_t *dci,
-                            int16_t *soft_in,
-                            const t_nrPolar_params *polar_param,
-                            int encoded_length,
-                            int rnti) {
+static uint16_t nr_dci_false_detection(uint64_t *dci,
+                                       int16_t *soft_in,
+                                       int encoded_length,
+                                       int rnti,
+                                       int8_t messageType,
+                                       uint16_t messageLength,
+                                       uint8_t aggregation_level
+                                       ) {

  uint32_t encoder_output[NR_MAX_DCI_SIZE_DWORD];
-  polar_encoder_fast(dci, (void*)encoder_output, rnti, 1, (t_nrPolar_params *)polar_param);
+  polar_encoder_fast(dci, (void*)encoder_output, rnti, 1,
+                    messageType, messageLength, aggregation_level);
  uint8_t *enout_p = (uint8_t*)encoder_output;
  uint16_t x = 0;

@@ -866,6 +861,7 @@ uint8_t nr_dci_decoding_procedure(PHY_VARS_NR_UE *ue,
  //int gNB_id = 0;
  int16_t tmp_e[16*108];
  rnti_t n_rnti;
+  int e_rx_cand_idx = 0;

  for (int j=0;j<rel15->number_of_candidates;j++) {
    int CCEind = rel15->CCE[j];
@@ -886,26 +882,24 @@ uint8_t nr_dci_decoding_procedure(PHY_VARS_NR_UE *ue,
      if (dci_found==1) continue;
      int dci_length = rel15->dci_length_options[k];
      uint64_t dci_estimation[2]= {0};
-      const t_nrPolar_params *currentPtrDCI = nr_polar_params(NR_POLAR_DCI_MESSAGE_TYPE, dci_length, L, 1, &ue->polarList);

      LOG_D(PHY, "Trying DCI candidate %d of %d number of candidates, CCE %d (%d), L %d, length %d, format %s\n",
-            j, rel15->number_of_candidates, CCEind, CCEind*9*6*2, L, dci_length,nr_dci_format_string[rel15->dci_format_options[k]]);
+            j, rel15->number_of_candidates, CCEind, e_rx_cand_idx, L, dci_length,nr_dci_format_string[rel15->dci_format_options[k]]);

-      nr_pdcch_unscrambling(&pdcch_vars->e_rx[CCEind*108], rel15->coreset.scrambling_rnti, L*108, rel15->coreset.pdcch_dmrs_scrambling_id, tmp_e);
+      nr_pdcch_unscrambling(&pdcch_vars->e_rx[e_rx_cand_idx], rel15->coreset.scrambling_rnti, L*108, rel15->coreset.pdcch_dmrs_scrambling_id, tmp_e);

 #ifdef DEBUG_DCI_DECODING
-      uint32_t * z = (uint32_t *) &pdcch_vars->e_rx[CCEind*108];
-      for (int index_z = 0; index_z < 96; index_z++){
+      uint32_t *z = (uint32_t *) &pdcch_vars->e_rx[e_rx_cand_idx];
+      for (int index_z = 0; index_z < L*6; index_z++){
        for (int i=0; i<9; i++) {
          LOG_D(PHY,"z[%d]=(%d,%d) \n", (9*index_z + i), *(int16_t *) &z[index_z + i],*(1 + (int16_t *) &z[index_z + i]));
        }
      }
 #endif
-
      uint16_t crc = polar_decoder_int16(tmp_e,
                                         dci_estimation,
                                         1,
-                                         currentPtrDCI);
+                                         NR_POLAR_DCI_MESSAGE_TYPE, dci_length, L);

      n_rnti = rel15->rnti;
      LOG_D(PHY, "(%i.%i) dci indication (rnti %x,dci format %s,n_CCE %d,payloadSize %d)\n",
@@ -913,7 +907,7 @@ uint8_t nr_dci_decoding_procedure(PHY_VARS_NR_UE *ue,
      if (crc == n_rnti) {
        LOG_D(PHY, "(%i.%i) Received dci indication (rnti %x,dci format %s,n_CCE %d,payloadSize %d,payload %llx)\n",
              proc->frame_rx, proc->nr_slot_rx,n_rnti,nr_dci_format_string[rel15->dci_format_options[k]],CCEind,dci_length,*(unsigned long long*)dci_estimation);
-        uint16_t mb = nr_dci_false_detection(dci_estimation,tmp_e,currentPtrDCI,L*108,n_rnti);
+        uint16_t mb = nr_dci_false_detection(dci_estimation,tmp_e,L*108,n_rnti, NR_POLAR_DCI_MESSAGE_TYPE, dci_length, L);
        ue->dci_thres = (ue->dci_thres + mb) / 2;
        if (mb > (ue->dci_thres+20)) {
          LOG_W(PHY,"DCI false positive. Dropping DCI index %d. Mismatched bits: %d/%d. Current DCI threshold: %d\n",j,mb,L*108,ue->dci_thres);
@@ -935,6 +929,7 @@ uint8_t nr_dci_decoding_procedure(PHY_VARS_NR_UE *ue,
        LOG_D(PHY,"(%i.%i) Decoded crc %x does not match rnti %x for DCI format %d\n", proc->frame_rx, proc->nr_slot_rx, crc, n_rnti, rel15->dci_format_options[k]);
      }
    }
+    e_rx_cand_idx += 9*L*6*2; //e_rx index for next candidate (L CCEs, 6 REGs per CCE and 9 REs per REG and 2 uint16_t per RE)
  }
  pdcch_vars->nb_search_space = 0;
  return(dci_ind->number_of_dcis);
@@ -79,7 +79,7 @@ void init_dlsch_tpool(uint8_t num_dlsch_threads) {
  free(params);
 }

-void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr,uint8_t N_RB_DL) {
+void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr, uint16_t N_RB_DL) {
  int i,r;
  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
  NR_UE_DLSCH_t *dlsch=*dlschptr;
@@ -131,7 +131,7 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr,uint8_t N_RB_DL) {
  }
 }

-NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_ldpc_iterations,uint16_t N_RB_DL, uint8_t abstraction_flag) {
+NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_ldpc_iterations,uint16_t N_RB_DL) {
  NR_UE_DLSCH_t *dlsch;
  uint8_t exit_flag = 0,i,r;
  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
@@ -167,30 +167,28 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
        else
          exit_flag=3;

-        if (abstraction_flag == 0) {
-          for (r=0; r<a_segments; r++) {
-            dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
-            dlsch->harq_processes[i]->c[r] = (uint8_t *)malloc16(1056);
+        for (r=0; r<a_segments; r++) {
+          dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
+          dlsch->harq_processes[i]->c[r] = (uint8_t *)malloc16(1056);

-            if (dlsch->harq_processes[i]->c[r])
-              memset(dlsch->harq_processes[i]->c[r],0,1056);
-            else
-              exit_flag=2;
+          if (dlsch->harq_processes[i]->c[r])
+            memset(dlsch->harq_processes[i]->c[r],0,1056);
+          else
+            exit_flag=2;

-            dlsch->harq_processes[i]->d[r] = (short *)malloc16((5*8448)*sizeof(short));
+          dlsch->harq_processes[i]->d[r] = (short *)malloc16((5*8448)*sizeof(short));

-            if (dlsch->harq_processes[i]->d[r])
-              memset(dlsch->harq_processes[i]->d[r],0,(5*8448)*sizeof(short));
-            else
-              exit_flag=2;
+          if (dlsch->harq_processes[i]->d[r])
+            memset(dlsch->harq_processes[i]->d[r],0,(5*8448)*sizeof(short));
+          else
+            exit_flag=2;

-            dlsch->harq_processes[i]->w[r] = (short *)malloc16((5*8448)*sizeof(short));
+          dlsch->harq_processes[i]->w[r] = (short *)malloc16((5*8448)*sizeof(short));

-            if (dlsch->harq_processes[i]->w[r])
-              memset(dlsch->harq_processes[i]->w[r],0,(5*8448)*sizeof(short));
-            else
-              exit_flag=2;
-          }
+          if (dlsch->harq_processes[i]->w[r])
+            memset(dlsch->harq_processes[i]->w[r],0,(5*8448)*sizeof(short));
+          else
+            exit_flag=2;
        }
      } else {
        exit_flag=1;
@@ -931,12 +931,12 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {

      for (aatx=0; aatx<nb_aatx; aatx++) {
-        dl_ch128      = (__m128i *)&dl_ch_estimates_ext[aatx*frame_parms->nb_antennas_rx+aarx][symbol*nb_rb*12];

        for (atx=0; atx<nb_aatx; atx++) {
          avg_rho_re[aarx][aatx*nb_aatx+atx] = 0;
          avg_rho_im[aarx][aatx*nb_aatx+atx] = 0;
          rho128        = (__m128i *)&rho[aarx][aatx*nb_aatx+atx][symbol*nb_rb*12];
+          dl_ch128      = (__m128i *)&dl_ch_estimates_ext[aatx*frame_parms->nb_antennas_rx+aarx][symbol*nb_rb*12];
          dl_ch128_2    = (__m128i *)&dl_ch_estimates_ext[atx*frame_parms->nb_antennas_rx+aarx][symbol*nb_rb*12];

          for (rb=0; rb<nb_rb_0; rb++) {
@@ -337,6 +337,22 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
        sync_pos_frame = n_symb_prefix0*(fp->ofdm_symbol_size + fp->nb_prefix_samples0)+(ue->symbol_offset-n_symb_prefix0)*(fp->ofdm_symbol_size + fp->nb_prefix_samples);
        // for a correct computation of frame number to sync with the one decoded at MIB we need to take into account in which of the n_frames we got sync
        ue->init_sync_frame = n_frames - 1 - is;
+
+        // compute the scramblingID_pdcch and the gold pdcch
+        ue->scramblingID_pdcch = fp->Nid_cell;
+        nr_gold_pdcch(ue,fp->Nid_cell);
+
+        // compute the scrambling IDs for PDSCH DMRS
+        for (int i=0; i<2; i++)
+          ue->scramblingID[i]=fp->Nid_cell;
+
+        nr_gold_pdsch(ue,ue->scramblingID);
+
+        // initialize the pusch dmrs
+        uint16_t N_n_scid[2] = {fp->Nid_cell,fp->Nid_cell};
+        int n_scid = 0; // This quantity is indicated by higher layer parameter dmrs-SeqInitialization
+        nr_init_pusch_dmrs(ue, N_n_scid, n_scid);
+
        // we also need to take into account the shift by samples_per_frame in case the if is true
        if (ue->ssb_offset < sync_pos_frame){
          ue->rx_offset = fp->samples_per_frame - sync_pos_frame + ue->ssb_offset;
@@ -533,8 +533,8 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,

  nr_pbch_unscrambling(nr_ue_pbch_vars,frame_parms->Nid_cell,nushift,M,NR_POLAR_PBCH_E,0,0);
  //polar decoding de-rate matching
-  const t_nrPolar_params *currentPtr = nr_polar_params( NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL,1,&ue->polarList);
-  decoderState = polar_decoder_int16(pbch_e_rx,(uint64_t *)&nr_ue_pbch_vars->pbch_a_prime,0,currentPtr);
+  decoderState = polar_decoder_int16(pbch_e_rx,(uint64_t *)&nr_ue_pbch_vars->pbch_a_prime,0,
+                                     NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL);

  if(decoderState) return(decoderState);

@@ -601,7 +601,7 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 #endif

  nr_downlink_indication_t dl_indication;
-  fapi_nr_rx_indication_t *rx_ind = calloc(1, sizeof(*rx_ind));
+  fapi_nr_rx_indication_t *rx_ind=calloc(sizeof(*rx_ind),1);
  uint16_t number_pdus = 1;

  nr_fill_dl_indication(&dl_indication, NULL, rx_ind, proc, ue, gNB_id);
@@ -609,6 +609,8 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,

  if (ue->if_inst && ue->if_inst->dl_indication)
    ue->if_inst->dl_indication(&dl_indication, NULL);
+  else
+    free(rx_ind); // dl_indication would free(), so free() here if not called

  return 0;
 }
--- a/Show More
+++ b/Show More