diff --git a/openair1/PHY/INIT/nr_parms.c b/openair1/PHY/INIT/nr_parms.c index 6c6b333a1283ba867dd79d07771d5fb9ac807319..a08abf416a9f65399474bc8628303bd91d57a83c 100644 --- a/openair1/PHY/INIT/nr_parms.c +++ b/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; } diff --git a/openair1/PHY/NR_TRANSPORT/nr_dlsch.h b/openair1/PHY/NR_TRANSPORT/nr_dlsch.h index bbb9783d3f7bb1770a7c96e0a4dc1a3278899898..d4c12a0ac8b40f5185d5c65e93efea87cf7335e5 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_dlsch.h +++ b/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); diff --git a/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c b/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c index 7d52ef04e34d19e67b62dd4e1f672a31c430ff78..e9cb69f70c4f4cfcf233a133d710f057f18c5522 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c +++ b/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); diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch.h b/openair1/PHY/NR_TRANSPORT/nr_ulsch.h index b3a4948a2a7ea42e3b2a5a42ddf761da2cdaf592..d49f5c8d006912926e8afacd150aad4938f73928 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch.h +++ b/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); diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c index 2e8f2af5f51609ab3fd1b7b037b66cc5259d4b6d..28a6a39fb87c7d2b0cccfc5f30c64bcc601e765b 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c +++ b/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,17 +117,14 @@ 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; + uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS; //number of segments to be allocated - switch (N_RB_UL) { - case 106: - bw_scaling =2; - break; + if (N_RB_UL != 273) { + a_segments = a_segments*N_RB_UL; + a_segments = a_segments/273; + } - default: - bw_scaling =1; - break; - } + uint16_t ulsch_bytes = a_segments*1056; // allocated bytes per segment ulsch = (NR_gNB_ULSCH_t *)malloc16(sizeof(NR_gNB_ULSCH_t)); @@ -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; + uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS; //number of segments to be allocated - switch (frame_parms->N_RB_UL) { - - 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_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 diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c index 7c9bb3b646031464915b81167ecadbf50e68fe34..c2c28b0626228764a9d4f9f10b77a4977fe6fd4c 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c +++ b/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,25 +118,14 @@ 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; + uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS; //number of segments to be allocated - switch (N_RB_DL) { - case 6: - bw_scaling =16; - break; + if (N_RB_DL != 273) { + a_segments = a_segments*N_RB_DL; + a_segments = a_segments/273; + } - case 25: - bw_scaling =4; - break; - - case 50: - bw_scaling =2; - break; - - default: - bw_scaling =1; - break; - } + uint16_t dlsch_bytes = a_segments*1056; // allocated bytes per segment dlsch = (NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t)); @@ -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); } @@ -391,20 +402,15 @@ uint32_t nr_dlsch_decoding(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)); } @@ -925,20 +931,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; + if (nb_rb != 273) { + a_segments = a_segments*nb_rb; + a_segments = a_segments/273; + } - default: - bw_scaling =1; - break; - } - - 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 @@ -1503,20 +1504,15 @@ void *nr_dlsch_decoding_process(void *arg) //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 diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h index 3c531856824784432bc285fd7ce6a6007a647fe7..2991ebf3d6c706fbaa79ff6f555ffe1dc0e44f1f 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h +++ b/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); diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h index 76427a9c093faa61ebc442f2526b570f3b3b318c..f976da0a3a83adaf1d069ea70a49e2cf2b5111a0 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h +++ b/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) diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c index f55765341631fd5ea3dc76528cdf06546d0858dd..334c8dfdd4cc7e0710891207c36e520146c823a6 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c +++ b/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,18 +109,14 @@ 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; + uint16_t a_segments = MAX_NUM_NR_ULSCH_SEGMENTS; //number of segments to be allocated - switch (N_RB_UL) { + if (N_RB_UL != 273) { + a_segments = a_segments*N_RB_UL; + a_segments = a_segments/273; + } - case 106: - bw_scaling =2; - break; - - default: - bw_scaling =1; - break; - } + uint16_t ulsch_bytes = a_segments*1056; // allocated bytes per segment ulsch = (NR_UE_ULSCH_t *)malloc16(sizeof(NR_UE_ULSCH_t)); @@ -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); diff --git a/openair1/PHY/defs_gNB.h b/openair1/PHY/defs_gNB.h index 3a0f5728ae47c9849c9cdda56d3a4bacf476225a..52aade312ae0a6b439fb27ae35633912dd9a0bc5 100644 --- a/openair1/PHY/defs_gNB.h +++ b/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; diff --git a/openair1/PHY/defs_nr_common.h b/openair1/PHY/defs_nr_common.h index bf57f0ab0701978f613b545abe097255a38eb4da..7b931a5ce45969a5edaaa0d4bc71fc2cae7a6f2b 100644 --- a/openair1/PHY/defs_nr_common.h +++ b/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 { diff --git a/openair1/SIMULATION/NR_PHY/dlschsim.c b/openair1/SIMULATION/NR_PHY/dlschsim.c index bc1bed4ea62951121f292490568b33086bd0608d..5667ceb98127b617f0705ab7312ba10cd1add669 100644 --- a/openair1/SIMULATION/NR_PHY/dlschsim.c +++ b/openair1/SIMULATION/NR_PHY/dlschsim.c @@ -628,9 +628,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++) { diff --git a/openair1/SIMULATION/NR_PHY/ulschsim.c b/openair1/SIMULATION/NR_PHY/ulschsim.c index 00f5bc237fa7b03900135bdc6f8033312c3b2ace..c5b59cb823bc142dd75813e59bdc1099e0b449e4 100644 --- a/openair1/SIMULATION/NR_PHY/ulschsim.c +++ b/openair1/SIMULATION/NR_PHY/ulschsim.c @@ -566,6 +566,7 @@ int main(int argc, char **argv) printf("\n"); } + if (output_fd) fclose(output_fd); diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c index dd8c48fee0116b7fc689255837804c49afffac95..89ba5f250c8698665cf2b4209fad1d994f9688f5 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c +++ b/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];