nr adding filler bits and dlsch coding

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/LTE_TRANSPORT/dlsch_coding.c
+* \brief Top-level routines for implementing LDPC-coded (DLSCH) transport channels from 38-212, 15.2
+* \author H.Wang
+* \date 2018
+* \version 0.1
+* \company Eurecom
+* \email:
+* \note
+* \warning
+*/
+
+#include "PHY/defs_gNB.h"
+#include "PHY/phy_extern.h"
+#include "PHY/CODING/coding_extern.h"
+#include "PHY/CODING/coding_defs.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/NR_TRANSPORT/nr_transport.h"
+#include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "SCHED_NR/sched_nr.h"
+#include "defs.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+#include "UTIL/LOG/log.h"
+#include <syscall.h>
+
+//#define DEBUG_DLSCH_CODING
+//#define DEBUG_DLSCH_FREE 1
+
+void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
+{
+  int i;
+  int r;
+
+  if (dlsch) {
+#ifdef DEBUG_DLSCH_FREE
+    printf("Freeing dlsch %p\n",dlsch);
+#endif
+
+    for (i=0; i<dlsch->Mdlharq; i++) {
+#ifdef DEBUG_DLSCH_FREE
+      printf("Freeing dlsch process %d\n",i);
+#endif
+
+      if (dlsch->harq_processes[i]) {
+#ifdef DEBUG_DLSCH_FREE
+        printf("Freeing dlsch process %d (%p)\n",i,dlsch->harq_processes[i]);
+#endif
+
+        if (dlsch->harq_processes[i]->b) {
+          free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES);
+          dlsch->harq_processes[i]->b = NULL;
+#ifdef DEBUG_DLSCH_FREE
+          printf("Freeing dlsch process %d b (%p)\n",i,dlsch->harq_processes[i]->b);
+#endif
+        }
+
+#ifdef DEBUG_DLSCH_FREE
+        printf("Freeing dlsch process %d c (%p)\n",i,dlsch->harq_processes[i]->c);
+#endif
+
+        for (r=0; r<MAX_NUM_DLSCH_SEGMENTS; r++) {
+
+#ifdef DEBUG_DLSCH_FREE
+          printf("Freeing dlsch process %d c[%d] (%p)\n",i,r,dlsch->harq_processes[i]->c[r]);
+#endif
+
+          if (dlsch->harq_processes[i]->c[r]) {
+            free16(dlsch->harq_processes[i]->c[r],((r==0)?8:0) + 3+1056);
+            dlsch->harq_processes[i]->c[r] = NULL;
+          }
+          if (dlsch->harq_processes[i]->d[r]) {
+            free16(dlsch->harq_processes[i]->d[r],(96+12+3+(3*8448)));
+            dlsch->harq_processes[i]->d[r] = NULL;
+          }
+
+	}
+	free16(dlsch->harq_processes[i],sizeof(NR_DL_gNB_HARQ_t));
+	dlsch->harq_processes[i] = NULL;
+      }
+    }
+
+    free16(dlsch,sizeof(NR_gNB_DLSCH_t));
+    dlsch = NULL;
+    }
+
+}
+
+NR_gNB_DLSCH_t *new_gNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,uint32_t Nsoft,unsigned char N_RB_DL, uint8_t abstraction_flag, NR_DL_FRAME_PARMS* frame_parms)
+{
+
+  NR_gNB_DLSCH_t *dlsch;
+  unsigned char exit_flag = 0,i,j,r,aa,layer;
+  int re;
+  unsigned char bw_scaling =1;
+
+  switch (N_RB_DL) {
+
+  case 106:
+    bw_scaling =2;
+    break;
+
+  default:
+    bw_scaling =1;
+    break;
+  }
+
+  dlsch = (NR_gNB_DLSCH_t *)malloc16(sizeof(NR_gNB_DLSCH_t));
+
+  if (dlsch) {
+    bzero(dlsch,sizeof(NR_gNB_DLSCH_t));
+    dlsch->Kmimo = Kmimo;
+    dlsch->Mdlharq = Mdlharq;
+    dlsch->Mlimit = 4;
+    dlsch->Nsoft = Nsoft;
+
+    for (layer=0; layer<4; layer++) {
+      dlsch->ue_spec_bf_weights[layer] = (int32_t**)malloc16(frame_parms->nb_antennas_tx*sizeof(int32_t*));
+
+       for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+         dlsch->ue_spec_bf_weights[layer][aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
+         for (re=0;re<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; re++) {
+           dlsch->ue_spec_bf_weights[layer][aa][re] = 0x00007fff;
+         }
+       }
+     }
+
+     dlsch->calib_dl_ch_estimates = (int32_t**)malloc16(frame_parms->nb_antennas_tx*sizeof(int32_t*));
+     for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+       dlsch->calib_dl_ch_estimates[aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
+
+     }
+
+    for (i=0; i<10; i++)
+      dlsch->harq_ids[i] = Mdlharq;
+
+    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_ULSCH_PAYLOAD_BYTES/bw_scaling,bw_scaling, 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_ULSCH_PAYLOAD_BYTES/bw_scaling);
+
+        if (dlsch->harq_processes[i]->b) {
+          bzero(dlsch->harq_processes[i]->b,MAX_NR_ULSCH_PAYLOAD_BYTES/bw_scaling);
+        } else {
+          printf("Can't get b\n");
+          exit_flag=1;
+        }
+
+        if (abstraction_flag==0) {
+          for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) {
+            // account for filler in first segment and CRCs for multiple segment case
+            dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448);
+            dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(3*8448);
+            if (dlsch->harq_processes[i]->c[r]) {
+              bzero(dlsch->harq_processes[i]->c[r],8448);
+            } else {
+              printf("Can't get c\n");
+              exit_flag=2;
+            }
+            if (dlsch->harq_processes[i]->d[r]) {
+              bzero(dlsch->harq_processes[i]->d[r],(3*8448));
+            } else {
+              printf("Can't get d\n");
+              exit_flag=2;
+            }
+          }
+        }
+      } else {
+        printf("Can't get harq_p %d\n",i);
+        exit_flag=3;
+      }
+    }
+
+    if (exit_flag==0) {
+      for (i=0; i<Mdlharq; i++) {
+        dlsch->harq_processes[i]->round=0;
+      }
+
+      return(dlsch);
+    }
+  }
+
+  LOG_D(PHY,"new_gNB_dlsch exit flag %d, size of  %ld\n",
+	exit_flag, sizeof(NR_gNB_DLSCH_t));
+  free_gNB_dlsch(dlsch);
+  return(NULL);
+
+
+}
+
+void clean_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
+{
+
+  unsigned char Mdlharq;
+  unsigned char i,j,r;
+
+  if (dlsch) {
+    Mdlharq = dlsch->Mdlharq;
+    dlsch->rnti = 0;
+    dlsch->active = 0;
+
+    for (i=0; i<10; i++)
+      dlsch->harq_ids[i] = Mdlharq;
+
+    for (i=0; i<Mdlharq; i++) {
+      if (dlsch->harq_processes[i]) {
+        //  dlsch->harq_processes[i]->Ndi    = 0;
+        dlsch->harq_processes[i]->status = 0;
+        dlsch->harq_processes[i]->round  = 0;
+
+	for (j=0; j<96; j++)
+	  for (r=0; r<MAX_NUM_DLSCH_SEGMENTS; r++)
+	    if (dlsch->harq_processes[i]->d[r])
+	      dlsch->harq_processes[i]->d[r][j] = NR_NULL;
+
+      }
+    }
+  }
+}
+
+int dlsch_encoding(PHY_VARS_gNB *gNB,
+		   	   	   unsigned char *a,
+                   uint8_t num_pdcch_symbols,
+                   NR_gNB_DLSCH_t *dlsch,
+                   int frame,
+                   uint8_t subframe,
+                   time_stats_t *rm_stats,
+                   time_stats_t *te_stats,
+                   time_stats_t *i_stats)
+{
+
+  unsigned int G;
+  unsigned int crc=1;
+  unsigned short iind;
+
+  NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
+  unsigned char harq_pid = dlsch->current_harq_pid;
+  unsigned short nb_rb = dlsch->harq_processes[harq_pid]->nb_rb;
+  unsigned int A, Z;
+  unsigned *pz = &Z;
+  unsigned char mod_order;
+  unsigned int Kr=0,Kr_bytes,r,r_offset=0,Kr_int=0;
+  unsigned short m=dlsch->harq_processes[harq_pid]->mcs;
+  uint8_t beamforming_mode=0;
+  uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
+  double rate = 0.33;
+  uint8_t kb,BG;
+  uint32_t E;
+  uint8_t Ilbrm = 0;
+  uint32_t Tbslbrm = 950984; //to compute tbs
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
+
+  A = dlsch->harq_processes[harq_pid]->TBS;
+  //printf("Encoder: A: %d frame.subframe %d.%d \n",A, frame,subframe);
+  mod_order = get_nr_Qm(dlsch->harq_processes[harq_pid]->mcs);
+
+  G = get_G(frame_parms,nb_rb,dlsch->harq_processes[harq_pid]->rb_alloc,mod_order,dlsch->harq_processes[harq_pid]->Nl,num_pdcch_symbols,frame,subframe,beamforming_mode);
+
+  //  if (dlsch->harq_processes[harq_pid]->Ndi == 1) {  // this is a new packet
+  if (dlsch->harq_processes[harq_pid]->round == 0) {  // this is a new packet
+#ifdef DEBUG_DLSCH_CODING
+  printf("encoding thinks this is a new packet \n");
+#endif
+    /*
+    int i;
+    printf("dlsch (tx): \n");
+    for (i=0;i<(A>>3);i++)
+      printf("%02x.",a[i]);
+    printf("\n");
+    */
+    // Add 24-bit crc (polynomial A) to payload
+    crc = crc24a(a,
+                 A)>>8;
+    a[A>>3] = ((uint8_t*)&crc)[2];
+    a[1+(A>>3)] = ((uint8_t*)&crc)[1];
+    a[2+(A>>3)] = ((uint8_t*)&crc)[0];
+    //printf("CRC %x (A %d)\n",crc,A);
+
+    dlsch->harq_processes[harq_pid]->B = A+24;
+    //    dlsch->harq_processes[harq_pid]->b = a;
+    memcpy(dlsch->harq_processes[harq_pid]->b,a,(A/8)+4);
+
+    nr_segmentation(dlsch->harq_processes[harq_pid]->b,
+		    		dlsch->harq_processes[harq_pid]->c,
+					dlsch->harq_processes[harq_pid]->B,
+					&dlsch->harq_processes[harq_pid]->C,
+					&dlsch->harq_processes[harq_pid]->K,
+					pz,
+					&dlsch->harq_processes[harq_pid]->F);
+
+    kb = dlsch->harq_processes[harq_pid]->K/(*pz);
+    if ( kb==22){
+		BG = 1;
+	}
+	else{
+		BG = 2;
+	}
+
+    //printf("Encoder: B %d F %d \n",dlsch->harq_processes[harq_pid]->B, dlsch->harq_processes[harq_pid]->F);
+
+    Kr = dlsch->harq_processes[harq_pid]->K;
+    Kr_bytes = Kr>>3;
+
+    start_meas(te_stats);
+    for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
+      d_tmp[r] = &dlsch->harq_processes[harq_pid]->d[r][0];
+#ifdef DEBUG_DLSCH_CODING
+      printf("start ldpc encoder segment %d/%d\n",r,dlsch->harq_processes[harq_pid]->C);
+      printf("input %d %d %d %d %d \n", dlsch->harq_processes[harq_pid]->c[r][0], dlsch->harq_processes[harq_pid]->c[r][1], dlsch->harq_processes[harq_pid]->c[r][2],dlsch->harq_processes[harq_pid]->c[r][3], dlsch->harq_processes[harq_pid]->c[r][4]);
+      /*for (int cnt =0 ; cnt < 22*(*pz); cnt ++){
+      printf("%d ", dlsch->harq_processes[harq_pid]->c[r][cnt]);
+      }*/
+
+#endif
+      //ldpc_encoder_orig((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],&dlsch->harq_processes[harq_pid]->d[r][96],Kr,1,3,0);
+      //ldpc_encoder((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],&dlsch->harq_processes[harq_pid]->d[r][96],Kr,1,3);
+      //ldpc_encoder_optim((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],(unsigned char*)&dlsch->harq_processes[harq_pid]->d[r][96],Kr,1,3,NULL,NULL,NULL,NULL);
+    }
+
+    ldpc_encoder_optim_8seg(dlsch->harq_processes[harq_pid]->c,d_tmp,Kr,1,3,dlsch->harq_processes[harq_pid]->C,NULL,NULL,NULL,NULL);
+    stop_meas(te_stats);
+    /*printf("end ldpc encoder -- output\n");
+
+
+	printf("output %d %d %d %d %d \n", dlsch->harq_processes[harq_pid]->d[r][0], dlsch->harq_processes[harq_pid]->d[r][1], dlsch->harq_processes[harq_pid]->d[r][2],dlsch->harq_processes[harq_pid]->d[r][3], dlsch->harq_processes[harq_pid]->d[r][4]);
+	for (int cnt =0 ; cnt < 66*(*pz); cnt ++){
+	printf("%d \n",  dlsch->harq_processes[harq_pid]->d[r][cnt]);
+	}
+	printf("\n");*/
+
+#ifdef DEBUG_DLSCH_CODING
+      write_output("enc_input0.m","enc_in0",&dlsch->harq_processes[harq_pid]->c[0][0],Kr_bytes,1,4);
+      write_output("enc_output0.m","enc0",&dlsch->harq_processes[harq_pid]->d[0][0],(3*8*Kr_bytes)+12,1,4);
+#endif
+
+  }
+
+  for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
+#ifdef DEBUG_DLSCH_CODING
+    printf("Rate Matching, Code segment %d (coded bits (G) %d,unpunctured/repeated bits per code segment %d,mod_order %d, nb_rb %d)...\n",
+        r,
+        G,
+        Kr*3,
+        mod_order,nb_rb);
+#endif
+
+    start_meas(rm_stats);
+#ifdef DEBUG_DLSCH_CODING
+  printf("rvidx in encoding = %d\n", dlsch->harq_processes[harq_pid]->rvidx);
+#endif
+
+    r_offset += nr_rate_matching_ldpc(Ilbrm,
+        		 	 	 	 	 	 Tbslbrm,
+    								 BG,
+    								 *pz,
+        							 G,
+									 dlsch->harq_processes[harq_pid]->d[r],
+									 dlsch->harq_processes[harq_pid]->e+r_offset,
+									 dlsch->harq_processes[harq_pid]->C,
+									 dlsch->harq_processes[harq_pid]->rvidx,
+									 mod_order,
+									 dlsch->harq_processes[harq_pid]->Nl,
+    								 r);
+
+
+    stop_meas(rm_stats);
+
+    if (r==0) E=r_offset;
+
+    start_meas(i_stats);
+	nr_interleaving_ldpc(E,
+						&dlsch->harq_processes[harq_pid]->Qm,
+						dlsch->harq_processes[harq_pid]->e+r_offset,
+						dlsch->harq_processes[harq_pid]->f+r_offset);
+    stop_meas(i_stats);
+
+#ifdef DEBUG_DLSCH_CODING
+
+    if (r==dlsch->harq_processes[harq_pid]->C-1)
+      write_output("enc_output.m","enc",dlsch->harq_processes[harq_pid]->f,r_offset,1,4);
+
+#endif
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
+
+  return(0);
+}

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -382,7 +382,7 @@ uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
     nr_deinterleaving_ldpc(E,
     					   harq_process->Qm,
-                           &harq_process->d[r],
+                           harq_process->d[r],
                            harq_process->w[r]);
 
 #if UE_TIMING_TRACE
@@ -445,16 +445,20 @@ uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
             }
       printf(" \n");*/
 
-		memset(pv,0,2*p_decParams->Z*sizeof(int16_t));
+		memset(pv,0,harq_process->K*sizeof(int16_t));
         //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
 
+      	for (i=((2*p_decParams->Z)>>3), j = 0; i < (Kr_bytes-(harq_process->F>>3)); i++, j++)
+      	{
+      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
+      	}
 
-      	for (i=2*p_decParams->Z/8, j = 0; i < (kc*p_decParams->Z/8+1); i++, j++)
+		for (i=Kr_bytes, j = (Kr_bytes-(harq_process->F>>3)); i < ((kc*p_decParams->Z)>>3); i++, j++)
 		      	{
 		      		pv[i]= _mm_loadu_si128((__m128i*)(&inv_d[8*j]));
 		      	}
       	
-		for (i=0, j=0; j < (kc*p_decParams->Z/16);  i+=2, j++)
+		for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
       	      	{
       				
       	      		pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);