Add FlexRAN RAN API for slice configuration

adds support for:
* create/remove slices
* change UE-slice association
* read/write slice parameters
* find slice index via ID

openair2/ENB_APP/flexran_agent_ran_api.c

@@ -1381,3 +1381,451 @@ float flexran_get_rrc_neigh_rsrq(mid_t mod_id, mid_t ue_id, int cell_id)
   if (!ue_context_p->ue_context.measResults->measResultNeighCells->choice.measResultListEUTRA.list.array[cell_id]->measResult.rsrqResult) return 0;
   return RSRQ_meas_mapping[*(ue_context_p->ue_context.measResults->measResultNeighCells->choice.measResultListEUTRA.list.array[cell_id]->measResult.rsrqResult)];
 }
+
+int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  int slice_idx = RC.mac[mod_id]->UE_list.assoc_dl_slice_idx[ue_id];
+  if (slice_idx >= 0 && slice_idx < RC.mac[mod_id]->slice_info.n_dl)
+    return RC.mac[mod_id]->slice_info.dl[slice_idx].id;
+  return 0;
+}
+
+void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return;
+  if (flexran_get_ue_crnti(mod_id, ue_id) == NOT_A_RNTI) return;
+  if (!flexran_dl_slice_exists(mod_id, slice_idx)) return;
+  RC.mac[mod_id]->UE_list.assoc_dl_slice_idx[ue_id] = slice_idx;
+}
+
+int flexran_get_ue_ul_slice_id(mid_t mod_id, mid_t ue_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  int slice_idx = RC.mac[mod_id]->UE_list.assoc_ul_slice_idx[ue_id];
+  if (slice_idx >= 0 && slice_idx < RC.mac[mod_id]->slice_info.n_ul)
+    return RC.mac[mod_id]->slice_info.ul[slice_idx].id;
+  return 0;
+}
+
+void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return;
+  if (flexran_get_ue_crnti(mod_id, ue_id) == NOT_A_RNTI) return;
+  if (!flexran_ul_slice_exists(mod_id, slice_idx)) return;
+  RC.mac[mod_id]->UE_list.assoc_ul_slice_idx[ue_id] = slice_idx;
+}
+
+int flexran_dl_slice_exists(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return slice_idx >= 0 && slice_idx < RC.mac[mod_id]->slice_info.n_dl;
+}
+
+int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id, int slice_default_values_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  if (!flexran_dl_slice_exists(mod_id, slice_default_values_idx)) return -1;
+  int newidx = RC.mac[mod_id]->slice_info.n_dl;
+  if (newidx >= MAX_NUM_SLICES) return -1;
+
+  ++RC.mac[mod_id]->slice_info.n_dl;
+  flexran_set_dl_slice_id(mod_id, newidx, slice_id);
+  flexran_set_dl_slice_percentage(mod_id, newidx,
+      flexran_get_dl_slice_percentage(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_isolation(mod_id, newidx,
+      flexran_get_dl_slice_isolation(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_priority(mod_id, newidx,
+      flexran_get_dl_slice_priority(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_position_low(mod_id, newidx,
+      flexran_get_dl_slice_position_low(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_position_high(mod_id, newidx,
+      flexran_get_dl_slice_position_high(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_maxmcs(mod_id, newidx,
+      flexran_get_dl_slice_maxmcs(mod_id, slice_default_values_idx));
+  Protocol__FlexDlSorting *sorting = NULL;
+  int n = flexran_get_dl_slice_sorting(mod_id, slice_default_values_idx, &sorting);
+  flexran_set_dl_slice_sorting(mod_id, newidx, sorting, n);
+  free(sorting);
+  flexran_set_dl_slice_accounting_policy(mod_id, newidx,
+      flexran_get_dl_slice_accounting_policy(mod_id, slice_default_values_idx));
+  flexran_set_dl_slice_scheduler_name(mod_id, newidx,
+      flexran_get_dl_slice_scheduler_name(mod_id, slice_default_values_idx));
+  return newidx;
+}
+
+int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  slice_info_t *sli = &RC.mac[mod_id]->slice_info;
+  int n = sli->n_dl;
+  for (int i = 0; i < n; i++) {
+    if (sli->dl[i].id == slice_id) return i;
+  }
+  return -1;
+}
+
+int flexran_remove_dl_slice(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  slice_info_t *sli = &RC.mac[mod_id]->slice_info;
+  if (sli->n_dl <= 1) return -1;
+
+  --sli->n_dl;
+  /* move last element to the position of the removed one */
+  if (slice_idx != sli->n_dl)
+    memcpy(&sli->dl[slice_idx], &sli->dl[sli->n_dl], sizeof(sli->dl[sli->n_dl]));
+
+  /* all UEs that have been in the old slice are put into slice index 0 */
+  int *assoc_list = RC.mac[mod_id]->UE_list.assoc_dl_slice_idx;
+  for (int i = 0; i < NUMBER_OF_UE_MAX; ++i) {
+    if (assoc_list[i] == slice_idx)
+      assoc_list[i] = 0;
+  }
+  return sli->n_dl;
+}
+
+int flexran_get_num_dl_slices(mid_t mod_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.n_dl;
+}
+
+int flexran_get_intraslice_sharing_active(mid_t mod_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.intraslice_share_active;
+}
+void flexran_set_intraslice_sharing_active(mid_t mod_id, int intraslice_active)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.intraslice_share_active = intraslice_active;
+}
+
+int flexran_get_interslice_sharing_active(mid_t mod_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.interslice_share_active;
+}
+void flexran_set_interslice_sharing_active(mid_t mod_id, int interslice_active)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.interslice_share_active = interslice_active;
+}
+
+slice_id_t flexran_get_dl_slice_id(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].id;
+}
+void flexran_set_dl_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].id = slice_id;
+}
+
+int flexran_get_dl_slice_percentage(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].pct * 100.0f;
+}
+void flexran_set_dl_slice_percentage(mid_t mod_id, int slice_idx, int percentage)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].pct = percentage / 100.0f;
+}
+
+int flexran_get_dl_slice_isolation(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].isol;
+}
+void flexran_set_dl_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].isol = is_isolated;
+}
+
+int flexran_get_dl_slice_priority(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].prio;
+}
+void flexran_set_dl_slice_priority(mid_t mod_id, int slice_idx, int priority)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].prio = priority;
+}
+
+int flexran_get_dl_slice_position_low(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].pos_low;
+}
+void flexran_set_dl_slice_position_low(mid_t mod_id, int slice_idx, int poslow)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].pos_low = poslow;
+}
+
+int flexran_get_dl_slice_position_high(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].pos_high;
+}
+void flexran_set_dl_slice_position_high(mid_t mod_id, int slice_idx, int poshigh)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].pos_high = poshigh;
+}
+
+int flexran_get_dl_slice_maxmcs(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].maxmcs;
+}
+void flexran_set_dl_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].maxmcs = maxmcs;
+}
+
+int flexran_get_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting **sorting_list)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  if (!(*sorting_list)) {
+    *sorting_list = calloc(CR_NUM, sizeof(Protocol__FlexDlSorting));
+    if (!(*sorting_list)) return -1;
+  }
+  uint32_t policy = RC.mac[mod_id]->slice_info.dl[slice_idx].sorting;
+  for (int i = 0; i < CR_NUM; i++) {
+    switch (policy >> 4 * (CR_NUM - 1 - i) & 0xF) {
+    case CR_ROUND:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_ROUND;
+      break;
+    case CR_SRB12:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_SRB12;
+      break;
+    case CR_HOL:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_HOL;
+      break;
+    case CR_LC:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_LC;
+      break;
+    case CR_CQI:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_CQI;
+      break;
+    case CR_LCP:
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_LCP;
+      break;
+    default:
+      /* this should not happen, but a "default" */
+      (*sorting_list)[i] = PROTOCOL__FLEX_DL_SORTING__CR_ROUND;
+      break;
+    }
+  }
+  return CR_NUM;
+}
+void flexran_set_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting *sorting_list, int n)
+{
+  if (!mac_is_present(mod_id)) return;
+  uint32_t policy = 0;
+  for (int i = 0; i < n && i < CR_NUM; i++) {
+    switch (sorting_list[i]) {
+    case PROTOCOL__FLEX_DL_SORTING__CR_ROUND:
+      policy = policy << 4 | CR_ROUND;
+      break;
+    case PROTOCOL__FLEX_DL_SORTING__CR_SRB12:
+      policy = policy << 4 | CR_SRB12;
+      break;
+    case PROTOCOL__FLEX_DL_SORTING__CR_HOL:
+      policy = policy << 4 | CR_HOL;
+      break;
+    case PROTOCOL__FLEX_DL_SORTING__CR_LC:
+      policy = policy << 4 | CR_LC;
+      break;
+    case PROTOCOL__FLEX_DL_SORTING__CR_CQI:
+      policy = policy << 4 | CR_CQI;
+      break;
+    case PROTOCOL__FLEX_DL_SORTING__CR_LCP:
+      policy = policy << 4 | CR_LCP;
+      break;
+    default: /* suppresses warnings */
+      policy = policy << 4 | CR_ROUND;
+      break;
+    }
+  }
+  /* fill up with 0 == CR_ROUND */
+  if (CR_NUM > n) policy = policy << 4 * (CR_NUM - n);
+  RC.mac[mod_id]->slice_info.dl[slice_idx].sorting = policy;
+}
+
+Protocol__FlexDlAccountingPolicy flexran_get_dl_slice_accounting_policy(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR;
+  switch (RC.mac[mod_id]->slice_info.dl[slice_idx].accounting) {
+  case POL_FAIR:
+    return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR;
+  case POL_GREEDY:
+    return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_GREEDY;
+  default:
+    return PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR;
+  }
+}
+void flexran_set_dl_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__FlexDlAccountingPolicy accounting)
+{
+  if (!mac_is_present(mod_id)) return;
+  switch (accounting) {
+  case PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_FAIR:
+    RC.mac[mod_id]->slice_info.dl[slice_idx].accounting = POL_FAIR;
+    return;
+  case PROTOCOL__FLEX_DL_ACCOUNTING_POLICY__POL_GREEDY:
+    RC.mac[mod_id]->slice_info.dl[slice_idx].accounting = POL_GREEDY;
+    return;
+  default:
+    RC.mac[mod_id]->slice_info.dl[slice_idx].accounting = POL_FAIR;
+    return;
+  }
+}
+
+char *flexran_get_dl_slice_scheduler_name(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return NULL;
+  return RC.mac[mod_id]->slice_info.dl[slice_idx].sched_name;
+}
+void flexran_set_dl_slice_scheduler_name(mid_t mod_id, int slice_idx, char *name)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].sched_name = name;
+  RC.mac[mod_id]->slice_info.dl[slice_idx].update_sched = 1;
+}
+
+int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id, int slice_default_values_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  if (!flexran_ul_slice_exists(mod_id, slice_default_values_idx)) return -1;
+  int newidx = RC.mac[mod_id]->slice_info.n_ul;
+  if (newidx >= MAX_NUM_SLICES) return -1;
+
+  ++RC.mac[mod_id]->slice_info.n_ul;
+  flexran_set_ul_slice_id(mod_id, newidx, slice_id);
+  flexran_set_ul_slice_percentage(mod_id, newidx,
+      flexran_get_ul_slice_percentage(mod_id, slice_default_values_idx));
+  /*flexran_set_ul_slice_isolation(mod_id, newidx,
+      flexran_get_ul_slice_isolation(mod_id, slice_default_values_idx));
+  flexran_set_ul_slice_priority(mod_id, newidx,
+      flexran_get_ul_slice_priority(mod_id, slice_default_values_idx));*/
+  flexran_set_ul_slice_first_rb(mod_id, newidx,
+      flexran_get_ul_slice_first_rb(mod_id, slice_default_values_idx));
+  flexran_set_ul_slice_maxmcs(mod_id, newidx,
+      flexran_get_ul_slice_maxmcs(mod_id, slice_default_values_idx));
+  /*Protocol__FlexUlSorting *sorting = NULL;
+  int n = flexran_get_ul_slice_sorting(mod_id, slice_default_values_idx, &sorting);
+  flexran_set_ul_slice_sorting(mod_id, newidx, sorting, n);
+  free(sorting);*/
+  /*flexran_set_ul_slice_accounting_policy(mod_id, newidx,
+      flexran_get_ul_slice_accounting_policy(mod_id, slice_default_values_idx));*/
+  flexran_set_ul_slice_scheduler_name(mod_id, newidx,
+      flexran_get_ul_slice_scheduler_name(mod_id, slice_default_values_idx));
+  return newidx;
+}
+
+int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  slice_info_t *sli = &RC.mac[mod_id]->slice_info;
+  int n = sli->n_ul;
+  for (int i = 0; i < n; i++) {
+    if (sli->ul[i].id == slice_id) return i;
+  }
+  return -1;
+}
+
+int flexran_remove_ul_slice(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  slice_info_t *sli = &RC.mac[mod_id]->slice_info;
+  if (sli->n_ul <= 1) return -1;
+
+  --sli->n_ul;
+  /* move last element to the position of the removed one */
+  if (slice_idx != sli->n_ul)
+    memcpy(&sli->ul[slice_idx], &sli->ul[sli->n_ul], sizeof(sli->ul[sli->n_ul]));
+
+  /* all UEs that have been in the old slice are put into slice index 0 */
+  int *assoc_list = RC.mac[mod_id]->UE_list.assoc_ul_slice_idx;
+  for (int i = 0; i < NUMBER_OF_UE_MAX; ++i) {
+    if (assoc_list[i] == slice_idx)
+      assoc_list[i] = 0;
+  }
+  return sli->n_ul;
+}
+
+int flexran_get_num_ul_slices(mid_t mod_id)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.n_ul;
+}
+
+int flexran_ul_slice_exists(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return slice_idx >= 0 && slice_idx < RC.mac[mod_id]->slice_info.n_ul;
+}
+
+slice_id_t flexran_get_ul_slice_id(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.ul[slice_idx].id;
+}
+void flexran_set_ul_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].id = slice_id;
+}
+
+int flexran_get_ul_slice_percentage(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.ul[slice_idx].pct * 100.0f;
+}
+void flexran_set_ul_slice_percentage(mid_t mod_id, int slice_idx, int percentage)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].pct = percentage / 100.0f;
+}
+
+int flexran_get_ul_slice_first_rb(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.ul[slice_idx].first_rb;
+}
+
+void flexran_set_ul_slice_first_rb(mid_t mod_id, int slice_idx, int first_rb)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].first_rb = first_rb;
+}
+
+int flexran_get_ul_slice_maxmcs(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return -1;
+  return RC.mac[mod_id]->slice_info.ul[slice_idx].maxmcs;
+}
+void flexran_set_ul_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].maxmcs = maxmcs;
+}
+
+char *flexran_get_ul_slice_scheduler_name(mid_t mod_id, int slice_idx)
+{
+  if (!mac_is_present(mod_id)) return NULL;
+  return RC.mac[mod_id]->slice_info.ul[slice_idx].sched_name;
+}
+void flexran_set_ul_slice_scheduler_name(mid_t mod_id, int slice_idx, char *name)
+{
+  if (!mac_is_present(mod_id)) return;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].sched_name = name;
+  RC.mac[mod_id]->slice_info.ul[slice_idx].update_sched = 1;
+}

openair2/ENB_APP/flexran_agent_ran_api.h

@@ -505,3 +505,155 @@ int flexran_get_rrc_neigh_plmn_mcc(mid_t mod_id, mid_t ue_id, int cell_id); */
 /*Get MNC PLMN identity neighbouring Cell*/
 /* currently not implemented
 int flexran_get_rrc_neigh_plmn_mnc(mid_t mod_id, mid_t ue_id, int cell_id); */
+
+/************************** Slice configuration **************************/
+
+/* Get the DL slice ID for a UE */
+int flexran_get_ue_dl_slice_id(mid_t mod_id, mid_t ue_id);
+
+/* Set the DL slice index(!) for a UE */
+void flexran_set_ue_dl_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
+
+/* Get the UL slice ID for a UE */
+int flexran_get_ue_ul_slice_id(mid_t mod_id, mid_t ue_id);
+
+/* Set the UL slice index(!) for a UE */
+void flexran_set_ue_ul_slice_idx(mid_t mod_id, mid_t ue_id, int slice_idx);
+
+/* Whether intraslice sharing is active, return boolean */
+int flexran_get_intraslice_sharing_active(mid_t mod_id);
+/* Set whether intraslice sharing is active */
+void flexran_set_intraslice_sharing_active(mid_t mod_id, int intraslice_active);
+
+/* Whether intraslice sharing is active, return boolean */
+int flexran_get_interslice_sharing_active(mid_t mod_id);
+/* Set whether intraslice sharing is active */
+void flexran_set_interslice_sharing_active(mid_t mod_id, int interslice_active);
+
+/* Get the number of slices in DL */
+int flexran_get_num_dl_slices(mid_t mod_id);
+
+/* Query slice existence in DL. Return is boolean value */
+int flexran_dl_slice_exists(mid_t mod_id, int slice_idx);
+
+/* Create slice in DL with values from another slice, returns the new slice index */
+int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id, int slice_default_values_idx);
+/* Finds slice in DL with given slice_id and returns slice index */
+int flexran_find_dl_slice(mid_t mod_id, slice_id_t slice_id);
+/* Remove slice in DL, returns new number of slices or -1 on error */
+int flexran_remove_dl_slice(mid_t mod_id, int slice_idx);
+
+/* Get the ID of a slice in DL */
+slice_id_t flexran_get_dl_slice_id(mid_t mod_id, int slice_idx);
+/* Set the ID of a slice in DL */
+void flexran_set_dl_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id);
+
+/* Get the RB share a slice in DL, value 0-100 */
+int flexran_get_dl_slice_percentage(mid_t mod_id, int slice_idx);
+/* Set the RB share a slice in DL, value 0-100 */
+void flexran_set_dl_slice_percentage(mid_t mod_id, int slice_idx, int percentage);
+
+/* Whether a slice in DL is isolated */
+int flexran_get_dl_slice_isolation(mid_t mod_id, int slice_idx);
+/* Set whether a slice in DL is isolated */
+void flexran_set_dl_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated);
+
+/* Get the priority of a slice in DL */
+int flexran_get_dl_slice_priority(mid_t mod_id, int slice_idx);
+/* Get the priority of a slice in DL */
+void flexran_set_dl_slice_priority(mid_t mod_id, int slice_idx, int priority);
+
+/* Get the lower end of the frequency range for the slice positioning in DL */
+int flexran_get_dl_slice_position_low(mid_t mod_id, int slice_idx);
+/* Set the lower end of the frequency range for the slice positioning in DL */
+void flexran_set_dl_slice_position_low(mid_t mod_id, int slice_idx, int poslow);
+
+/* Get the higher end of the frequency range for the slice positioning in DL */
+int flexran_get_dl_slice_position_high(mid_t mod_id, int slice_idx);
+/* Set the higher end of the frequency range for the slice positioning in DL */
+void flexran_set_dl_slice_position_high(mid_t mod_id, int slice_idx, int poshigh);
+
+/* Get the maximum MCS for slice in DL */
+int flexran_get_dl_slice_maxmcs(mid_t mod_id, int slice_idx);
+/* Set the maximum MCS for slice in DL */
+void flexran_set_dl_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs);
+
+/* Get the sorting order of a slice in DL, return value is number of elements
+ * in sorting_list */
+int flexran_get_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting **sorting_list);
+/* Set the sorting order of a slice in DL */
+void flexran_set_dl_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexDlSorting *sorting_list, int n);
+
+/* Get the accounting policy for a slice in DL */
+Protocol__FlexDlAccountingPolicy flexran_get_dl_slice_accounting_policy(mid_t mod_id, int slice_idx);
+/* Set the accounting policy for a slice in DL */
+void flexran_set_dl_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__FlexDlAccountingPolicy accounting);
+
+/* Get the scheduler name for a slice in DL */
+char *flexran_get_dl_slice_scheduler_name(mid_t mod_id, int slice_idx);
+/* Set the scheduler name for a slice in DL */
+void flexran_set_dl_slice_scheduler_name(mid_t mod_id, int slice_idx, char *name);
+
+/* Get the number of slices in UL */
+int flexran_get_num_ul_slices(mid_t mod_id);
+
+/* Query slice existence in UL. Return is boolean value */
+int flexran_ul_slice_exists(mid_t mod_id, int slice_idx);
+
+/* Create slice in UL with values from another slice, returns the new slice index */
+int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id, int slice_default_values_idx);
+/* Finds slice in UL with given slice_id and returns slice index */
+int flexran_find_ul_slice(mid_t mod_id, slice_id_t slice_id);
+/* Remove slice in UL */
+int flexran_remove_ul_slice(mid_t mod_id, int slice_idx);
+
+/* Get the ID of a slice in UL */
+slice_id_t flexran_get_ul_slice_id(mid_t mod_id, int slice_idx);
+/* Set the ID of a slice in UL */
+void flexran_set_ul_slice_id(mid_t mod_id, int slice_idx, slice_id_t slice_id);
+
+/* Get the RB share a slice in UL, value 0-100 */
+int flexran_get_ul_slice_percentage(mid_t mod_id, int slice_idx);
+/* Set the RB share a slice in UL, value 0-100 */
+void flexran_set_ul_slice_percentage(mid_t mod_id, int slice_idx, int percentage);
+
+/* TODO Whether a slice in UL is isolated */
+/*int flexran_get_ul_slice_isolation(mid_t mod_id, int slice_idx);*/
+/* TODO Set whether a slice in UL is isolated */
+/*void flexran_set_ul_slice_isolation(mid_t mod_id, int slice_idx, int is_isolated);*/
+
+/* TODO Get the priority of a slice in UL */
+/*int flexran_get_ul_slice_priority(mid_t mod_id, int slice_idx);*/
+/* TODO Set the priority of a slice in UL */
+/*void flexran_set_ul_slice_priority(mid_t mod_id, int slice_idx, int priority);*/
+
+/* Get the first RB for allocation in a slice in UL */
+int flexran_get_ul_slice_first_rb(mid_t mod_id, int slice_idx);
+/* Set the first RB for allocation in a slice in UL */
+void flexran_set_ul_slice_first_rb(mid_t mod_id, int slice_idx, int first_rb);
+
+/* TODO Get the number of RB for the allocation in a slice in UL */
+/*int flexran_get_ul_slice_length_rb(mid_t mod_id, int slice_idx);*/
+/* TODO Set the of number of RB for the allocation in a slice in UL */
+/*void flexran_set_ul_slice_length_rb(mid_t mod_id, int slice_idx, int poshigh);*/
+
+/* Get the maximum MCS for slice in UL */
+int flexran_get_ul_slice_maxmcs(mid_t mod_id, int slice_idx);
+/* Set the maximum MCS for slice in UL */
+void flexran_set_ul_slice_maxmcs(mid_t mod_id, int slice_idx, int maxmcs);
+
+/* TODO Get the sorting order of a slice in UL, return value is number of elements
+ * in sorting_list */
+/*int flexran_get_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting **sorting_list);*/
+/* TODO Set the sorting order of a slice in UL */
+/*void flexran_set_ul_slice_sorting(mid_t mod_id, int slice_idx, Protocol__FlexUlSorting *sorting_list, int n);*/
+
+/* TODO Get the accounting policy for a slice in UL */
+/*Protocol__UlAccountingPolicy flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx);*/
+/* TODO Set the accounting policy for a slice in UL */
+/*void flexran_get_ul_slice_accounting_policy(mid_t mod_id, int slice_idx, Protocol__UlAccountingPolicy accountin);*/
+
+/* Get the scheduler name for a slice in UL */
+char *flexran_get_ul_slice_scheduler_name(mid_t mod_id, int slice_idx);
+/* Set the scheduler name for a slice in UL */
+void flexran_set_ul_slice_scheduler_name(mid_t mod_id, int slice_idx, char *name);