Add Custom FlexRIC E2 Service Models

Co-authored-by: Teodora Vladic <teodora.vladic@openairinterface.org>

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt

@@ -15,3 +15,4 @@ add_library(e2_ran_func_cust STATIC
   ../../flexric/src/util/time_now_us.c
           )
 
+target_link_libraries(e2_ran_func_cust PUBLIC asn1_nr_rrc nr_rrc asn1_nr_rrc_hdrs)

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c

 #include "ran_func_gtp.h"
-#include "../../flexric/test/rnd/fill_rnd_data_gtp.h"
+#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_gtp.h"
 #include <assert.h>
 
+static
+const int mod_id = 0;
+
 void read_gtp_sm(void * data)
 {
   assert(data != NULL);
 
   gtp_ind_data_t* gtp = (gtp_ind_data_t*)(data);
-  fill_gtp_ind_data(gtp);
+  //fill_gtp_ind_data(gtp);
+
+  gtp->msg.tstamp = time_now_us();
+
+  NR_UEs_t *UE_info = &RC.nrmac[mod_id]->UE_info;
+  size_t num_ues = 0;
+  UE_iterator(UE_info->list, ue) {
+    if (ue)
+      num_ues += 1;
+  }
+
+  gtp->msg.len = num_ues;
+  if(gtp->msg.len > 0){
+    gtp->msg.ngut = calloc(gtp->msg.len, sizeof(gtp_ngu_t_stats_t) );
+    assert(gtp->msg.ngut != NULL);
+  }
+
+  size_t i = 0;
+  UE_iterator(UE_info->list, UE)
+  {
+    uint16_t const rnti = UE->rnti;
+    struct rrc_gNB_ue_context_s *ue_context_p = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[mod_id], rnti);
+    if (ue_context_p != NULL) {
+      gtp->msg.ngut[i].rnti = ue_context_p->ue_context.rnti;
+      int nb_pdu_session = ue_context_p->ue_context.nb_of_pdusessions;
+      if (nb_pdu_session > 0) {
+        int nb_pdu_idx = nb_pdu_session - 1;
+        gtp->msg.ngut[i].teidgnb = ue_context_p->ue_context.pduSession[nb_pdu_idx].param.gNB_teid_N3;
+        gtp->msg.ngut[i].teidupf = ue_context_p->ue_context.pduSession[nb_pdu_idx].param.UPF_teid_N3;
+        // TODO: one PDU session has multiple QoS Flow
+        int nb_qos_flow = ue_context_p->ue_context.pduSession[nb_pdu_idx].param.nb_qos;
+        if (nb_qos_flow > 0) {
+          gtp->msg.ngut[i].qfi = ue_context_p->ue_context.pduSession[nb_pdu_idx].param.qos[nb_qos_flow - 1].qfi;
+        }
+      }
+    } else {
+      LOG_W(NR_RRC,"rrc_gNB_get_ue_context return NULL\n");
+      // if (gtp->msg.ngut != NULL) free(gtp->msg.ngut);
+    }
+    i++;
+  }
+
 }
 
 void read_gtp_setup_sm(void* data)
@@ -21,4 +65,3 @@ sm_ag_if_ans_t write_ctrl_gtp_sm(void const* src)
   assert(src != NULL);
   assert(0 !=0 && "Not supported");
 }
-

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h

 #ifndef RAN_FUNC_SM_GTP_READ_WRITE_AGENT_H
 #define RAN_FUNC_SM_GTP_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
+#include "common/ran_context.h"
+#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "openair2/E2AP/flexric/src/util/time_now_us.h"
+#include "openair2/RRC/NR/rrc_gNB_UE_context.h"
 
 void read_gtp_sm(void*);
 

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_mac.c

 #include "ran_func_mac.h"
-#include "../../flexric/test/rnd/fill_rnd_data_mac.h"
+#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_mac.h"
 #include <assert.h>
 
+static
+const int mod_id = 0;
+
+
 void read_mac_sm(void* data)
 {
   assert(data != NULL);
 
   mac_ind_data_t* mac = (mac_ind_data_t*)data;
-  fill_mac_ind_data(mac);
+  //fill_mac_ind_data(mac);
+
+  mac->msg.tstamp = time_now_us();
+
+  NR_UEs_t *UE_info = &RC.nrmac[mod_id]->UE_info;
+  size_t num_ues = 0;
+  UE_iterator(UE_info->list, ue) {
+    if (ue)
+      num_ues += 1;
+  }
+
+  mac->msg.len_ue_stats = num_ues;
+  if(mac->msg.len_ue_stats > 0){
+    mac->msg.ue_stats = calloc(mac->msg.len_ue_stats, sizeof(mac_ue_stats_impl_t));
+    assert(mac->msg.ue_stats != NULL && "Memory exhausted" );
+  }
+
+  size_t i = 0; //TODO
+  UE_iterator(UE_info->list, UE) {
+    const NR_UE_sched_ctrl_t* sched_ctrl = &UE->UE_sched_ctrl;
+    mac_ue_stats_impl_t* rd = &mac->msg.ue_stats[i];
+
+    rd->frame = RC.nrmac[mod_id]->frame;
+    rd->slot = RC.nrmac[mod_id]->slot;
+
+    rd->dl_aggr_tbs = UE->mac_stats.dl.total_bytes;
+    rd->ul_aggr_tbs = UE->mac_stats.ul.total_bytes;
+
+    if (is_xlsch_in_slot(RC.nrmac[mod_id]->dlsch_slot_bitmap[rd->slot / 64], rd->slot)) {
+      rd->dl_curr_tbs = UE->mac_stats.dl.current_bytes;
+      rd->dl_sched_rb = UE->mac_stats.dl.current_rbs;
+    }
+    if (is_xlsch_in_slot(RC.nrmac[mod_id]->ulsch_slot_bitmap[rd->slot / 64], rd->slot)) {
+      rd->ul_curr_tbs = UE->mac_stats.ul.current_bytes;
+      rd->ul_sched_rb = sched_ctrl->sched_pusch.rbSize;
+    }
+
+    rd->rnti = UE->rnti;
+    rd->dl_aggr_prb = UE->mac_stats.dl.total_rbs;
+    rd->ul_aggr_prb = UE->mac_stats.ul.total_rbs;
+    rd->dl_aggr_retx_prb = UE->mac_stats.dl.total_rbs_retx;
+    rd->ul_aggr_retx_prb = UE->mac_stats.ul.total_rbs_retx;
+
+    rd->dl_aggr_bytes_sdus = UE->mac_stats.dl.lc_bytes[3];
+    rd->ul_aggr_bytes_sdus = UE->mac_stats.ul.lc_bytes[3];
+
+    rd->dl_aggr_sdus = UE->mac_stats.dl.num_mac_sdu;
+    rd->ul_aggr_sdus = UE->mac_stats.ul.num_mac_sdu;
+
+    rd->pusch_snr = (float) sched_ctrl->pusch_snrx10 / 10; //: float = -64;
+    rd->pucch_snr = (float) sched_ctrl->pucch_snrx10 / 10; //: float = -64;
+
+    rd->wb_cqi = sched_ctrl->CSI_report.cri_ri_li_pmi_cqi_report.wb_cqi_1tb;
+    rd->dl_mcs1 = sched_ctrl->dl_bler_stats.mcs;
+    rd->dl_bler = sched_ctrl->dl_bler_stats.bler;
+    rd->ul_mcs1 = sched_ctrl->ul_bler_stats.mcs;
+    rd->ul_bler = sched_ctrl->ul_bler_stats.bler;
+    rd->dl_mcs2 = 0;
+    rd->ul_mcs2 = 0;
+    rd->phr = sched_ctrl->ph;
+
+    const uint32_t bufferSize = sched_ctrl->estimated_ul_buffer - sched_ctrl->sched_ul_bytes;
+    rd->bsr = bufferSize;
+
+    const size_t numDLHarq = 4;
+    rd->dl_num_harq = numDLHarq;
+    for (uint8_t j = 0; j < numDLHarq; ++j)
+      rd->dl_harq[j] = UE->mac_stats.dl.rounds[j];
+    rd->dl_harq[numDLHarq] = UE->mac_stats.dl.errors;
+
+    const size_t numUlHarq = 4;
+    rd->ul_num_harq = numUlHarq;
+    for (uint8_t j = 0; j < numUlHarq; ++j)
+      rd->ul_harq[j] = UE->mac_stats.ul.rounds[j];
+    rd->ul_harq[numUlHarq] = UE->mac_stats.ul.errors;
+
+    ++i;
+  }
 }
 
 void read_mac_setup_sm(void* data)

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_mac.h

 #ifndef SM_MAC_READ_WRITE_AGENT_H
 #define SM_MAC_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
+#include "common/ran_context.h"
+#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "openair2/E2AP/flexric/src/util/time_now_us.h"
+
 
 void read_mac_sm(void*);
 

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c

 #include "ran_func_pdcp.h"
-#include "../../flexric/test/rnd/fill_rnd_data_pdcp.h"
+#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_pdcp.h"
 #include <assert.h>
 
+static
+const int mod_id = 0;
+
+static
+    uint32_t num_act_rb(NR_UEs_t* UE_info)
+{
+  assert(UE_info!= NULL);
+
+  uint32_t act_rb = 0;
+  UE_iterator(UE_info->list, UE) {
+    uint16_t const rnti = UE->rnti;
+    for(int rb_id = 1; rb_id < 6; ++rb_id ){
+      nr_rlc_statistics_t rlc = {0};
+      const int srb_flag = 0;
+      const bool rc = nr_rlc_get_statistics(rnti, srb_flag, rb_id, &rlc);
+      if(rc) ++act_rb;
+    }
+  }
+  return act_rb;
+}
+
 void read_pdcp_sm(void* data)
 {
   assert(data != NULL);
   //assert(data->type == PDCP_STATS_V0);
 
   pdcp_ind_data_t* pdcp = (pdcp_ind_data_t*)data;
-  fill_pdcp_ind_data(pdcp);
+  //fill_pdcp_ind_data(pdcp);
+  // TODO: Need to improve, not good
+  if (NODE_IS_CU(RC.nrrrc[mod_id]->node_type)) {
+
+    uint32_t act_rb = 0;
+    struct rrc_gNB_ue_context_s *ue_context_p1 = NULL;
+    RB_FOREACH(ue_context_p1, rrc_nr_ue_tree_s, &RC.nrrrc[mod_id]->rrc_ue_head) {
+      uint16_t const rnti = ue_context_p1->ue_context.rnti;
+      for(int rb_id = 1; rb_id < 6; ++rb_id ){
+        nr_pdcp_statistics_t rb_pdcp = {0};
+        const int srb_flag = 0;
+        const bool rc = nr_pdcp_get_statistics(rnti, srb_flag, rb_id, &rb_pdcp);
+        if(rc) ++act_rb;
+      }
+    }
+
+    pdcp->msg.tstamp = time_now_us();
+
+    pdcp->msg.len = act_rb;
+    if (pdcp->msg.len > 0) {
+      pdcp->msg.rb = calloc(pdcp->msg.len, sizeof(pdcp_radio_bearer_stats_t));
+      assert(pdcp->msg.rb != NULL && "Memory exhausted!");
+    }
+
+    size_t i = 0;
+    struct rrc_gNB_ue_context_s *ue_context_p2 = NULL;
+    RB_FOREACH(ue_context_p2, rrc_nr_ue_tree_s, &RC.nrrrc[mod_id]->rrc_ue_head) {
+      // TODO: Need to handel multiple UEs
+      uint16_t const rnti = ue_context_p2->ue_context.rnti;
+
+      for (size_t rb_id = 1; rb_id < 6; ++rb_id) {
+        nr_pdcp_statistics_t rb_pdcp = {0};
+
+        const int srb_flag = 0;
+        const bool rc = nr_pdcp_get_statistics(rnti, srb_flag, rb_id, &rb_pdcp);
+
+        if (!rc) continue;
+
+        pdcp_radio_bearer_stats_t *rd = &pdcp->msg.rb[i];
+
+        rd->txpdu_pkts = rb_pdcp.txpdu_pkts;     /* aggregated number of tx packets */
+        rd->txpdu_bytes = rb_pdcp.txpdu_bytes;    /* aggregated bytes of tx packets */
+        rd->txpdu_sn = rb_pdcp.txpdu_sn;       /* current sequence number of last tx packet (or TX_NEXT) */
+        rd->rxpdu_pkts = rb_pdcp.rxpdu_pkts;     /* aggregated number of rx packets */
+        rd->rxpdu_bytes = rb_pdcp.rxpdu_bytes;    /* aggregated bytes of rx packets */
+        rd->rxpdu_sn = rb_pdcp.rxpdu_sn;       /* current sequence number of last rx packet (or  RX_NEXT) */
+        rd->rxpdu_oo_pkts = rb_pdcp.rxpdu_oo_pkts;       /* aggregated number of out-of-order rx pkts  (or RX_REORD) */
+        rd->rxpdu_oo_bytes = rb_pdcp.rxpdu_oo_bytes; /* aggregated amount of out-of-order rx bytes */
+        rd->rxpdu_dd_pkts = rb_pdcp.rxpdu_dd_pkts;  /* aggregated number of duplicated discarded packets (or dropped packets because of other reasons such as integrity failure) (or RX_DELIV) */
+        rd->rxpdu_dd_bytes = rb_pdcp.rxpdu_dd_bytes; /* aggregated amount of discarded packets' bytes */
+        rd->rxpdu_ro_count = rb_pdcp.rxpdu_ro_count; /* this state variable indicates the COUNT value following the COUNT value associated with the PDCP Data PDU which triggered t-Reordering. (RX_REORD) */
+        rd->txsdu_pkts = rb_pdcp.txsdu_pkts;     /* number of SDUs delivered */
+        rd->txsdu_bytes = rb_pdcp.txsdu_bytes;    /* number of bytes of SDUs delivered */
+        rd->rxsdu_pkts = rb_pdcp.rxsdu_pkts;     /* number of SDUs received */
+        rd->rxsdu_bytes = rb_pdcp.rxsdu_bytes;    /* number of bytes of SDUs received */
+        rd->rnti = rnti;
+        rd->mode = rb_pdcp.mode;               /* 0: PDCP AM, 1: PDCP UM, 2: PDCP TM */
+        rd->rbid = rb_id;
+
+        ++i;
+      }
+    }
+  } else {
+
+    //assert(0!=0 && "Calling PDCP");
+    // for the moment and while we don't have a split base station, we use the
+    // MAC structures to obtain the RNTIs which we use to query the PDCP
+    NR_UEs_t *UE_info = &RC.nrmac[mod_id]->UE_info;
+    uint32_t const act_rb = num_act_rb(UE_info);
+
+    pdcp->msg.tstamp = time_now_us();
+
+    pdcp->msg.len = act_rb;
+    if (pdcp->msg.len > 0) {
+      pdcp->msg.rb = calloc(pdcp->msg.len, sizeof(pdcp_radio_bearer_stats_t));
+      assert(pdcp->msg.rb != NULL && "Memory exhausted!");
+    }
+
+    size_t i = 0;
+    UE_iterator(UE_info->list, UE)
+    {
+
+      const int rnti = UE->rnti;
+      for (size_t rb_id = 1; rb_id < 6; ++rb_id) {
+        nr_pdcp_statistics_t rb_pdcp = {0};
+
+        const int srb_flag = 0;
+        const bool rc = nr_pdcp_get_statistics(rnti, srb_flag, rb_id, &rb_pdcp);
+
+        if (!rc) continue;
+
+        pdcp_radio_bearer_stats_t *rd = &pdcp->msg.rb[i];
+
+        rd->txpdu_pkts = rb_pdcp.txpdu_pkts;     /* aggregated number of tx packets */
+        rd->txpdu_bytes = rb_pdcp.txpdu_bytes;    /* aggregated bytes of tx packets */
+        rd->txpdu_sn = rb_pdcp.txpdu_sn;       /* current sequence number of last tx packet (or TX_NEXT) */
+        rd->rxpdu_pkts = rb_pdcp.rxpdu_pkts;     /* aggregated number of rx packets */
+        rd->rxpdu_bytes = rb_pdcp.rxpdu_bytes;    /* aggregated bytes of rx packets */
+        rd->rxpdu_sn = rb_pdcp.rxpdu_sn;       /* current sequence number of last rx packet (or  RX_NEXT) */
+        rd->rxpdu_oo_pkts = rb_pdcp.rxpdu_oo_pkts;       /* aggregated number of out-of-order rx pkts  (or RX_REORD) */
+        rd->rxpdu_oo_bytes = rb_pdcp.rxpdu_oo_bytes; /* aggregated amount of out-of-order rx bytes */
+        rd->rxpdu_dd_pkts = rb_pdcp.rxpdu_dd_pkts;  /* aggregated number of duplicated discarded packets (or dropped packets because of other reasons such as integrity failure) (or RX_DELIV) */
+        rd->rxpdu_dd_bytes = rb_pdcp.rxpdu_dd_bytes; /* aggregated amount of discarded packets' bytes */
+        rd->rxpdu_ro_count = rb_pdcp.rxpdu_ro_count; /* this state variable indicates the COUNT value following the COUNT value associated with the PDCP Data PDU which triggered t-Reordering. (RX_REORD) */
+        rd->txsdu_pkts = rb_pdcp.txsdu_pkts;     /* number of SDUs delivered */
+        rd->txsdu_bytes = rb_pdcp.txsdu_bytes;    /* number of bytes of SDUs delivered */
+        rd->rxsdu_pkts = rb_pdcp.rxsdu_pkts;     /* number of SDUs received */
+        rd->rxsdu_bytes = rb_pdcp.rxsdu_bytes;    /* number of bytes of SDUs received */
+        rd->rnti = rnti;
+        rd->mode = rb_pdcp.mode;               /* 0: PDCP AM, 1: PDCP UM, 2: PDCP TM */
+        rd->rbid = rb_id;
+
+        ++i;
+      }
+    }
+  }
 }
 
 void read_pdcp_setup_sm(void* data)

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h

 #ifndef RAN_FUNC_SM_PDCP_READ_WRITE_AGENT_H
 #define RAN_FUNC_SM_PDCP_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
+#include "common/ran_context.h"
+#include "openair2/RRC/NR/rrc_gNB_UE_context.h"
+#include "openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h"
+#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h"
+#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "openair2/E2AP/flexric/src/util/time_now_us.h"
 
 void read_pdcp_sm(void*);
 

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c

+#include <assert.h>
 #include "ran_func_rlc.h"
-#include "../../flexric/test/rnd/fill_rnd_data_rlc.h"
+#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_rlc.h"
+
+static
+const int mod_id = 0;
+
+static
+uint32_t num_act_rb(NR_UEs_t* const UE_info)
+{
+  assert(UE_info!= NULL);
+
+  uint32_t act_rb = 0;
+  UE_iterator(UE_info->list, UE) {
+    uint16_t const rnti = UE->rnti;
+    for(int rb_id = 1; rb_id < 6; ++rb_id ){
+      nr_rlc_statistics_t rlc = {0};
+      const int srb_flag = 0;
+      const bool rc = nr_rlc_get_statistics(rnti, srb_flag, rb_id, &rlc);
+      if(rc) ++act_rb;
+    }
+  }
+  return act_rb;
+}
+
+static
+void active_avg_to_tx(NR_UEs_t* const UE_info)
+{
+  assert(UE_info!= NULL);
+
+  UE_iterator(UE_info->list, UE) {
+    uint16_t const rnti = UE->rnti;
+    for(int rb_id = 1; rb_id < 6; ++rb_id ){
+      nr_rlc_statistics_t rlc = {0};
+      const int srb_flag = 0;
+      const bool rc = nr_rlc_get_statistics(rnti, srb_flag, rb_id, &rlc);
+      if(rc) nr_rlc_activate_avg_time_to_tx(rnti, rb_id+3, 1);   // rb_id (DRB ID) mapping to logical channel
+    }
+  }
+}
 
 void read_rlc_sm(void* data)
 {
@@ -7,7 +45,94 @@ void read_rlc_sm(void* data)
 //  assert(data->type ==  RLC_STATS_V0);
 
   rlc_ind_data_t* rlc = (rlc_ind_data_t*)data;
-  fill_rlc_ind_data(rlc);
+  //fill_rlc_ind_data(rlc);
+  // use MAC structures to get RNTIs
+  NR_UEs_t *UE_info = &RC.nrmac[mod_id]->UE_info;
+  uint32_t const act_rb = num_act_rb(UE_info);
+
+  //assert(0!=0 && "Read RLC called");
+
+  // activate the rlc to calculate the average tx time
+  active_avg_to_tx(UE_info);
+
+  rlc->msg.len = act_rb;
+  if(rlc->msg.len > 0){
+    rlc->msg.rb = calloc(rlc->msg.len, sizeof(rlc_radio_bearer_stats_t));
+    assert(rlc->msg.rb != NULL && "Memory exhausted");
+  }
+
+  rlc->msg.tstamp = time_now_us();
+
+  uint32_t i = 0;
+  UE_iterator(UE_info->list, UE) {
+    uint16_t const rnti = UE->rnti;
+    //for every LC ID
+    for(int rb_id = 1; rb_id < 6; ++rb_id ){
+
+      nr_rlc_statistics_t rb_rlc = {0};
+      const int srb_flag = 0;
+      const bool rc = nr_rlc_get_statistics(rnti, srb_flag, rb_id, &rb_rlc);
+      if(!rc) continue;
+      rlc_radio_bearer_stats_t* sm_rb = &rlc->msg.rb[i];
+
+      /* TX */
+      sm_rb->txpdu_pkts = rb_rlc.txpdu_pkts;
+      sm_rb->txpdu_bytes =  rb_rlc.txpdu_bytes;        /* aggregated amount of transmitted bytes in RLC PDUs */
+
+      /* TODO? */
+      /* (TO BE DISCUSSED) HOL delay of the packet to be transmitted (RLC delay + MAC delay) */
+      // sm_rb->txpdu_wt_ms += rb_rlc.txsdu_avg_time_to_tx;
+
+      sm_rb->txpdu_dd_pkts = rb_rlc.txpdu_dd_pkts;      /* aggregated number of dropped or discarded tx packets by RLC */
+      sm_rb->txpdu_dd_bytes = rb_rlc.txpdu_dd_bytes;     /* aggregated amount of bytes dropped or discarded tx packets by RLC */
+      sm_rb->txpdu_retx_pkts = rb_rlc.txpdu_retx_pkts;    /* aggregated number of tx pdus/pkts to be re-transmitted (only applicable to RLC AM) */
+      sm_rb->txpdu_retx_bytes = rb_rlc.txpdu_retx_bytes;   /* aggregated amount of bytes to be re-transmitted (only applicable to RLC AM) */
+      sm_rb->txpdu_segmented = rb_rlc.txpdu_segmented;    /* aggregated number of segmentations */
+      sm_rb->txpdu_status_pkts = rb_rlc.txpdu_status_pkts;  /* aggregated number of tx status pdus/pkts (only applicable to RLC AM) */
+      sm_rb->txpdu_status_bytes = rb_rlc.txpdu_status_bytes; /* aggregated amount of tx status bytes  (only applicable to RLC AM) */
+      sm_rb->txbuf_occ_bytes = rb_rlc.txbuf_occ_bytes;    /* (IMPLEMENTED) transmitting bytes currently in buffer */
+      sm_rb->txbuf_occ_pkts = rb_rlc.txbuf_occ_pkts;     /* current tx buffer occupancy in terms of number of packets (average: NOT IMPLEMENTED) */
+
+      /* RX */
+      sm_rb->rxpdu_pkts = rb_rlc.rxpdu_pkts;         /* aggregated number of received RLC PDUs */
+      sm_rb->rxpdu_bytes = rb_rlc.rxpdu_bytes;        /* amount of bytes received by the RLC */
+      sm_rb->rxpdu_dup_pkts = rb_rlc.rxpdu_dup_pkts;     /* aggregated number of duplicate packets */
+      sm_rb->rxpdu_dup_bytes = rb_rlc.rxpdu_dup_bytes;    /* aggregated amount of duplicated bytes */
+      sm_rb->rxpdu_dd_pkts = rb_rlc.rxpdu_dd_pkts;      /* aggregated number of rx packets dropped or discarded by RLC */
+      sm_rb->rxpdu_dd_bytes = rb_rlc.rxpdu_dd_bytes;     /* aggregated amount of rx bytes dropped or discarded by RLC */
+      sm_rb->rxpdu_ow_pkts = rb_rlc.rxpdu_ow_pkts;      /* aggregated number of out of window received RLC pdu */
+      sm_rb->rxpdu_ow_bytes = rb_rlc.rxpdu_ow_bytes;     /* aggregated number of out of window bytes received RLC pdu */
+      sm_rb->rxpdu_status_pkts = rb_rlc.rxpdu_status_pkts;  /* aggregated number of rx status pdus/pkts (only applicable to RLC AM) */
+      sm_rb->rxpdu_status_bytes = rb_rlc.rxpdu_status_bytes; /* aggregated amount of rx status bytes  (only applicable to RLC AM) */
+
+      sm_rb->rxbuf_occ_bytes = rb_rlc.rxbuf_occ_bytes;    /* (IMPLEMENTED) received bytes currently in buffer */
+      sm_rb->rxbuf_occ_pkts = rb_rlc.rxbuf_occ_pkts;     /* current rx buffer occupancy in terms of number of packets (average: NOT IMPLEMENTED) */
+
+      /* TX */
+      sm_rb->txsdu_pkts = rb_rlc.txsdu_pkts;         /* number of SDUs delivered */
+      sm_rb->txsdu_bytes = rb_rlc.txsdu_bytes;        /* (UPDATED) number of SDUs bytes successfully transmitted so far (counter) */
+
+      sm_rb->txsdu_avg_time_to_tx = rb_rlc.txsdu_avg_time_to_tx;    /* (100ms-windowed) per-packet sojourn (SDU to PDU) in microseconds */
+      sm_rb->txsdu_wt_us = rb_rlc.txsdu_wt_us;           /* HOL delay of the current radio bearer */
+
+      /* RX */
+      sm_rb->rxsdu_pkts = rb_rlc.rxsdu_pkts;         /* number of SDUs received */
+      sm_rb->rxsdu_bytes = rb_rlc.rxsdu_bytes;        /* (UPDATED) number of SDUs bytes arrived so far (counter) */
+      sm_rb->rxsdu_dd_pkts = rb_rlc.rxsdu_dd_pkts;      /* number of dropped or discarded SDUs */
+      sm_rb->rxsdu_dd_bytes = rb_rlc.rxsdu_dd_bytes;     /* number of bytes of SDUs dropped or discarded */
+
+      sm_rb->mode = rb_rlc.mode;               /* 0: RLC AM, 1: RLC UM, 2: RLC TM */
+      sm_rb->rnti = rnti;
+      sm_rb->rbid = rb_id;
+
+      LOG_D(RLC, "[E2-AGENT] SDU Goodput & HOL-waittime/200ms-sojourn: %lu/%lu (bytes) & %u/%f (microsecs);\n\
+                             Current Buffer: received %u, transmitting %u (bytes).\n",
+            sm_rb->txsdu_bytes, sm_rb->rxsdu_bytes, sm_rb->txsdu_wt_us, sm_rb->txsdu_avg_time_to_tx,
+            sm_rb->rxbuf_occ_bytes, sm_rb->txbuf_occ_bytes);
+
+      ++i;
+    }
+  }
 }
 
 void read_rlc_setup_sm(void* data)

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h

 #ifndef RAN_FUNC_SM_RLC_READ_WRITE_AGENT_H
 #define RAN_FUNC_SM_RLC_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
+#include "common/ran_context.h"
+#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h"
+#include "openair2/E2AP/flexric/src/util/time_now_us.h"
+
 
 void read_rlc_sm(void*);
 

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_slice.h

 #ifndef RAN_FUNC_SM_SLICE_READ_WRITE_AGENT_H
 #define RAN_FUNC_SM_SLICE_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
 
 void read_slice_sm(void*);
 

openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_tc.h

 #ifndef RAN_FUNC_SM_TC_READ_WRITE_AGENT_H
 #define RAN_FUNC_SM_TC_READ_WRITE_AGENT_H
 
-#include "../../flexric/src/agent/e2_agent_api.h"
+#include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h"
 
 void read_tc_sm(void*);