Merge branch 'gNB_mwc18_integration' of...

Merge branch 'gNB_mwc18_integration' of https://gitlab.eurecom.fr/oai-nr/openairinterface5g into gNB_mwc18_integration

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -142,12 +142,12 @@ int test_ldpc(short No_iteration,
     if (lift_size[i1] >= (double) block_length/Kb)
     {
       Zc = lift_size[i1];
-      // printf("%d\n",Zc);
+      //printf("%d\n",Zc);
       break;
     }
   }
 
-  printf("BG %d, Zc %d, Kb %d\n",BG, Zc, Kb);
+  printf("ldpc_test: BG %d, Zc %d, Kb %d\n",BG, Zc, Kb);
   no_punctured_columns=(int)((nrows-2)*Zc+block_length-block_length*(1/((float)nom_rate/(float)denom_rate)))/Zc;
   //  printf("puncture:%d\n",no_punctured_columns);
   removed_bit=(nrows-no_punctured_columns-2) * Zc+block_length-(int)(block_length/((float)nom_rate/(float)denom_rate));
@@ -160,28 +160,25 @@ int test_ldpc(short No_iteration,
     //// encoder
     start_meas(&time);
 
-    if (BG==1)
-      ldpc_encoder(test_input, channel_input,block_length,nom_rate,denom_rate);
-    else
+    //if (BG==1) 
+    //ldpc_encoder(test_input, channel_input,block_length,nom_rate,denom_rate);
+    //else
     ldpc_encoder_orig(test_input, channel_input,block_length,nom_rate,denom_rate,0);
     
     stop_meas(&time);
     start_meas(&time_optim);
-    if (BG==1) {
-      ldpc_encoder_optim(test_input, channel_input_optim,block_length,nom_rate,denom_rate,&tinput,&tprep,&tparity,&toutput);
-    }
+    ldpc_encoder_optim(test_input,channel_input_optim,block_length,nom_rate,denom_rate,&tinput,&tprep,&tparity,&toutput);
     stop_meas(&time_optim);
     
-    
+    if (ntrials==1)    
       for (i = 0; i < block_length+(nrows-no_punctured_columns) * Zc - removed_bit; i++)
 	if (channel_input[i]!=channel_input_optim[i]) printf("differ in pos %d (%d,%d)\n",i,
 							     channel_input[i],
 							     channel_input_optim[i]);
     //print_meas_now(&time, "", stdout);
 
-    //for (i=0;i<25344;i++)
+   // for (i=0;i<6400;i++)
     //printf("channel_input[%d]=%d\n",i,channel_input[i]);
-
     //printf("%d ",channel_input[i]);
 
     if ((BG==2) && (Zc==128||Zc==256))
@@ -253,7 +250,7 @@ int test_ldpc(short No_iteration,
 int main(int argc, char *argv[])
 {
   unsigned int errors,crc_misses;
-  short block_length=22*384; // decoder supports length: 1201 -> 1280, 2401 -> 2560
+  short block_length=576; // decoder supports length: 1201 -> 1280, 2401 -> 2560
   short No_iteration=25;
   //double rate=0.333;
   int nom_rate=1;
@@ -262,7 +259,9 @@ int main(int argc, char *argv[])
   unsigned char qbits=4;
   unsigned int decoded_errors[100]; // initiate the size of matrix equivalent to size of SNR
   int c,i=0;
+
   int n_trials = 1;
+
   randominit(0);
 
   while ((c = getopt (argc, argv, "q:r:s:l:n:")) != -1)

openair1/PHY/CODING/ldpc_encoder2.c

@@ -5,6 +5,7 @@
 #include <types.h>
 #include "assertions.h"
 #include "PHY/TOOLS/time_meas.h"
+#include "defs.h"
 
 #include "ldpc384_byte.c"
 #include "ldpc352_byte.c"
@@ -15,12 +16,32 @@
 #include "ldpc224_byte.c"
 #include "ldpc208_byte.c"
 #include "ldpc192_byte.c"
+#include "ldpc176_byte.c"
+#include "ldpc_BG2_Zc384_byte.c"
+#include "ldpc_BG2_Zc352_byte.c"
+#include "ldpc_BG2_Zc320_byte.c"
+#include "ldpc_BG2_Zc288_byte.c"
+#include "ldpc_BG2_Zc256_byte.c"
+#include "ldpc_BG2_Zc240_byte.c"
+#include "ldpc_BG2_Zc224_byte.c"
+#include "ldpc_BG2_Zc208_byte.c"
+#include "ldpc_BG2_Zc192_byte.c"
+#include "ldpc_BG2_Zc176_byte.c"
+#include "ldpc_BG2_Zc160_byte.c"
+#include "ldpc_BG2_Zc144_byte.c"
+#include "ldpc_BG2_Zc128_byte.c"
+#include "ldpc_BG2_Zc120_byte.c"
+#include "ldpc_BG2_Zc112_byte.c"
+#include "ldpc_BG2_Zc104_byte.c"
+#include "ldpc_BG2_Zc96_byte.c"
+#include "ldpc_BG2_Zc88_byte.c"
+#include "ldpc_BG2_Zc80_byte.c"
+#include "ldpc_BG2_Zc72_byte.c"
 
-void encode_parity_check_part_optim(unsigned char *c,unsigned char *d, short BG,short Zc,short Kb)
-{
 
-  AssertFatal(BG==1,"BG %d is not supported yet\n",BG);
 
+void encode_parity_check_part_optim(uint8_t *c,uint8_t *d, short BG,short Zc,short Kb)
+{
 
   if (BG==1)
   {
@@ -67,7 +88,7 @@ void encode_parity_check_part_optim(unsigned char *c,unsigned char *d, short BG,
     case 128: break;
     case 144: break;
     case 160: break;
-      //    case 176: ldpc176_byte(c,d); break;
+    case 176: ldpc176_byte(c,d); break;
     case 192: ldpc192_byte(c,d); break;
     case 208: ldpc208_byte(c,d); break;
     case 224: ldpc224_byte(c,d); break;
@@ -77,8 +98,69 @@ void encode_parity_check_part_optim(unsigned char *c,unsigned char *d, short BG,
     case 320: ldpc320_byte(c,d); break;
     case 352: ldpc352_byte(c,d); break;
     case 384: ldpc384_byte(c,d); break;
+    default: AssertFatal(0,"BG %d Zc %d is not supported yet\n",BG,Zc); break;
     }
   }
+  else if (BG==2) {
+    switch (Zc)
+    {
+    case 2: break;
+    case 3: break;
+    case 4: break;
+    case 5: break;
+    case 6: break;
+    case 7: break;
+    case 8: break;
+    case 9: break;
+    case 10: break;
+    case 11: break;
+    case 12: break;
+    case 13: break;
+    case 14: break;
+    case 15: break;
+    case 16: break;
+    case 18: break;
+    case 20: break;
+    case 22: break;
+    case 24: break;      
+    case 26: break;
+    case 28: break;
+    case 30: break;
+    case 32: break;
+    case 36: break;
+    case 40: break;
+    case 44: break;
+    case 48: break;
+    case 52: break;
+    case 56: break;
+    case 60: break;
+    case 64: break;
+    case 72: ldpc_BG2_Zc72_byte(c,d); break;
+    case 80: ldpc_BG2_Zc80_byte(c,d); break;   
+    case 88: ldpc_BG2_Zc88_byte(c,d); break;   
+    case 96: ldpc_BG2_Zc96_byte(c,d); break;
+    case 104: ldpc_BG2_Zc104_byte(c,d); break;
+    case 112: ldpc_BG2_Zc112_byte(c,d); break;
+    case 120: ldpc_BG2_Zc120_byte(c,d); break;
+    case 128: ldpc_BG2_Zc128_byte(c,d); break;
+    case 144: ldpc_BG2_Zc144_byte(c,d); break;
+    case 160: ldpc_BG2_Zc160_byte(c,d); break;
+    case 176: ldpc_BG2_Zc176_byte(c,d); break;
+    case 192: ldpc_BG2_Zc192_byte(c,d); break;
+    case 208: ldpc_BG2_Zc208_byte(c,d); break;
+    case 224: ldpc_BG2_Zc224_byte(c,d); break;
+    case 240: ldpc_BG2_Zc240_byte(c,d); break;
+    case 256: ldpc_BG2_Zc256_byte(c,d); break;
+    case 288: ldpc_BG2_Zc288_byte(c,d); break;
+    case 320: ldpc_BG2_Zc320_byte(c,d); break;
+    case 352: ldpc_BG2_Zc352_byte(c,d); break;
+    case 384: ldpc_BG2_Zc384_byte(c,d); break;
+    default: AssertFatal(0,"BG %d Zc %d is not supported yet\n",BG,Zc); break;
+    }
+  }
+  else {
+    AssertFatal(0,"BG %d is not supported yet\n",BG);
+  } 
 
 }
 
@@ -155,7 +237,7 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
   }
   stop_meas(tinput);
 
-  if (BG==1) { 
+  if ((BG==1) || (BG==2 && Zc>64)) { 
     // extend matrix
     start_meas(tprep);
     for (i1=0; i1 < ncols; i1++)
@@ -178,17 +260,12 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
     encode_parity_check_part_optim(c_extension, d, BG, Zc, Kb);
     stop_meas(tparity);
   }
-  else if (BG==2) {
+  else {
     if (encode_parity_check_part_orig(c, d, BG, Zc, Kb, block_length)!=0) {
       printf("Problem with encoder\n");
       return(-1);
     }
   }
-  else {
-      printf("Problem with encoder\n");
-      return(-1);
-  }
-
   start_meas(toutput);
   // information part and puncture columns
   memcpy(&channel_input[0], &c[2*Zc], (block_length-2*Zc)*sizeof(unsigned char));

openair1/PHY/CODING/ldpc_generate_coefficient.c

@@ -4,10 +4,11 @@
 #include <string.h>
 #include "Gen_shift_value.h"
 #include "assertions.h"
+#include "defs.h"
 
 short *choose_generator_matrix(short BG,short Zc)
 {
-  short *Gen_shift_values;
+  short *Gen_shift_values = NULL;
 
   if (BG==1)
   {
@@ -329,17 +330,22 @@ short *choose_generator_matrix(short BG,short Zc)
   return Gen_shift_values;
 }
 
-int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,short block_length,double rate,unsigned char gen_code)
+int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,short block_length,int nom_rate,int denom_rate,unsigned char gen_code)
 {
   unsigned char c[22*384]; //padded input, unpacked, max size
   unsigned char d[68*384]; //coded output, unpacked, max size
   unsigned char channel_temp,temp;
   short *Gen_shift_values, *no_shift_values, *pointer_shift_values;
   short BG,Zc,Kb,nrows,ncols;
-  int i,i1,i2,i3,i4,i5,t,var,temp_prime;
+  int i,i1,i2,i3,i4,i5,temp_prime,var;
   int no_punctured_columns,removed_bit;
   //Table of possible lifting sizes
   short lift_size[51]= {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384};
+
+  int nind=0;
+  int indlist[1000];
+  int indlist2[1000];
+
   //determine number of bits in codeword
   if (block_length>3840)
   {
@@ -353,6 +359,7 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
     BG=2;
     nrows=42;  //parity check bits
     ncols=10;  // info bits
+
     if (block_length>640)
       Kb = 10;
     else if (block_length>560)
@@ -364,6 +371,7 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
   }
 
   //find minimum value in all sets of lifting size
+  Zc=0;
   for (i1=0; i1 < 51; i1++)
   {
     if (lift_size[i1] >= (double) block_length/Kb)
@@ -373,9 +381,18 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
       break;
     }
   }
+  if (Zc==0) {
+    printf("ldpc_encoder_orig: could not determine lifting size\n");
+    return(-1);
+  }
 
-  int nind=0;
-  int indlist[1000];
+  Gen_shift_values=choose_generator_matrix(BG,Zc);
+  if (Gen_shift_values==NULL) {
+    printf("ldpc_encoder_orig: could not find generator matrix\n");
+    return(-1);
+  }
+
+  //printf("ldpc_encoder_orig: BG %d, Zc %d, Kb %d\n",BG, Zc, Kb);
 
   // load base graph of generator matrix
   if (BG==1)
@@ -389,19 +406,19 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
     pointer_shift_values=(short *) pointer_shift_values_BG2;
   }
   
-  Gen_shift_values=choose_generator_matrix(BG,Zc);
-  // calculate number of punctured bits
   no_punctured_columns=(int)((nrows-2)*Zc+block_length-block_length*3)/Zc;
-  removed_bit=(nrows-no_punctured_columns-2) * Zc+block_length-(int)(block_length*3);
+  removed_bit=(nrows-no_punctured_columns-2) * Zc+block_length-(block_length*3);
   //printf("%d\n",no_punctured_columns);
   //printf("%d\n",removed_bit);
   // unpack input
-  memset(c,0,sizeof(unsigned char) * Kb * Zc);
+  memset(c,0,sizeof(unsigned char) * ncols * Zc);
+  memset(d,0,sizeof(unsigned char) * nrows * Zc);
 
   for (i=0; i<block_length; i++)
   {
-    c[i] = test_input[i/8]<<(i%8);
-    c[i]=c[i]>>7&1;
+    //c[i] = test_input[i/8]<<(i%8);
+    //c[i]=c[i]>>7&1;
+    c[i]=(test_input[i/8]&(1<<(i&7)))>>(i&7);
   }
 
   // parity check part
@@ -409,16 +426,23 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
   if (gen_code==1)
   {
     char fname[100];
-    sprintf(fname,"ldpc%d_byte.c",Zc);
+    sprintf(fname,"ldpc_BG%d_Zc%d_byte.c",BG,Zc);
     FILE *fd=fopen(fname,"w");
+    AssertFatal(fd!=NULL,"cannot open %s\n",fname);
+    sprintf(fname,"ldpc_BG%d_Zc%d_16bit.c",BG,Zc);
+    FILE *fd2=fopen(fname,"w");
+    AssertFatal(fd2!=NULL,"cannot open %s\n",fname);
+
     int shift;
     char data_type[100];
     char xor_command[100];
     int mask;
 
-    AssertFatal(fd!=NULL,"cannot open %s\n",fname);
+
+
 
     fprintf(fd,"#include \"PHY/sse_intrin.h\"\n");
+    fprintf(fd2,"#include \"PHY/sse_intrin.h\"\n");
 
     if ((Zc&31)==0) {
       shift=5; // AVX2 - 256-bit SIMD
@@ -436,7 +460,7 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
     else if ((Zc&7)==0) {
       shift=3; // MMX  - 64-bit SIMD
       mask=7;
-      strcpy(data_type,"__m64i");
+      strcpy(data_type,"__m64");
       strcpy(xor_command,"_mm_xor_si64"); 
     }
     else {
@@ -445,49 +469,56 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
       strcpy(data_type,"uint8_t");
       strcpy(xor_command,"scalar_xor");
       fprintf(fd,"#define scalar_xor(a,b) ((a)^(b))\n");
+      fprintf(fd2,"#define scalar_xor(a,b) ((a)^(b))\n");
     }
     fprintf(fd,"// generated code for Zc=%d, byte encoding\n",Zc);
-    fprintf(fd,"static inline void ldpc%d_byte(uint8_t *c,uint8_t *d) {\n",Zc);
+    fprintf(fd2,"// generated code for Zc=%d, 16bit encoding\n",Zc);
+    fprintf(fd,"static inline void ldpc_BG%d_Zc%d_byte(uint8_t *c,uint8_t *d) {\n",BG,Zc);
+    fprintf(fd2,"static inline void ldpc_BG%d_Zc%d_16bit(uint16_t *c,uint16_t *d) {\n",BG,Zc);
     fprintf(fd,"  %s *csimd=(%s *)c,*dsimd=(%s *)d;\n\n",data_type,data_type,data_type);
+    fprintf(fd2,"  %s *csimd=(%s *)c,*dsimd=(%s *)d;\n\n",data_type,data_type,data_type);
     fprintf(fd,"  %s *c2,*d2;\n\n",data_type);
+    fprintf(fd2,"  %s *c2,*d2;\n\n",data_type);
     fprintf(fd,"  int i2;\n");
+    fprintf(fd2,"  int i2;\n");
     fprintf(fd,"  for (i2=0; i2<%d; i2++) {\n",Zc>>shift);
+    fprintf(fd2,"  for (i2=0; i2<%d; i2++) {\n",Zc>>(shift-1));
     for (i2=0; i2 < 1; i2++)
     {
-      t=Kb*Zc+i2;
-
-      //rotate matrix here
-      for (i5=0; i5 < Kb; i5++)
-      {
-        temp = c[i5*Zc];
-        memmove(&c[i5*Zc], &c[i5*Zc+1], (Zc-1)*sizeof(unsigned char));
-        c[i5*Zc+Zc-1] = temp;
-      }
+      //t=Kb*Zc+i2;
     
       // calculate each row in base graph
+     
+
       fprintf(fd,"     c2=&csimd[i2];\n");
       fprintf(fd,"     d2=&dsimd[i2];\n");
+      fprintf(fd2,"     c2=&csimd[i2];\n");
+      fprintf(fd2,"     d2=&dsimd[i2];\n");
 
+      for (i1=0; i1 < nrows; i1++)
 
-      for (i1=0; i1 < nrows-no_punctured_columns; i1++)
       {
         channel_temp=0;
         fprintf(fd,"\n//row: %d\n",i1);
+        fprintf(fd2,"\n//row: %d\n",i1);
 	fprintf(fd,"     d2[%d]=",(Zc*i1)>>shift);
+	fprintf(fd2,"     d2[%d]=",(Zc*i1)>>(shift-1));
 
         nind=0;
 
-        for (i3=0; i3 < Kb; i3++)
+        for (i3=0; i3 < ncols; i3++)
         {
           temp_prime=i1 * ncols + i3;
 
+
 	  for (i4=0; i4 < no_shift_values[temp_prime]; i4++)
 	    {
 	          
 	      var=(int)((i3*Zc + (Gen_shift_values[ pointer_shift_values[temp_prime]+i4 ]+1)%Zc)/Zc);
 	      int index =var*2*Zc + (i3*Zc + (Gen_shift_values[ pointer_shift_values[temp_prime]+i4 ]+1)%Zc) % Zc;
 	      
-	      indlist[nind++] = ((index&mask)*((2*Zc)>>shift)*Kb)+(index>>shift);
+	      indlist[nind] = ((index&mask)*((2*Zc)>>shift)*Kb)+(index>>shift);
+	      indlist2[nind++] = ((index&(mask>>1))*((2*Zc)>>(shift-1))*Kb)+(index>>(shift-1));
 	      
 	    }
 	  
@@ -495,20 +526,25 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
         }
 	for (i4=0;i4<nind-1;i4++) {
 	  fprintf(fd,"%s(c2[%d],",xor_command,indlist[i4]);
+	  fprintf(fd2,"%s(c2[%d],",xor_command,indlist2[i4]);
 	}
 	fprintf(fd,"c2[%d]",indlist[i4]);
-	for (i4=0;i4<nind-1;i4++) fprintf(fd,")");
+	fprintf(fd2,"c2[%d]",indlist2[i4]);
+	for (i4=0;i4<nind-1;i4++) { fprintf(fd,")"); fprintf(fd2,")"); }
 	fprintf(fd,";\n");
-        d[t+i1*Zc]=channel_temp;
-        //channel_input[t+i1*Zc]=channel_temp;
+	fprintf(fd2,";\n");
+
       }
       fprintf(fd,"  }\n}\n");
+      fprintf(fd2,"  }\n}\n");
     }
     fclose(fd);
+    fclose(fd2);
   }
   else if(gen_code==0)
   {
-   for (i2=0; i2 < Zc; i2++) {
+    for (i2=0; i2 < Zc; i2++)
+    {
       //t=Kb*Zc+i2;
 
       //rotate matrix here
@@ -523,10 +559,7 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
       for (i1=0; i1 < nrows-no_punctured_columns; i1++)
       {
         channel_temp=0;
-      if (gen_code) {
-	printf("//row: %d\n",i1);
-	printf("d[i2+%d*Zc]=",i1);
-      }
+
         for (i3=0; i3 < Kb; i3++)
         {
           temp_prime=i1 * ncols + i3;
@@ -534,12 +567,9 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
           for (i4=0; i4 < no_shift_values[temp_prime]; i4++)
           {
             channel_temp = channel_temp ^ c[ i3*Zc + Gen_shift_values[ pointer_shift_values[temp_prime]+i4 ] ];
-	  if (gen_code)
-	    printf("c[%d]^", i3*Zc + Gen_shift_values[ pointer_shift_values[temp_prime]+i4 ] );
           }
         }
-      if (gen_code)
-	printf("\n");
+
         d[i2+i1*Zc]=channel_temp;
         //channel_input[t+i1*Zc]=channel_temp;
       }
@@ -548,7 +578,7 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
 
   // information part and puncture columns
   memcpy(&channel_input[0], &c[2*Zc], (block_length-2*Zc)*sizeof(unsigned char));
-  memcpy(&channel_input[block_length-2*Zc], &d[Kb*Zc], ((nrows-no_punctured_columns) * Zc-removed_bit)*sizeof(unsigned char));
+  memcpy(&channel_input[block_length-2*Zc], &d[0], ((nrows-no_punctured_columns) * Zc-removed_bit)*sizeof(unsigned char));
   //memcpy(channel_input,c,Kb*Zc*sizeof(unsigned char));
   return 0;
 }

targets/RT/USER/lte-enb.c

@@ -382,12 +382,15 @@ int wakeup_tx(PHY_VARS_eNB *eNB,RU_proc_t *ru_proc) {
 
   LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
  
+  static int num_busy=0;
+ 
   struct timespec wait;
   wait.tv_sec=0;
   wait.tv_nsec=5000000L;
   
   if (proc_rxtx1->instance_cnt_rxtx == 0) {
     LOG_E(PHY,"Frame %d, subframe %d: TX1 thread busy, dropping\n",proc_rxtx1->frame_rx,proc_rxtx1->subframe_rx);
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DAQ_MBOX,++num_busy);
     return(-1);
   }
   

targets/RT/USER/lte-ru.c

@@ -775,8 +775,6 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
   if (ru == RC.ru[0]) {
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_RU, proc->frame_rx );
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_RU, proc->subframe_rx );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, proc->frame_tx );
-    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_RU, proc->subframe_tx );
   }
   
   if (proc->first_rx == 0) {
@@ -846,6 +844,8 @@ void tx_rf(RU_t *ru) {
       flags = 4; // start of burst and end of burst (only one DL SF between two UL)
   
     
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_RU, proc->frame_tx );
+    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_RU, proc->subframe_tx );
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, (proc->timestamp_tx-ru->openair0_cfg.tx_sample_advance)&0xffffffff );
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );
     // prepare tx buffer pointers