Merge branch 'nr_segmentation_fixes' into NR_RRCConfiguration

openair1/PHY/INIT/nr_parms.c

@@ -84,7 +84,8 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
 			 nfapi_nr_config_request_scf_t* cfg,
 			 int mu0,
 			 int Ncp,
-			 int N_RB_DL)
+			 int N_RB_DL,
+                         int N_RB_UL)
 
 {
 
@@ -103,6 +104,7 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
   fp->numerology_index = mu;
   fp->Ncp = Ncp;
   fp->N_RB_DL = N_RB_DL;
+  fp->N_RB_UL = N_RB_UL;
 
   switch(mu) {
 
@@ -267,11 +269,13 @@ int nr_init_frame_parms(nfapi_nr_config_request_scf_t* config,
   fp->frame_type = config->cell_config.frame_duplex_type.value;
   fp->L_ssb = (((uint64_t) config->ssb_table.ssb_mask_list[1].ssb_mask.value)<<32) | config->ssb_table.ssb_mask_list[0].ssb_mask.value ;
   int N_RB_DL = config->carrier_config.dl_grid_size[config->ssb_config.scs_common.value].value;
+  int N_RB_UL = config->carrier_config.ul_grid_size[config->ssb_config.scs_common.value].value;
   return nr_init_frame_parms0(fp,
 			      config,
 			      0,
 			      NFAPI_CP_NORMAL,
-			      N_RB_DL);
+			      N_RB_DL,
+                              N_RB_UL);
 }
 
 int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *fp,
@@ -281,8 +285,8 @@ int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *fp,
 			   int n_ssb_crb,
 			   int ssb_subcarrier_offset) 
 {
-  /*n_ssb_crb and ssb_subcarrier_offset are given in 15kHz SCS*/
-  nr_init_frame_parms0(fp,NULL,mu,Ncp,N_RB_DL);
+  int N_RB_UL = N_RB_DL;
+  nr_init_frame_parms0(fp,NULL,mu,Ncp,N_RB_DL,N_RB_UL);
   fp->ssb_start_subcarrier = (12 * n_ssb_crb + ssb_subcarrier_offset);
   return 0;
 }

openair1/PHY/NR_TRANSPORT/nr_dlsch.h

@@ -89,7 +89,7 @@ uint8_t nr_generate_pdsch(NR_gNB_DLSCH_t *dlsch,
 			  time_stats_t *dlsch_segmentation_stats);
 
 
-void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
+void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch,uint16_t N_RB);
 
 void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -49,12 +49,22 @@
 //#define DEBUG_DLSCH_CODING
 //#define DEBUG_DLSCH_FREE 1
 
-void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
+void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch,uint16_t N_RB)
 {
   int i;
   int r;
 
+  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;
+    }  
+
+    uint16_t dlsch_bytes = a_segments*1056;  // allocated bytes per segment
+
+
 #ifdef DEBUG_DLSCH_FREE
     LOG_D(PHY,"Freeing dlsch %p\n",dlsch);
 #endif
@@ -70,18 +80,34 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
 #endif
 
         if (dlsch->harq_processes[i]->b) {
-          free16(dlsch->harq_processes[i]->b,MAX_NR_DLSCH_PAYLOAD_BYTES); //this should be MAX_NR_DLSCH_PAYLOAD_BYTES
+          free16(dlsch->harq_processes[i]->b,dlsch_bytes);
           dlsch->harq_processes[i]->b = NULL;
 #ifdef DEBUG_DLSCH_FREE
           LOG_D(PHY,"Freeing dlsch process %d b (%p)\n",i,dlsch->harq_processes[i]->b);
 #endif
         }
 
+        if (dlsch->harq_processes[i]->e) {
+          free16(dlsch->harq_processes[i]->e,14*N_RB*12*8);
+          dlsch->harq_processes[i]->e = NULL;
+#ifdef DEBUG_DLSCH_FREE
+          printf("Freeing dlsch process %d e (%p)\n",i,dlsch->harq_processes[i]->e);
+#endif
+        }
+
+        if (dlsch->harq_processes[i]->f) {
+          free16(dlsch->harq_processes[i]->f,14*N_RB*12*8);
+          dlsch->harq_processes[i]->f = NULL;
+#ifdef DEBUG_DLSCH_FREE
+          printf("Freeing dlsch process %d f (%p)\n",i,dlsch->harq_processes[i]->f);
+#endif
+        }
+
 #ifdef DEBUG_DLSCH_FREE
         LOG_D(PHY,"Freeing dlsch process %d c (%p)\n",i,dlsch->harq_processes[i]->c);
 #endif
 
-        for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS; r++) {
+        for (r=0; r<a_segments; r++) {
 
 #ifdef DEBUG_DLSCH_FREE
           LOG_D(PHY,"Freeing dlsch process %d c[%d] (%p)\n",i,r,dlsch->harq_processes[i]->c[r]);
@@ -119,9 +145,15 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
   NR_gNB_DLSCH_t *dlsch;
   unsigned char exit_flag = 0,i,r,aa,layer;
   int re;
-  unsigned char bw_scaling =1;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
+
+  if (N_RB != 273) {
+    a_segments = a_segments*N_RB;
+    a_segments = a_segments/273;
+  }  
+
+  uint16_t dlsch_bytes = a_segments*1056;  // allocated bytes per segment
 
-  if (N_RB <= 107) bw_scaling =2;
   
   dlsch = (NR_gNB_DLSCH_t *)malloc16(sizeof(NR_gNB_DLSCH_t));
 
@@ -161,31 +193,31 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
 
     for (i=0; i<Mdlharq; i++) {
       dlsch->harq_processes[i] = (NR_DL_gNB_HARQ_t *)malloc16(sizeof(NR_DL_gNB_HARQ_t));
-      LOG_T(PHY, "Required mem size %d (bw scaling %d), dlsch->harq_processes[%d] %p\n",
-    		  MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling,bw_scaling, i,dlsch->harq_processes[i]);
+      LOG_T(PHY, "Required mem size %d  dlsch->harq_processes[%d] %p\n",
+    		  dlsch_bytes, i,dlsch->harq_processes[i]);
 
       if (dlsch->harq_processes[i]) {
         bzero(dlsch->harq_processes[i],sizeof(NR_DL_gNB_HARQ_t));
         //    dlsch->harq_processes[i]->first_tx=1;
-        dlsch->harq_processes[i]->b = (unsigned char*)malloc16(MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
-        dlsch->harq_processes[i]->pdu = (uint8_t*)malloc16(MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
+        dlsch->harq_processes[i]->b = (unsigned char*)malloc16(dlsch_bytes);
+        dlsch->harq_processes[i]->pdu = (uint8_t*)malloc16(dlsch_bytes);
         if (dlsch->harq_processes[i]->pdu) {
-          bzero(dlsch->harq_processes[i]->pdu,MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
-          nr_emulate_dlsch_payload(dlsch->harq_processes[i]->pdu, (MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling)>>3);
+          bzero(dlsch->harq_processes[i]->pdu,dlsch_bytes);
+          nr_emulate_dlsch_payload(dlsch->harq_processes[i]->pdu, (dlsch_bytes)>>3);
         } else {
           LOG_D(PHY,"Can't allocate PDU\n");
           exit_flag=1;
         }
 
         if (dlsch->harq_processes[i]->b) {
-          bzero(dlsch->harq_processes[i]->b,MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
+          bzero(dlsch->harq_processes[i]->b,dlsch_bytes);
         } else {
           LOG_D(PHY,"Can't get b\n");
           exit_flag=1;
         }
 
         if (abstraction_flag==0) {
-          for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) {
+          for (r=0; r<a_segments; r++) {
             // account for filler in first segment and CRCs for multiple segment case
             // [hna] 8448 is the maximum CB size in NR
             //       68*348 = 68*(maximum size of Zc)
@@ -205,6 +237,20 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
               exit_flag=2;
             }
           }
+          dlsch->harq_processes[i]->e = (uint8_t*)malloc16(14*N_RB*12*8);
+          if (dlsch->harq_processes[i]->e) {
+            bzero(dlsch->harq_processes[i]->e,14*N_RB*12*8);
+          } else {
+            printf("Can't get e\n");
+            exit_flag=1;
+          }
+          dlsch->harq_processes[i]->f = (uint8_t*)malloc16(14*N_RB*12*8);
+          if (dlsch->harq_processes[i]->f) {
+            bzero(dlsch->harq_processes[i]->f,14*N_RB*12*8);
+          } else {
+            printf("Can't get f\n");
+            exit_flag=1;
+          }
         }
       } else {
         LOG_D(PHY,"Can't get harq_p %d\n",i);
@@ -223,7 +269,7 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms,
 
   LOG_D(PHY,"new_gNB_dlsch exit flag %d, size of  %ld\n",
 	exit_flag, sizeof(NR_gNB_DLSCH_t));
-  free_gNB_dlsch(dlsch);
+  free_gNB_dlsch(dlsch,N_RB);
   return(NULL);
 
 
@@ -325,7 +371,7 @@ int nr_dlsch_encoding(unsigned char *a,
       dlsch->harq_processes[harq_pid]->B = A+24;
       //    dlsch->harq_processes[harq_pid]->b = a;
    
-      AssertFatal((A/8)+3 <= MAX_NR_DLSCH_PAYLOAD_BYTES,"A %d is too big (A/8+4 = %d > %d)\n",A,(A/8)+4,MAX_NR_DLSCH_PAYLOAD_BYTES);
+      AssertFatal((A/8)+4 <= MAX_NR_DLSCH_PAYLOAD_BYTES,"A %d is too big (A/8+4 = %d > %d)\n",A,(A/8)+4,MAX_NR_DLSCH_PAYLOAD_BYTES);
 
       memcpy(dlsch->harq_processes[harq_pid]->b,a,(A/8)+4);  // why is this +4 if the CRC is only 3 bytes?
     }
@@ -391,7 +437,7 @@ int nr_dlsch_encoding(unsigned char *a,
       //ldpc_encoder_optim((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],(unsigned char*)&dlsch->harq_processes[harq_pid]->d[r][0],*Zc,Kb,Kr,BG,NULL,NULL,NULL,NULL);
     }
 
-    for(int j=0;j<(dlsch->harq_processes[harq_pid]->C/8+1);j++) {
+    for(int j=0;j<((dlsch->harq_processes[harq_pid]->C-1)/8+1);j++) {
       ldpc_encoder_optim_8seg_multi(dlsch->harq_processes[harq_pid]->c,dlsch->harq_processes[harq_pid]->d,*Zc,Kb,Kr,BG,
 				    dlsch->harq_processes[harq_pid]->C,j,
 				    tinput,tprep,tparity,toutput);

openair1/PHY/NR_TRANSPORT/nr_ulsch.h

@@ -32,7 +32,7 @@
 
 #include "PHY/defs_gNB.h"
 
-void free_gNB_ulsch(NR_gNB_ULSCH_t **ulsch);
+void free_gNB_ulsch(NR_gNB_ULSCH_t **ulsch,uint8_t N_RB_UL);
 
 NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8_t abstraction_flag);
 

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -58,29 +58,45 @@ static uint64_t nb_error_decod =0;
 
 //extern double cpuf;
 
-void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr) {
+void free_gNB_ulsch(NR_gNB_ULSCH_t **ulschptr,uint8_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;
+    }  
+
+    uint16_t ulsch_bytes = a_segments*1056;  // allocated bytes per segment
+
     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,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          free16(ulsch->harq_processes[i]->b,ulsch_bytes);
           ulsch->harq_processes[i]->b = NULL;
         }
-        for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+        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<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+        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<(MAX_NUM_NR_ULSCH_SEGMENTS); r++) {
+        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;
@@ -101,18 +117,15 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8
 
   NR_gNB_ULSCH_t *ulsch;
   uint8_t exit_flag = 0,i,r;
-  unsigned char bw_scaling =1;
-
-  switch (N_RB_UL) {
-    case 106:
-      bw_scaling =2;
-    break;
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS;  //number of segments to be allocated
 
-    default:
-      bw_scaling =1;
-    break;
+  if (N_RB_UL != 273) {
+    a_segments = a_segments*N_RB_UL;
+    a_segments = a_segments/273;
   }  
 
+  uint16_t ulsch_bytes = a_segments*1056;  // allocated bytes per segment
+
   ulsch = (NR_gNB_ULSCH_t *)malloc16(sizeof(NR_gNB_ULSCH_t));
 
   if (ulsch) {
@@ -130,15 +143,15 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8
 
         memset(ulsch->harq_processes[i],0,sizeof(NR_UL_gNB_HARQ_t));
 
-        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(ulsch_bytes);
 
         if (ulsch->harq_processes[i]->b)
-          memset(ulsch->harq_processes[i]->b,0,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+          memset(ulsch->harq_processes[i]->b,0,ulsch_bytes);
         else
           exit_flag=3;
 
         if (abstraction_flag == 0) {
-          for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling; r++) {
+          for (r=0; r<a_segments; r++) {
 
             ulsch->harq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem();
 
@@ -155,6 +168,13 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8
               memset(ulsch->harq_processes[i]->d[r],0,(68*384)*sizeof(int16_t));
             else
               exit_flag=2;
+
+            ulsch->harq_processes[i]->w[r] = (int16_t*)malloc16((3*(6144+64))*sizeof(int16_t));
+
+            if (ulsch->harq_processes[i]->w[r])
+              memset(ulsch->harq_processes[i]->w[r],0,(3*(6144+64))*sizeof(int16_t));
+            else
+              exit_flag=2;
           }
         }
       } else {
@@ -167,7 +187,8 @@ NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8
   }
 
   printf("new_gNB_ulsch with size %zu: exit_flag = %u\n",sizeof(NR_UL_gNB_HARQ_t), exit_flag);
-  free_gNB_ulsch(&ulsch);
+  free_gNB_ulsch(&ulsch,N_RB_UL);
+
   return(NULL);
 }
 
@@ -263,7 +284,7 @@ void clean_gNB_ulsch(NR_gNB_ULSCH_t *ulsch)
         /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
         //uint8_t h[MAX_NUM_CHANNEL_BITS];
         /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-        //int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+        //int16_t w[MAX_NUM_NR_ULSCH_SEGMENTS][3*(6144+64)];
       }
     }
   }
@@ -420,21 +441,15 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
   err_flag = 0;
   r_offset = 0;
 
-  unsigned char bw_scaling =1;
-
-  switch (frame_parms->N_RB_UL) {
-
-    case 106:
-      bw_scaling =2;
-      break;
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS;  //number of segments to be allocated
 
-    default:
-      bw_scaling =1;
-      break;
+  if (nb_rb != 273) {
+    a_segments = a_segments*nb_rb;
+    a_segments = a_segments/273;
   }  
 
-  if (harq_process->C > MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling) {
-    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling);
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
     return (ulsch->max_ldpc_iterations + 1);
   }
 #ifdef DEBUG_ULSCH_DECODING

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -56,31 +56,46 @@ notifiedFIFO_elt_t *msgToPush;
 
 //extern double cpuf;
 
-void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr)
+void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlschptr,uint8_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;
+
   if (dlsch) {
+    if (N_RB_DL != 273) {
+      a_segments = a_segments*N_RB_DL;
+      a_segments = a_segments/273;
+    }  
+ 
+    uint16_t dlsch_bytes = a_segments*1056;  // allocated bytes per segment
+
     for (i=0; i<dlsch->Mdlharq; i++) {
       if (dlsch->harq_processes[i]) {
         if (dlsch->harq_processes[i]->b) {
-          free16(dlsch->harq_processes[i]->b,MAX_NR_DLSCH_PAYLOAD_BYTES);
+          free16(dlsch->harq_processes[i]->b,dlsch_bytes);
           dlsch->harq_processes[i]->b = NULL;
         }
 
-        for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS; r++) {
+        for (r=0; r<a_segments; r++) {
           free16(dlsch->harq_processes[i]->c[r],1056);
           dlsch->harq_processes[i]->c[r] = NULL;
         }
 
-        for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS; r++)
+        for (r=0; r<a_segments; r++)
           if (dlsch->harq_processes[i]->d[r]) {
             free16(dlsch->harq_processes[i]->d[r],(3*8448)*sizeof(short));
             dlsch->harq_processes[i]->d[r] = NULL;
           }
         
-        for (r=0; r<(MAX_NUM_NR_DLSCH_SEGMENTS); r++) {
+        for (r=0; r<a_segments; r++)
+          if (dlsch->harq_processes[i]->w[r]) {
+            free16(dlsch->harq_processes[i]->w[r],(3*8448)*sizeof(short));
+            dlsch->harq_processes[i]->w[r] = NULL;
+          }
+
+        for (r=0; r<a_segments; r++) {
           if (dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]){
             nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]);
             dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL;
@@ -103,26 +118,15 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
   NR_UE_DLSCH_t *dlsch;
   uint8_t exit_flag = 0,i,r;
 
-  unsigned char bw_scaling =1;
-
-  switch (N_RB_DL) {
-  case 6:
-    bw_scaling =16;
-    break;
-
-  case 25:
-    bw_scaling =4;
-    break;
-
-  case 50:
-    bw_scaling =2;
-    break;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
 
-  default:
-    bw_scaling =1;
-    break;
+  if (N_RB_DL != 273) {
+    a_segments = a_segments*N_RB_DL;
+    a_segments = a_segments/273;
   }  
 
+  uint16_t dlsch_bytes = a_segments*1056;  // allocated bytes per segment
+
   dlsch = (NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t));
 
   if (dlsch) {
@@ -140,15 +144,15 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
       if (dlsch->harq_processes[i]) {
         memset(dlsch->harq_processes[i],0,sizeof(NR_DL_UE_HARQ_t));
         dlsch->harq_processes[i]->first_tx=1;
-        dlsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
+        dlsch->harq_processes[i]->b = (uint8_t*)malloc16(dlsch_bytes);
 
         if (dlsch->harq_processes[i]->b)
-          memset(dlsch->harq_processes[i]->b,0,MAX_NR_DLSCH_PAYLOAD_BYTES/bw_scaling);
+          memset(dlsch->harq_processes[i]->b,0,dlsch_bytes);
         else
           exit_flag=3;
 
         if (abstraction_flag == 0) {
-          for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) { 
+          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);
 
@@ -163,6 +167,13 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
               memset(dlsch->harq_processes[i]->d[r],0,(3*8448)*sizeof(short));
             else
               exit_flag=2;
+
+            dlsch->harq_processes[i]->w[r] = (short*)malloc16((3*8448)*sizeof(short));
+
+            if (dlsch->harq_processes[i]->w[r])
+              memset(dlsch->harq_processes[i]->w[r],0,(3*8448)*sizeof(short));
+            else
+              exit_flag=2;
           }
         }
       } else {
@@ -175,7 +186,7 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint
   }
 
   printf("new_ue_dlsch with size %zu: exit_flag = %u\n",sizeof(NR_DL_UE_HARQ_t), exit_flag);
-  free_nr_ue_dlsch(&dlsch);
+  free_nr_ue_dlsch(&dlsch,N_RB_DL);
 
   return(NULL);
 }
@@ -392,20 +403,15 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   err_flag = 0;
   r_offset = 0;
 
-  unsigned char bw_scaling =1;
-
-  switch (frame_parms->N_RB_DL) {
-    case 106:
-      bw_scaling =2;
-      break;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
 
-    default:
-      bw_scaling =1;
-      break;
+  if (nb_rb != 273) {
+    a_segments = a_segments*nb_rb;
+    a_segments = a_segments/273;
   }  
 
-  if (harq_process->C > MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling) {
-    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling);
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
     return((1+dlsch->max_ldpc_iterations));
   }
 
@@ -938,20 +944,15 @@ uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
   err_flag = 0;
   r_offset = 0;
 
-  unsigned char bw_scaling =1;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
 
-  switch (frame_parms->N_RB_DL) {
-  case 106:
-    bw_scaling =2;
-    break;
-
-  default:
-    bw_scaling =1;
-    break;
+  if (nb_rb != 273) {
+    a_segments = a_segments*nb_rb;
+    a_segments = a_segments/273;
   }  
 
-  if (harq_process->C > MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling) {
-    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling);
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
     return((1+dlsch->max_ldpc_iterations));
   }
 #ifdef DEBUG_DLSCH_DECODING
@@ -1516,20 +1517,15 @@ void *nr_dlsch_decoding_process(void *arg)
   //r_offset = 0;
 
   /*
-  unsigned char bw_scaling =1;
-
-  switch (frame_parms->N_RB_DL) {
-  case 106:
-    bw_scaling =2;
-    break;
+  uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS;  //number of segments to be allocated
 
-  default:
-    bw_scaling =1;
-    break;
+  if (nb_rb != 273) {
+    a_segments = a_segments*nb_rb;
+    a_segments = a_segments/273;
   }  
 
-  if (harq_process->C > MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling) {
-    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling);
+  if (harq_process->C > a_segments) {
+    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
     return((1+dlsch->max_ldpc_iterations));
   }*/
 #ifdef DEBUG_DLSCH_DECODING

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -47,7 +47,8 @@
     \brief This function frees memory allocated for a particular DLSCH at UE
     @param dlsch Pointer to DLSCH to be removed
 */
-void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlsch);
+void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlsch,uint8_t N_RB_DL);
+
 
 /** \fn new_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t abstraction_flag)
     \brief This function allocates structures for a particular DLSCH at UE
@@ -61,7 +62,7 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t **dlsch);
 NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_turbo_iterations,uint8_t N_RB_DL, uint8_t abstraction_flag);
 
 
-void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch);
+void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch,unsigned char N_RB_UL);
 
 
 NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL, int number_of_harq_pids, uint8_t abstraction_flag);

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -127,9 +127,9 @@ typedef struct {
   /// LDPC-code outputs
   uint8_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
   /// LDPC-code outputs (TS 36.212 V15.4.0, Sec 5.3.2 p. 17)
-  uint8_t e[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
+  uint8_t *e; 
   /// Rate matching (Interleaving) outputs (TS 36.212 V15.4.0, Sec 5.4.2.2 p. 30)
-  uint8_t f[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
+  uint8_t *f; 
   /// Number of code segments
   uint32_t C;
   /// Number of bits in code segments
@@ -278,7 +278,7 @@ typedef struct {
   /// MIMO mode for this DLSCH
   MIMO_nrmode_t mimo_mode;
   /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  int16_t w[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+  int16_t *w[MAX_NUM_NR_DLSCH_SEGMENTS];
   /// for abstraction soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
   //double w_abs[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
   /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -42,7 +42,7 @@
 
 
 
-void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch)
+void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch,unsigned char N_RB_UL)
 {
   int i, r;
 
@@ -51,18 +51,35 @@ void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch)
     printf("Freeing ulsch %p\n",ulsch);
 #endif
 
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS;  //number of segments to be allocated
+
+  if (N_RB_UL != 273) {
+    a_segments = a_segments*N_RB_UL;
+    a_segments = a_segments/273;
+  }  
+
+  uint16_t ulsch_bytes = a_segments*1056;  // allocated bytes per segment
+
     for (i=0; i<NR_MAX_ULSCH_HARQ_PROCESSES; i++) {
       if (ulsch->harq_processes[i]) {
 
         if (ulsch->harq_processes[i]->a) {
-          free16(ulsch->harq_processes[i]->a,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          free16(ulsch->harq_processes[i]->a,ulsch_bytes);
           ulsch->harq_processes[i]->a = NULL;
         }
         if (ulsch->harq_processes[i]->b) {
-          free16(ulsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES);
+          free16(ulsch->harq_processes[i]->b,ulsch_bytes);
           ulsch->harq_processes[i]->b = NULL;
         }
-        for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS; r++) {
+        if (ulsch->harq_processes[i]->e) {
+          free16(ulsch->harq_processes[i]->e,14*N_RB_UL*12*8);
+          ulsch->harq_processes[i]->e = NULL;
+        }
+        if (ulsch->harq_processes[i]->f) {
+          free16(ulsch->harq_processes[i]->f,14*N_RB_UL*12*8);
+          ulsch->harq_processes[i]->f = NULL;
+        }
+        for (r=0; r<a_segments; r++) {
           if (ulsch->harq_processes[i]->c[r]) {
             free16(ulsch->harq_processes[i]->c[r],((r==0)?8:0) + 3+768);
             ulsch->harq_processes[i]->c[r] = NULL;
@@ -92,19 +109,15 @@ NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL,
 {
   NR_UE_ULSCH_t *ulsch;
   unsigned char exit_flag = 0,i,r;
-  unsigned char bw_scaling =1;
-
-  switch (N_RB_UL) {
-
-  case 106:
-    bw_scaling =2;
-    break;
+  uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS;  //number of segments to be allocated
 
-  default:
-    bw_scaling =1;
-    break;
+  if (N_RB_UL != 273) {
+    a_segments = a_segments*N_RB_UL;
+    a_segments = a_segments/273;
   }  
 
+  uint16_t ulsch_bytes = a_segments*1056;  // allocated bytes per segment
+
   ulsch = (NR_UE_ULSCH_t *)malloc16(sizeof(NR_UE_ULSCH_t));
 
   if (ulsch) {
@@ -123,25 +136,25 @@ NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL,
       //      printf("ulsch->harq_processes[%d] %p\n",i,ulsch->harq_processes[i]);
       if (ulsch->harq_processes[i]) {
         memset(ulsch->harq_processes[i], 0, sizeof(NR_UL_UE_HARQ_t));
-        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
-        ulsch->harq_processes[i]->a = (unsigned char*)malloc16(MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        ulsch->harq_processes[i]->b = (uint8_t*)malloc16(ulsch_bytes);
+        ulsch->harq_processes[i]->a = (unsigned char*)malloc16(ulsch_bytes);
 
         if (ulsch->harq_processes[i]->a) {
-          bzero(ulsch->harq_processes[i]->a,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+          bzero(ulsch->harq_processes[i]->a,ulsch_bytes);
         } else {
           printf("Can't allocate PDU\n");
           exit_flag=1;
         }
 
         if (ulsch->harq_processes[i]->b)
-          bzero(ulsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+          bzero(ulsch->harq_processes[i]->b,ulsch_bytes);
         else {
           LOG_E(PHY,"Can't get b\n");
           exit_flag=1;
         }
 
         if (abstraction_flag==0) {
-          for (r=0; r<MAX_NUM_NR_ULSCH_SEGMENTS/bw_scaling; r++) {
+          for (r=0; r<a_segments; r++) {
             // account for filler in first segment and CRCs for multiple segment case
             ulsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448);
             ulsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384); //max size for coded output
@@ -159,6 +172,20 @@ NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL,
               exit_flag=2;
             }
           }
+          ulsch->harq_processes[i]->e = (uint8_t*)malloc16(14*N_RB_UL*12*8);
+          if (ulsch->harq_processes[i]->e) {
+            bzero(ulsch->harq_processes[i]->e,14*N_RB_UL*12*8);
+          } else {
+            printf("Can't get e\n");
+            exit_flag=1;
+          }
+          ulsch->harq_processes[i]->f = (uint8_t*)malloc16(14*N_RB_UL*12*8);
+          if (ulsch->harq_processes[i]->f) {
+            bzero(ulsch->harq_processes[i]->f,14*N_RB_UL*12*8);
+          } else {
+            printf("Can't get f\n");
+            exit_flag=1;
+          }
         }
 
         ulsch->harq_processes[i]->subframe_scheduling_flag = 0;
@@ -179,7 +206,7 @@ NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL,
   }
 
   LOG_E(PHY,"new_ue_ulsch exit flag, size of  %d ,   %zu\n",exit_flag, sizeof(LTE_UE_ULSCH_t));
-  free_nr_ue_ulsch(ulsch);
+  free_nr_ue_ulsch(ulsch,N_RB_UL);
   return(NULL);
 
 
@@ -238,6 +265,7 @@ int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
 ///////////
 /////////////////////////////////////////////////////////////////////////////////////////  
 
+
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
 
   LOG_D(PHY,"ulsch coding nb_rb %d nb_symb_sch %d nb_re_dmrs %d, length_dmrs %d\n", nb_rb,nb_symb_sch, nb_re_dmrs,length_dmrs);

openair1/PHY/defs_gNB.h

@@ -89,11 +89,11 @@ typedef struct {
   /// MIMO mode for this DLSCH
   MIMO_mode_t mimo_mode;
   /// Concatenated sequences
-  uint8_t e[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32)));
+  uint8_t *e;
   /// LDPC-code outputs
   uint8_t *d[MAX_NUM_NR_DLSCH_SEGMENTS];
   /// Interleaver outputs
-  uint8_t f[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32)));
+  uint8_t *f;
   /// Number of code segments
   uint32_t C;
   /// Number of bits in "small" code segments
@@ -273,7 +273,7 @@ typedef struct {
   /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
   uint8_t h[MAX_NUM_CHANNEL_BITS];
   /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
-  int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+  int16_t *w[MAX_NUM_NR_ULSCH_SEGMENTS];
   //////////////////////////////////////////////////////////////
 } NR_UL_gNB_HARQ_t;
 

openair1/PHY/defs_nr_common.h

@@ -102,13 +102,13 @@
 #define NR_MAX_PUSCH_ENCODED_LENGTH NR_MAX_PDSCH_ENCODED_LENGTH
 #define NR_MAX_PDSCH_TBS 3824
 
-#define MAX_NUM_NR_DLSCH_SEGMENTS 24
+#define MAX_NUM_NR_DLSCH_SEGMENTS 34
 #define MAX_NR_DLSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
 
 #define MAX_NUM_NR_ULSCH_SEGMENTS MAX_NUM_NR_DLSCH_SEGMENTS
 #define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_ULSCH_SEGMENTS*1056)
 
-#define MAX_NUM_NR_CHANNEL_BITS (14*273*12*6)  // 14 symbols, 273 RB
+#define MAX_NUM_NR_CHANNEL_BITS (14*273*12*8)  // 14 symbols, 273 RB
 #define MAX_NUM_NR_RE (14*273*12)
 
 typedef enum {

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -623,9 +623,9 @@ int main(int argc, char **argv)
 
 	for (i = 0; i < 2; i++) {
 		printf("gNB %d\n", i);
-		free_gNB_dlsch(gNB->dlsch[0][i]);
+		free_gNB_dlsch(gNB->dlsch[0][i],N_RB_DL);
 		printf("UE %d\n", i);
-		free_nr_ue_dlsch(&(UE->dlsch[0][0][i]));
+		free_nr_ue_dlsch(&(UE->dlsch[0][0][i]),N_RB_DL);
 	}
 
 	for (i = 0; i < 2; i++) {

openair1/SIMULATION/NR_PHY/ulschsim.c

@@ -566,6 +566,7 @@ int main(int argc, char **argv)
     printf("\n");
   }
 
+
   if (output_fd)
     fclose(output_fd);
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -480,7 +480,6 @@ void nr_schedule_uss_dlsch_phytest(module_id_t   module_idP,
   nfapi_nr_dl_tti_request_body_t   *dl_req;
   nfapi_nr_pdu_t            *TX_req;
 
-
   int TBS;
   int TBS_bytes;
   int lcid;
@@ -491,7 +490,7 @@ void nr_schedule_uss_dlsch_phytest(module_id_t   module_idP,
   mac_rlc_status_resp_t rlc_status;
   uint16_t sdu_lengths[NB_RB_MAX];
   int num_sdus = 0;
-  unsigned char dlsch_buffer[MAX_DLSCH_PAYLOAD_BYTES];
+  unsigned char dlsch_buffer[MAX_NR_DLSCH_PAYLOAD_BYTES];
   int offset;
   int UE_id = 0;
   unsigned char sdu_lcids[NB_RB_MAX];