Enable multiple RC subscriptions

- create hash table to save ric_req_id (key) and array of ran_param_id(s) (values), per each subscription - create RB tree to store list of ric_req_id(s) for each ran_param_id => when the async event occurs, it is easier and faster to search per ran_param_id and send the indication message to all xApps (ric_req_id(s)) subscribed to the same ran_param_id - it is important to mention that both data structures need to be maintained, especially when unsubscription occurs (free_aperiodic_subscription)
2024-02-07 15:14:27 +01:00
parent 3cc3bbbabc
commit d7ff30db55
5 changed files with 263 additions and 61 deletions
@@ -20,22 +20,41 @@
 */

 #include "ran_func_rc.h"
+#include "ran_func_rc_subs.h"
 #include "ran_func_rc_extern.h"
 #include "../../flexric/test/rnd/fill_rnd_data_rc.h"  // this dependancy will be taken out once RAN Function Definition is implemented
 #include "../../flexric/src/sm/rc_sm/ie/ir/lst_ran_param.h"
 #include "../../flexric/src/sm/rc_sm/ie/ir/ran_param_list.h"
 #include "../../flexric/src/agent/e2_agent_api.h"

-#include <assert.h>
 #include <stdio.h>
-#include <pthread.h>
 #include <unistd.h>
-#include "common/utils/assertions.h"
 #include "common/ran_context.h"

-static const int rrc_state_changed_to = 202;
-static bool subs_rrc_state_change = false;
-static uint32_t ric_req_id = 0;
+static pthread_once_t once_rc_mutex = PTHREAD_ONCE_INIT;
+static rc_subs_data_t rc_subs_data = {0};
+static pthread_mutex_t rc_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void init_once_rc(void)
+{
+  init_rc_subs_data(&rc_subs_data);
+}
+
+void read_rc_setup_sm(void* data)
+{
+  assert(data != NULL);
+//  assert(data->type == RAN_CTRL_V1_3_AGENT_IF_E2_SETUP_ANS_V0);
+  rc_e2_setup_t* rc = (rc_e2_setup_t*)data;
+  rc->ran_func_def = fill_rc_ran_func_def();
+
+  // E2 Setup Request is sent periodically until the connection is established
+  // RC subscritpion data should be initialized only once
+  const int ret = pthread_once(&once_rc_mutex, init_once_rc);
+  DevAssert(ret == 0);
+}
+
+
+RB_PROTOTYPE(ric_id_2_param_id_trees, ric_req_id_s, entries, cmp_ric_req_id);

 static ue_id_e2sm_t fill_ue_id_data(const gNB_RRC_UE_t *rrc_ue_context)
 {
@@ -65,11 +84,11 @@ static ue_id_e2sm_t fill_ue_id_data(const gNB_RRC_UE_t *rrc_ue_context)
      ue_id.gnb.gnb_cu_cp_ue_e1ap_lst[i] = rrc_ue_context->rrc_ue_id;
    }
  } else if (RC.nrrrc[0]->node_type == ngran_gNB_DU) {
-    assert(false && "Cannot access RRC layer in DU\n");
+    assert(false && "RRC state change cannot be triggered from DU\n");
  }

  #elif defined (NGRAN_GNB_CUUP)
-  assert(false && "Cannot access RRC layer in CU-UP\n");
+  assert(false && "RRC state change cannot be triggered from CU-UP\n");

  #endif

@@ -88,7 +107,7 @@ static seq_ran_param_t fill_rrc_state_change_seq_ran(const rc_sm_rrc_state_e rrc
 {
  seq_ran_param_t seq_ran_param = {0};

-  seq_ran_param.ran_param_id = rrc_state_changed_to;
+  seq_ran_param.ran_param_id = RRC_STATE_CHANGED_TO_E2SM_RC_RAN_PARAM_ID;
  seq_ran_param.ran_param_val.type = ELEMENT_KEY_FLAG_FALSE_RAN_PARAMETER_VAL_TYPE;
  seq_ran_param.ran_param_val.flag_false = calloc(1, sizeof(ran_parameter_value_t));
  assert(seq_ran_param.ran_param_val.flag_false != NULL && "Memory exhausted");
@@ -132,34 +151,70 @@ static rc_ind_data_t* fill_ue_rrc_state_change(const gNB_RRC_UE_t *rrc_ue_contex
  return rc_ind;
 }

-
 void signal_rrc_state_changed_to(const gNB_RRC_UE_t *rrc_ue_context, const rc_sm_rrc_state_e rrc_state)
-{
-  AssertFatal(subs_rrc_state_change == true, "xApp should be subscribed to E2 node before sending the RIC INDICATION Message\n");
+{ 
+  pthread_mutex_lock(&rc_mutex);
+  if (rc_subs_data.rb[RRC_STATE_CHANGED_TO_E2SM_RC_RAN_PARAM_ID].rbh_root == NULL) {
+    pthread_mutex_unlock(&rc_mutex);
+    return;
+  }
  
-  rc_ind_data_t* rc_ind_data = fill_ue_rrc_state_change(rrc_ue_context, rrc_state);
+  struct ric_req_id_s *node;
+  RB_FOREACH(node, ric_id_2_param_id_trees, &rc_subs_data.rb[RRC_STATE_CHANGED_TO_E2SM_RC_RAN_PARAM_ID]) {
+    rc_ind_data_t* rc_ind_data = fill_ue_rrc_state_change(rrc_ue_context, rrc_state);

-  async_event_agent_api(ric_req_id, rc_ind_data);
-  printf("Event for RIC Req ID %u generated\n", ric_req_id);
+    // Needs review: memory ownership of the type rc_ind_data_t is transferred to the E2 Agent. Bad
+    async_event_agent_api(node->ric_req_id, rc_ind_data);
+    printf( "Event for RIC Req ID %u generated\n", node->ric_req_id);
+  }
+  
+  pthread_mutex_unlock(&rc_mutex);
 }

-bool read_rc_sm(void* data)
+static void free_aperiodic_subscription(uint32_t ric_req_id)
 {
-  assert(data != NULL);
-//  assert(data->type == RAN_CTRL_STATS_V1_03);
-  assert(0!=0 && "Not implemented");
-
-  return true;
+  remove_rc_subs_data(&rc_subs_data, ric_req_id);
 }

-void read_rc_setup_sm(void* data)
+sm_ag_if_ans_t write_subs_rc_sm(void const* src)
 {
-  assert(data != NULL);
-//  assert(data->type == RAN_CTRL_V1_3_AGENT_IF_E2_SETUP_ANS_V0);
-  rc_e2_setup_t* rc = (rc_e2_setup_t*)data;
-  rc->ran_func_def = fill_rc_ran_func_def();
+  assert(src != NULL); // && src->type == RAN_CTRL_SUBS_V1_03);
+
+  wr_rc_sub_data_t* wr_rc = (wr_rc_sub_data_t*)src;
+
+  assert(wr_rc->rc.ad != NULL && "Cannot be NULL");
+
+  // 9.2.1.2  RIC ACTION DEFINITION IE
+  switch (wr_rc->rc.ad->format) {
+    case FORMAT_1_E2SM_RC_ACT_DEF: {
+      // Parameters to be Reported List
+      // [1-65535]
+      const uint32_t ric_req_id = wr_rc->ric_req_id;
+      arr_ran_param_id_t* arr_ran_param_id = calloc(1, sizeof(arr_ran_param_id_t));
+      assert(arr_ran_param_id != NULL && "Memory exhausted");
+      arr_ran_param_id->len = wr_rc->rc.ad->frmt_1.sz_param_report_def;
+      arr_ran_param_id->ran_param_id = calloc(arr_ran_param_id->len, sizeof(ran_param_id_e));
+
+      const size_t sz = arr_ran_param_id->len;
+      for(size_t i = 0; i < sz; i++) {    
+        arr_ran_param_id->ran_param_id[i] = wr_rc->rc.ad->frmt_1.param_report_def[i].ran_param_id;
+      }
+      insert_rc_subs_data(&rc_subs_data, ric_req_id, arr_ran_param_id);
+      break;
+    }
+  
+    default:
+      AssertFatal(wr_rc->rc.ad->format == FORMAT_1_E2SM_RC_ACT_DEF, "Action Definition Format %d not yet implemented", wr_rc->rc.ad->format);
+  }
+
+  sm_ag_if_ans_t ans = {.type = SUBS_OUTCOME_SM_AG_IF_ANS_V0};
+  ans.subs_out.type = APERIODIC_SUBSCRIPTION_FLRC;
+  ans.subs_out.aper.free_aper_subs = free_aperiodic_subscription;
+
+  return ans;
 }

+
 sm_ag_if_ans_t write_ctrl_rc_sm(void const* data)
 {
  assert(data != NULL);
@@ -205,36 +260,12 @@ sm_ag_if_ans_t write_ctrl_rc_sm(void const* data)
  return ans;
 }

-sm_ag_if_ans_t write_subs_rc_sm(void const* src)
+
+bool read_rc_sm(void* data)
 {
-  assert(src != NULL); // && src->type == RAN_CTRL_SUBS_V1_03);
+  assert(data != NULL);
+//  assert(data->type == RAN_CTRL_STATS_V1_03);
+  assert(0!=0 && "Not implemented");

-  wr_rc_sub_data_t* wr_rc = (wr_rc_sub_data_t*)src;
-
-  ric_req_id = wr_rc->ric_req_id;  // store the ric_req_id to generate asynchronous event
-
-  assert(wr_rc->rc.ad != NULL && "Cannot be NULL");
-
-  // 9.2.1.2  RIC ACTION DEFINITION IE
-  switch (wr_rc->rc.ad->format) {
-    case FORMAT_1_E2SM_RC_ACT_DEF: {
-      // Parameters to be Reported List
-      // [1-65535]
-      for(size_t i = 0; i < wr_rc->rc.ad->frmt_1.sz_param_report_def; i++) {
-        if (wr_rc->rc.ad->frmt_1.param_report_def[i].ran_param_id == rrc_state_changed_to) {
-          subs_rrc_state_change = true;
-        } else {
-          AssertFatal(wr_rc->rc.ad->frmt_1.param_report_def[i].ran_param_id == rrc_state_changed_to, "RAN Parameter ID %d not yet implemented\n", wr_rc->rc.ad->frmt_1.param_report_def[i].ran_param_id);
-        }
-      }
-      break;
-    }
-  
-    default:
-      AssertFatal(wr_rc->rc.ad->format == FORMAT_1_E2SM_RC_ACT_DEF, "Action Definition Format %d not yet implemented", wr_rc->rc.ad->format);
-  }
-
-  sm_ag_if_ans_t ans = {0}; 
-
-  return ans;
+  return true;
 }