Merge branch develop_nfapi_rm2163 into develop

common/utils/LOG/log.c

@@ -227,6 +227,9 @@ int write_file_matlab(const char *fname,const char *vname,void *data,int length,
   return 0;
 }
 
+/* Statistics info */
+STAT_INFO_t stat_info={0,0,0,0,0,0,0,0,0};
+
 /* get log parameters from configuration file */
 void  log_getconfig(log_t *g_log) {
   char *gloglevel = NULL;
@@ -924,6 +927,57 @@ void close_log_mem(void){
     }
   }
  }
+void output_stat_info(void){
+  time_t t;
+  struct tm *tmp;
+  uint64_t rrc_connected_count_tmp;
+  uint64_t rrc_release_count_tmp;
+  uint64_t memblock_alloc_ok_tmp;
+  uint64_t memblock_free_ok_tmp;
+  uint64_t rf_write_err_tmp;
+  uint64_t rf_read_err_tmp;
+  uint64_t tx_failsafe_tmp;
+ 
+  rrc_connected_count_tmp = stat_info.rrc_connected_count;
+  rrc_release_count_tmp   = stat_info.rrc_release_count;
+  memblock_alloc_ok_tmp   = stat_info.memblock_alloc_ok;
+  memblock_free_ok_tmp    = stat_info.memblock_free_ok;
+  rf_write_err_tmp        = stat_info.rf_write_err;
+  rf_read_err_tmp         = stat_info.rf_read_err;
+  tx_failsafe_tmp         = stat_info.tx_failsafe;
+ 
+  time(&t);
+  tmp = localtime(&t);
+ 
+  LOG_I(RRC,"%d/%02d/%02d %02d:%02d:%02d, connected:%lld, release:%lld, reest:%lld, pdcp_dis:%lld, rlc_dis:%lld, queue_dis:%lld, dlack:%lld, dlnack:%lld, ulcrc_ok:%lld, ulcrc_ng:%lld, memblock_alloc_ok:%lld, memblock_free_ok:%lld, rf_write_err:%lld, rf_read_err:%lld, tx_failsafe:%lld\n", 
+    1900 + tmp->tm_year, 1 + tmp->tm_mon, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
+    stat_info.rrc_connected_count,
+    stat_info.rrc_release_count,
+    stat_info.rrc_reest_count,
+    stat_info.pdcp_discard,
+    stat_info.rlc_discard,
+    stat_info.queue_discard_count,
+    stat_info.dlack_count,
+    stat_info.dlnack_count,
+    stat_info.ul_crcchk_ok,
+    stat_info.ul_crcchk_ng,
+    stat_info.memblock_alloc_ok,
+    stat_info.memblock_free_ok,
+    stat_info.rf_write_err,
+    stat_info.rf_read_err,
+    stat_info.tx_failsafe);
+
+  memset(&stat_info, 0, sizeof(STAT_INFO_t));
+  stat_info.rrc_connected_count = rrc_connected_count_tmp;
+  stat_info.rrc_release_count   = rrc_release_count_tmp;
+  stat_info.memblock_alloc_ok   = memblock_alloc_ok_tmp;
+  stat_info.memblock_free_ok    = memblock_free_ok_tmp;
+  stat_info.rf_write_err        = rf_write_err_tmp;
+  stat_info.rf_read_err         = rf_read_err_tmp;
+  stat_info.tx_failsafe         = tx_failsafe_tmp;
+
+  return;
+}
 
 #ifdef LOG_TEST
 

common/utils/LOG/log.h

@@ -317,6 +317,26 @@ typedef struct {
   int enable_flag;
 } log_mem_cnt_t;
 
+// Statistics_info
+typedef struct STAT_INFO {
+  uint64_t rrc_connected_count;   /* Number of RRC_CONNECTED UEs    */
+  uint64_t rrc_release_count;     /* Number of RRC_Release count    */
+  uint64_t rrc_reest_count;       /* Number of RRC_Reestablishment  */
+  uint64_t memblock_alloc_ok;     /* Number of memblock alloc OK    */
+  uint64_t memblock_free_ok;     /* Number of  memblock free  OK    */
+  uint64_t pdcp_discard;          /* Number of PDCP discard         */
+  uint64_t rlc_discard;           /* Number of RLC  discard         */
+  uint64_t queue_discard_count;   /* Number of queue buffer discard */
+  uint64_t dlack_count;           /* Number of DL ACK               */
+  uint64_t dlnack_count;          /* Number of DL NACK              */
+  uint64_t ul_crcchk_ok;          /* Number of UL CRC Check OK      */
+  uint64_t ul_crcchk_ng;          /* Number of UL CRC Check NG      */
+  uint64_t rf_write_err;          /* Number of RF Write Err         */
+  uint64_t rf_read_err;           /* Number of RF Read  Err         */
+  uint64_t tx_failsafe;           /* Number of RF TX Failsafe       */
+} STAT_INFO_t;
+
+extern STAT_INFO_t stat_info;
 
 /* @}*/
 

openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c

@@ -1506,6 +1506,11 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc,
   // Do ULSCH Decoding for data portion
 
   ret = ulsch_decoding_data_all(eNB,UE_id,harq_pid,llr8_flag);
+  if (ret == 5){
+    stat_info.ul_crcchk_ng++;
+  } else {
+    stat_info.ul_crcchk_ok++;
+  }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING0+harq_pid,0);
 

openair2/LAYER2/MAC/eNB_scheduler_primitives.c

@@ -3580,9 +3580,11 @@ extract_harq(module_id_t mod_idP, int CC_idP, int UE_id,
          if(harq_indication_tdd->harq_data[0].bundling.value_0==1){ //ack
            sched_ctl->round[CC_idP][harq_pid] = 8; // release HARQ process
            sched_ctl->tbcnt[CC_idP][harq_pid] = 0;
+           stat_info.dlack_count++;  // Statistics info (DL ACK)
            LOG_D(MAC,"frame %d subframe %d Acking (%d,%d) harq_pid %d round %d\n",frameP,subframeP,frame_tx,subframe_tx,harq_pid,sched_ctl->round[CC_idP][harq_pid]);
          }else{ //nack
 	   if( sched_ctl->round[CC_idP][harq_pid]<8) sched_ctl->round[CC_idP][harq_pid]++;
+           stat_info.dlnack_count++;  // Statistics info (DL NACK)
            if (sched_ctl->round[CC_idP][harq_pid] == 4) {
              sched_ctl->round[CC_idP][harq_pid] = 8;     // release HARQ process
              sched_ctl->tbcnt[CC_idP][harq_pid] = 0;
@@ -3682,6 +3684,7 @@ extract_harq(module_id_t mod_idP, int CC_idP, int UE_id,
 	if (pdu[0] == 1) {	// ACK
 	  sched_ctl->round[CC_idP][harq_pid] = 8;	// release HARQ process
 	  sched_ctl->tbcnt[CC_idP][harq_pid] = 0;
+          stat_info.dlack_count++;  // Statistics info (DL ACK)
 	} else if (pdu[0] == 2 || pdu[0] == 4) {	// NAK (treat DTX as NAK)
 	  sched_ctl->round[CC_idP][harq_pid]++;	// increment round
           if (sched_ctl->round[CC_idP][harq_pid] == 4) {
@@ -3698,6 +3701,7 @@ extract_harq(module_id_t mod_idP, int CC_idP, int UE_id,
             }
            }
           }
+        stat_info.dlnack_count++;  // Statistics info (DL NACK)
         }
       } else {
 	// one or two ACK/NAK bits

openair2/LAYER2/PDCP_v10.1.0/pdcp.c

@@ -195,6 +195,7 @@ boolean_t pdcp_data_req(
       rlc_status = RLC_OP_STATUS_OUT_OF_RESSOURCES;
       LOG_W(PDCP,PROTOCOL_CTXT_FMT" PDCP_DATA_REQ SDU DROPPED, OUT OF MEMORY \n",
             PROTOCOL_CTXT_ARGS(ctxt_pP));
+      stat_info.pdcp_discard++;
 #if defined(STOP_ON_IP_TRAFFIC_OVERLOAD)
       AssertFatal(0, PROTOCOL_CTXT_FMT"[RB %u] PDCP_DATA_REQ SDU DROPPED, OUT OF MEMORY \n",
                   PROTOCOL_CTXT_ARGS(ctxt_pP),
@@ -343,7 +344,7 @@ boolean_t pdcp_data_req(
       //util_flush_hex_octets(PDCP, (unsigned char*)pdcp_pdu->data, pdcp_pdu_size);
     } else {
       LOG_E(PDCP, "Cannot create a mem_block for a PDU!\n");
-
+      stat_info.pdcp_discard++;
       if (ctxt_pP->enb_flag == ENB_FLAG_NO) {
         stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_req);
       } else {
@@ -831,8 +832,8 @@ pdcp_data_ind(
              sdu_buffer_sizeP - payload_offset);
       list_add_tail_eurecom (new_sdu_p, sdu_list_p);
 
-      
-      
+    } else {  
+      stat_info.pdcp_discard++;
     }
 
   /* Print octets of incoming data in hexadecimal form */

openair2/LAYER2/PDCP_v10.1.0/pdcp_control_primitive.c

@@ -45,7 +45,10 @@ configure_pdcp_req (struct pdcp_entity *pdcpP, void *rlcP, uint8_t rlc_sap_typeP
   mem_block      *mb;
 
   mb = get_free_mem_block (sizeof (struct cpdcp_primitive), __func__);
-  if(mb==NULL) return;
+  if(mb==NULL) {
+    stat_info.pdcp_discard++;
+    return;
+  }
   ((struct cpdcp_primitive *) mb->data)->type = CPDCP_CONFIG_REQ;
   ((struct cpdcp_primitive *) mb->data)->primitive.config_req.rlc_sap = rlcP;
   ((struct cpdcp_primitive *) mb->data)->primitive.config_req.rlc_type_sap = rlc_sap_typeP;

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c

@@ -56,6 +56,7 @@ rlc_am_reassembly (
 
     //assert(rlc_pP->output_sdu_in_construction != NULL);
     if(rlc_pP->output_sdu_in_construction == NULL) {
+      stat_info.rlc_discard++;
       LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PAYLOAD] output_sdu_in_construction is NULL\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
       return;

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c

@@ -260,7 +260,10 @@ mem_block_t* rlc_am_retransmit_get_copy (
   /* We need to allocate a new buffer and copy to it because header content may change for Polling bit */
   int size             = pdu_mngt->header_and_payload_size + sizeof(struct mac_tb_req);
   mem_block_t* mb_copy = get_free_mem_block(size, __func__);
-  if(mb_copy == NULL) return NULL;
+  if(mb_copy == NULL) {
+    stat_info.rlc_discard++;
+    return NULL;
+  }
   memcpy(mb_copy->data, mb_original_p->data, size);
 
   rlc_am_pdu_sn_10_t *pdu_p                         = (rlc_am_pdu_sn_10_t*) (&mb_copy->data[sizeof(struct mac_tb_req)]);
@@ -365,7 +368,10 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 		*payload_sizeP = retx_so_stop - retx_so_start + 1;
 
 		mem_pdu_segment_p = get_free_mem_block((*payload_sizeP + RLC_AM_PDU_SEGMENT_HEADER_MIN_SIZE + sizeof(struct mac_tb_req)), __func__);
-		if(mem_pdu_segment_p == NULL) return NULL;
+		if(mem_pdu_segment_p == NULL) {
+                  stat_info.rlc_discard++;
+                  return NULL;
+                }
 		pdu_segment_header_p        = (uint8_t *)&mem_pdu_segment_p->data[sizeof(struct mac_tb_req)];
 		((struct mac_tb_req*)(mem_pdu_segment_p->data))->data_ptr = pdu_segment_header_p;
 		((struct mac_tb_req*)(mem_pdu_segment_p->data))->tb_size = RLC_AM_PDU_SEGMENT_HEADER_MIN_SIZE + *payload_sizeP;
@@ -626,7 +632,10 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 				header_segment_length,*payload_sizeP,pdu_mngt->header_and_payload_size,sn,rlc_pP->channel_id);
 */
 		mem_pdu_segment_p = get_free_mem_block((*payload_sizeP + header_segment_length + sizeof(struct mac_tb_req)), __func__);
-		if(mem_pdu_segment_p == NULL) return NULL;
+		if(mem_pdu_segment_p == NULL) {
+                 stat_info.rlc_discard++;
+                 return NULL;
+                }
 		pdu_segment_header_p        = (uint8_t *)&mem_pdu_segment_p->data[sizeof(struct mac_tb_req)];
 		((struct mac_tb_req*)(mem_pdu_segment_p->data))->data_ptr = pdu_segment_header_p;
 		((struct mac_tb_req*)(mem_pdu_segment_p->data))->tb_size = header_segment_length + *payload_sizeP;

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c

@@ -336,7 +336,9 @@ mem_block_t * create_new_segment_from_pdu(
 		((struct mac_tb_ind *) (new_segment_p->data))->data_ptr = (uint8_t*)&new_segment_p->data[sizeof (mac_rlc_max_rx_header_size_t)];
 		((struct mac_tb_ind *) (new_segment_p->data))->size = data_length_to_copy + header_size;
 		memcpy(pdu_new_segment_info_p->payload,pdu_rx_info_p->payload + so_offset,data_length_to_copy);
-	}
+	} else {
+          stat_info.rlc_discard++;
+        }
 
 	return new_segment_p;
 }

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c

@@ -212,6 +212,7 @@ void rlc_am_segment_10 (
         LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEGMENT] ERROR COULD NOT GET NEW PDU, EXIT\n",
               PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
         RLC_AM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus);
+        stat_info.rlc_discard++;
         return;
       }
 

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c

@@ -730,8 +730,10 @@ rlc_am_send_status_pdu(
         pdu_size);
   tb_p = get_free_mem_block(sizeof(struct mac_tb_req) + pdu_size, __func__);
 
-  if(tb_p == NULL) return;
-
+  if(tb_p == NULL) {
+    stat_info.rlc_discard++;
+    return;
+  }
   memset(tb_p->data, 0, sizeof(struct mac_tb_req) + pdu_size);
   //estimation only ((struct mac_tb_req*)(tb_p->data))->tb_size  = pdu_size;
   ((struct mac_tb_req *)(tb_p->data))->data_ptr         = (uint8_t *)&(tb_p->data[sizeof(struct mac_tb_req)]);

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c

@@ -78,6 +78,7 @@ rlc_tm_send_sdu (
     rlc_pP->output_sdu_in_construction = NULL;
   } else {
     LOG_D (RLC,"[RLC_TM %p][SEND_SDU] ERROR  OUTPUT SDU IS NULL\n", rlc_pP);
+    stat_info.rlc_discard++;
   }
 }
 //-----------------------------------------------------------------------------
@@ -100,6 +101,7 @@ rlc_tm_no_segment (
     if (!(pdu_p = get_free_mem_block (((rlc_pP->rlc_pdu_size + 7) >> 3) + sizeof (struct rlc_tm_tx_data_pdu_struct) + GUARD_CRC_LIH_SIZE, __func__))) {
       LOG_D(RLC, PROTOCOL_RLC_TM_CTXT_FMT"[SEGMENT] ERROR COULD NOT GET NEW PDU, EXIT\n",
             PROTOCOL_RLC_TM_CTXT_ARGS(ctxt_pP, rlc_pP));
+      stat_info.rlc_discard++;
       return;
     }
 

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c

@@ -83,7 +83,10 @@ void rlc_tm_init (
 
   if ((rlcP->input_sdus_alloc == NULL) && (rlcP->size_input_sdus_buffer > 0)) {
     rlcP->input_sdus_alloc = get_free_mem_block (rlcP->size_input_sdus_buffer * sizeof (void *), __func__);
-    if(rlcP->input_sdus_alloc == NULL) return;
+    if(rlcP->input_sdus_alloc == NULL) {
+      stat_info.rlc_discard++;
+      return;
+    }
     rlcP->input_sdus = (mem_block_t **) (rlcP->input_sdus_alloc->data);
     memset (rlcP->input_sdus, 0, rlcP->size_input_sdus_buffer * sizeof (void *));
   }

openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_reassembly.c

@@ -96,6 +96,7 @@ rlc_um_reassembly (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP
   } else {
     LOG_E(RLC, PROTOCOL_RLC_UM_CTXT_FMT"[REASSEMBLY]ERROR  OUTPUT SDU IS NULL\n",
           PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP));
+    stat_info.rlc_discard++;
 #if STOP_ON_IP_TRAFFIC_OVERLOAD
     AssertFatal(0, PROTOCOL_RLC_UM_CTXT_FMT" RLC_UM_DATA_IND, SDU DROPPED, OUT OF MEMORY\n",
                 PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP));

openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_segment.c

@@ -119,6 +119,7 @@ rlc_um_segment_10 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP
               PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP));
 #endif
         RLC_UM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus);
+        stat_info.rlc_discard++;
         return;
       }
 
@@ -509,6 +510,7 @@ rlc_um_segment_5 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP)
               PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP));
 #endif
         RLC_UM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus);
+        stat_info.rlc_discard++;
         return;
       }
 

openair2/LAYER2/RLC/rlc.c

@@ -464,6 +464,7 @@ rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
         } else {
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
           free_mem_block(sdu_pP, __func__);
+          stat_info.rlc_discard++;
           return RLC_OP_STATUS_INTERNAL_ERROR;
         }
 
@@ -496,6 +497,7 @@ rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
         } else {
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
           free_mem_block(sdu_pP, __func__);
+          stat_info.rlc_discard++;
           return RLC_OP_STATUS_INTERNAL_ERROR;
         }
 
@@ -518,6 +520,7 @@ rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
           //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : out of memory\n", __FILE__, __LINE__);
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
           free_mem_block(sdu_pP, __func__);
+          stat_info.rlc_discard++;
           return RLC_OP_STATUS_INTERNAL_ERROR;
         }
 
@@ -551,6 +554,7 @@ rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
         } else {
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
           free_mem_block(sdu_pP, __func__);
+          stat_info.rlc_discard++;
           return RLC_OP_STATUS_BAD_PARAMETER;
         }
       } else {

openair2/LAYER2/RLC/rlc_rrc.c

@@ -890,6 +890,7 @@ rlc_op_status_t rrc_rlc_data_req     (
 #endif
                         );
   } else {
+    stat_info.rlc_discard++;
     return RLC_OP_STATUS_INTERNAL_ERROR;
   }
 }

openair2/RRC/LTE/rrc_eNB.c

@@ -1919,6 +1919,7 @@ rrc_eNB_generate_RRCConnectionRelease(
   ue_context_pP->ue_context.ue_reestablishment_timer = 0;
   ue_context_pP->ue_context.ue_release_timer = 0;
   ue_context_pP->ue_context.ue_rrc_inactivity_timer = 0;
+  stat_info.rrc_release_count++;  //statistics rrc_release count
   LOG_I(RRC,
         PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel DL-DCCH, Generate RRCConnectionRelease (bytes %d)\n",
         PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
@@ -6200,7 +6201,7 @@ rrc_eNB_decode_dcch(
                 ue_context_p);
           } else {
             ue_context_p->ue_context.reestablishment_cause = LTE_ReestablishmentCause_spare1;
-
+            stat_info.rrc_reest_count++;  //statistics rrc_reest count
             for (uint8_t e_rab = 0; e_rab < ue_context_p->ue_context.nb_of_e_rabs; e_rab++) {
               if (ue_context_p->ue_context.e_rab[e_rab].status == E_RAB_STATUS_DONE) {
                 ue_context_p->ue_context.e_rab[e_rab].status = E_RAB_STATUS_ESTABLISHED;
@@ -6346,6 +6347,7 @@ rrc_eNB_decode_dcch(
               ctxt_pP,
               ue_context_p,
               &ul_dcch_msg->message.choice.c1.choice.rrcConnectionSetupComplete.criticalExtensions.choice.c1.choice.rrcConnectionSetupComplete_r8);
+             stat_info.rrc_connected_count++; //statistics rrc_connected count
             LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_CONNECTED \n",
                   PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP));
 

openair2/UTIL/MEM/mem_block.c

@@ -205,6 +205,7 @@ free_mem_block (mem_block_t * leP, const char* caller)
         counters[5],counters[6],counters[7],counters[8],counters[9],
         counters[10],counters[11]);
 #endif
+    stat_info.memblock_free_ok++;
     leP = NULL;                 // this prevent from freeing the block twice
   } else {
     LOG_E (RLC,"[MEM_MNGT][FREE] ERROR free_mem_block() unknown pool_id : %d\n", leP->pool_id);
@@ -265,7 +266,7 @@ get_free_mem_block (uint32_t sizeP, const char* caller)
 #ifdef MEMBLOCK_BIG_LOCK
   if (pthread_mutex_unlock(&mtex)) abort();
 #endif
-
+      stat_info.memblock_alloc_ok++;
       return le;
     }
 
@@ -309,6 +310,7 @@ get_free_copy_mem_block (void)
           counters[5],counters[6],counters[7],counters[8],counters[9],
           counters[10],counters[11]);
 #endif
+    stat_info.memblock_alloc_ok++;
     return le;
   } else {
     LOG_E (RLC,"[MEM_MNGT][ERROR] POOL COPY IS EMPTY\n");

targets/RT/USER/lte-enb.c

@@ -406,6 +406,9 @@ static void* L1_thread( void* param ) {
     T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));
 
     if (wait_on_condition(&proc->mutex,&proc->cond,&proc->instance_cnt,thread_name)<0) break;
+    if (proc->frame_tx == 0 && proc->subframe_tx == 0){
+      output_stat_info();
+    }
 
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_CPUID_ENB_THREAD_RXTX,sched_getcpu());
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 1 );

targets/RT/USER/lte-ru.c

@@ -773,6 +773,7 @@ void rx_rf(RU_t *ru,int *frame,int *subframe) {
 //	      "rx_rf: Asked for %d samples, got %d from SDR\n",fp->samples_per_tti,rxs);
   if(rxs != fp->samples_per_tti){
     LOG_E(PHY,"rx_rf: Asked for %d samples, got %d from SDR\n",fp->samples_per_tti,rxs);
+    stat_info.rf_read_err++;
     late_control=STATE_BURST_TERMINATE;
   }
 
@@ -957,6 +958,7 @@ void tx_rf(RU_t *ru) {
     if( (txs !=  siglen+sf_extension) && (late_control==STATE_BURST_NORMAL) ){ /* add fail safe for late command */
       late_control=STATE_BURST_TERMINATE;
       LOG_E(PHY,"TX : Timeout (sent %d/%d) state =%d\n",txs, siglen,late_control);
+      stat_info.rf_write_err++;
     }
   }
 }
@@ -1217,8 +1219,10 @@ void do_ru_synch(RU_t *ru) {
 				     rxp,
 				     fp->samples_per_tti*10,
 				     ru->nb_rx);
-    if (rxs != fp->samples_per_tti*10) LOG_E(PHY,"requested %d samples, got %d\n",fp->samples_per_tti*10,rxs);
- 
+    if (rxs != fp->samples_per_tti*10) {
+      LOG_E(PHY,"requested %d samples, got %d\n",fp->samples_per_tti*10,rxs);
+      stat_info.rf_read_err++;
+    }
     // wakeup synchronization processing thread
     wakeup_synch(ru);
     ic=0;
@@ -2051,6 +2055,7 @@ static void* eNB_thread_phy_tx( void* param ) {
         }else{
           LOG_E(PHY,"rf tx thread busy, skipping\n");
           late_control=STATE_BURST_TERMINATE;
+          stat_info.tx_failsafe++;
         }
         pthread_mutex_unlock( &ru->proc.mutex_rf_tx );
     }
@@ -2100,6 +2105,7 @@ static void* rf_tx( void* param ) {
     if(proc->instance_cnt_rf_tx >= 0){
       late_control=STATE_BURST_TERMINATE;
       LOG_E(PHY,"detect rf tx busy change mode TX failsafe\n");
+      stat_info.tx_failsafe++;
     }
   }