Remove any slice-related information from OAI

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c

@@ -49,19 +49,6 @@ struct lfds700_misc_prng_state ps[NUM_MAX_ENB];
 struct lfds700_ringbuffer_element *dl_mac_config_array[NUM_MAX_ENB];
 struct lfds700_ringbuffer_state ringbuffer_state[NUM_MAX_ENB];
 
-/* the slice config as kept in the underlying system */
-Protocol__FlexSliceConfig *slice_config[MAX_NUM_SLICES];
-/* a structure that keeps updates which will be reflected in slice_config later */
-Protocol__FlexSliceConfig *sc_update[MAX_NUM_SLICES];
-/* indicates whether sc_update contains new data */
-int perform_slice_config_update_count = 1;
-/* queue of incoming new UE<>slice association commands */
-Protocol__FlexUeConfig *ue_slice_assoc_update[MAX_NUM_SLICES];
-int n_ue_slice_assoc_updates = 0;
-/* mutex for sc_update: do not receive new config and write it at the same time */
-pthread_mutex_t sc_update_mtx = PTHREAD_MUTEX_INITIALIZER;
-
-
 int flexran_agent_mac_stats_reply_ue(mid_t mod_id,
                                     Protocol__FlexUeStatsReport **ue_report,
                                     int      n_ue,

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c

@@ -33,14 +33,6 @@
 #include "flexran_agent_mac_internal.h"
 #include "flexran_agent_mac_slice_verification.h"
 
-/* from flexran_agent_mac.c */
-extern Protocol__FlexSliceConfig *slice_config[MAX_NUM_SLICES];
-extern Protocol__FlexSliceConfig *sc_update[MAX_NUM_SLICES];
-extern int perform_slice_config_update_count;
-extern Protocol__FlexUeConfig *ue_slice_assoc_update[MAX_NUM_SLICES];
-extern int n_ue_slice_assoc_updates;
-extern pthread_mutex_t sc_update_mtx;
-
 Protocol__FlexranMessage * flexran_agent_generate_diff_mac_stats_report(Protocol__FlexranMessage *new_message,
 									Protocol__FlexranMessage *old_message) {
 
@@ -1040,12 +1032,12 @@ Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
   if (!fsc) return NULL;
   protocol__flex_slice_config__init(fsc);
 
-  /* say there are n_dl slices but reserve memory for up to MAX_NUM_SLICES so
+  /* say there are n_dl slices but reserve memory for up to 10 so
    * we don't need to reserve again later */
   fsc->n_dl = n_dl;
-  fsc->dl = calloc(MAX_NUM_SLICES, sizeof(Protocol__FlexDlSlice *));
+  fsc->dl = calloc(10, sizeof(Protocol__FlexDlSlice *));
   if (!fsc->dl) fsc->n_dl = 0;
-  for (i = 0; i < MAX_NUM_SLICES; i++) {
+  for (i = 0; i < 10; i++) {
     fsc->dl[i] = malloc(sizeof(Protocol__FlexDlSlice));
     if (!fsc->dl[i]) continue;
     protocol__flex_dl_slice__init(fsc->dl[i]);
@@ -1053,9 +1045,9 @@ Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul)
 
   /* as above */
   fsc->n_ul = m_ul;
-  fsc->ul = calloc(MAX_NUM_SLICES, sizeof(Protocol__FlexUlSlice *));
+  fsc->ul = calloc(10, sizeof(Protocol__FlexUlSlice *));
   if (!fsc->ul) fsc->n_ul = 0;
-  for (i = 0; i < MAX_NUM_SLICES; i++) {
+  for (i = 0; i < 10; i++) {
     fsc->ul[i] = malloc(sizeof(Protocol__FlexUlSlice));
     if (!fsc->ul[i]) continue;
     protocol__flex_ul_slice__init(fsc->ul[i]);
@@ -1401,8 +1393,8 @@ Protocol__FlexDlSlice *create_new_dl_slice(mid_t mod_id, int id)
         mod_id, id);
   Protocol__FlexDlSlice *to = sc_update[mod_id]->dl[sc_update[mod_id]->n_dl];
   sc_update[mod_id]->n_dl++;
-  AssertFatal(sc_update[mod_id]->n_dl <= MAX_NUM_SLICES,
-              "cannot create more than MAX_NUM_SLICES\n");
+  AssertFatal(sc_update[mod_id]->n_dl <= 10,
+              "cannot create more than 10\n");
   to->id = id;
   return to;
 }
@@ -1468,8 +1460,8 @@ Protocol__FlexUlSlice *create_new_ul_slice(mid_t mod_id, int id)
         mod_id, id);
   Protocol__FlexUlSlice *to = sc_update[mod_id]->ul[sc_update[mod_id]->n_ul];
   sc_update[mod_id]->n_ul++;
-  AssertFatal(sc_update[mod_id]->n_ul <= MAX_NUM_SLICES,
-              "cannot create more than MAX_NUM_SLICES\n");
+  AssertFatal(sc_update[mod_id]->n_ul <= 10,
+              "cannot create more than 10\n");
   to->id = id;
   return to;
 }
@@ -1698,7 +1690,7 @@ int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protoco
 
 void prepare_ue_slice_assoc_update(mid_t mod_id, Protocol__FlexUeConfig *ue_config)
 {
-  if (n_ue_slice_assoc_updates == MAX_NUM_SLICES) {
+  if (n_ue_slice_assoc_updates == 10) {
     LOG_E(FLEXRAN_AGENT,
           "[%d] can not handle flex_ue_config message, buffer is full; try again later\n",
           mod_id);

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c

@@ -132,7 +132,7 @@ int flexran_verify_group_dl_slices(mid_t mod_id, Protocol__FlexDlSlice **existin
     /* else "only" an update */
   }
 
-  if (n < 1 || n > MAX_NUM_SLICES) {
+  if (n < 1 || n > 10) {
     LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting DL slices (%d -> %d)\n",
           mod_id, n_ex, n);
     return 0;
@@ -253,7 +253,7 @@ int flexran_verify_group_ul_slices(mid_t mod_id, Protocol__FlexUlSlice **existin
     /* else "only" an update */
   }
 
-  if (n < 1 || n > MAX_NUM_SLICES) {
+  if (n < 1 || n > 10) {
     LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting UL slices (%d -> %d)\n",
           mod_id, n_ex, n);
     return 0;

openair2/ENB_APP/flexran_agent_ran_api.c

@@ -3015,469 +3015,209 @@ uint32_t flexran_get_rrc_enb_ue_s1ap_id(mid_t mod_id, rnti_t rnti)
 /**************************** SLICING ****************************/
 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 = 0; //RC.mac[mod_id]->UE_info.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_mac_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_info.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 = 0; //RC.mac[mod_id]->UE_info.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_mac_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_info.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;
+  return 0;
 }
 
 int flexran_create_dl_slice(mid_t mod_id, slice_id_t slice_id) {
   if (!mac_is_present(mod_id)) 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);
-  return newidx;
+  return -1;
 }
 
 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;
-
-  if (sli->dl[slice_idx].sched_name) free(sli->dl[slice_idx].sched_name);
-
-  --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]));
-
-  memset(&sli->dl[sli->n_dl], 0, 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_info.assoc_dl_slice_idx;
-
-  //for (int i = 0; i < MAX_MOBILES_PER_ENB; ++i) {
-  //  if (assoc_list[i] == slice_idx)
-  //    assoc_list[i] = 0;
-  //}
-
-  return 1;
+  return -1;
 }
 
 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;
+  return 0;
 }
 
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
-  }
+  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(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;
+  return NULL;
 }
 int flexran_set_dl_slice_scheduler(mid_t mod_id, int slice_idx, char *name) {
   if (!mac_is_present(mod_id)) return 0;
-
-  if (RC.mac[mod_id]->slice_info.dl[slice_idx].sched_name)
-    free(RC.mac[mod_id]->slice_info.dl[slice_idx].sched_name);
-
-  RC.mac[mod_id]->slice_info.dl[slice_idx].sched_name = strdup(name);
-  RC.mac[mod_id]->slice_info.dl[slice_idx].sched_cb = dlsym(NULL, name);
-  return RC.mac[mod_id]->slice_info.dl[slice_idx].sched_cb != NULL;
+  return 0;
 }
 
 int flexran_create_ul_slice(mid_t mod_id, slice_id_t slice_id) {
   if (!mac_is_present(mod_id)) 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);
-  return newidx;
+  return -1;
 }
 
 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;
-
-  if (sli->ul[slice_idx].sched_name) free(sli->ul[slice_idx].sched_name);
-
-  --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]));
-
-  memset(&sli->ul[sli->n_ul], 0, 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_info.assoc_ul_slice_idx;
-
-  //for (int i = 0; i < MAX_MOBILES_PER_ENB; ++i) {
-  //  if (assoc_list[i] == slice_idx)
-  //    assoc_list[i] = 0;
-  //}
-
-  return sli->n_ul;
+  return -1;
 }
 
 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;
+  return 0;
 }
 
 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;
+  return 0;
 }
 
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 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;
+  return -1;
 }
 
 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;
+  return -1;
 }
 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(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;
+  return "";
 }
 int flexran_set_ul_slice_scheduler(mid_t mod_id, int slice_idx, char *name) {
   if (!mac_is_present(mod_id)) return 0;
-
-  if (RC.mac[mod_id]->slice_info.ul[slice_idx].sched_name)
-    free(RC.mac[mod_id]->slice_info.ul[slice_idx].sched_name);
-
-  RC.mac[mod_id]->slice_info.ul[slice_idx].sched_name = strdup(name);
-  RC.mac[mod_id]->slice_info.ul[slice_idx].sched_cb = dlsym(NULL, name);
-  return RC.mac[mod_id]->slice_info.ul[slice_idx].sched_cb != NULL;
+  return 0;
 }
 
 /************************** S1AP **************************/

openair2/LAYER2/MAC/mac.h

@@ -155,9 +155,6 @@
 /*!\brief minimum MAC data needed for transmitting 1 min RLC PDU size + 1 byte MAC subHeader */
 #define MIN_MAC_HDR_RLC_SIZE    (1 + MIN_RLC_PDU_SIZE)
 
-/*!\brief maximum number of slices / groups */
-#define MAX_NUM_SLICES 10
-
 
 #define U_PLANE_INACTIVITY_VALUE 0   /* defined 10ms order (zero means infinity) */
 
@@ -1150,9 +1147,6 @@ typedef struct {
   UE_list_t list;
   int num_UEs;
   boolean_t active[MAX_MOBILES_PER_ENB];
-
-  /// Sorting criteria for the UE list in the MAC preprocessor
-  uint16_t sorting_criteria[MAX_NUM_SLICES][CR_NUM];
 } UE_info_t;
 
 /*! \brief deleting control information*/
@@ -1171,101 +1165,6 @@ typedef struct {
   int tail_freelist; ///the tail position of the delete list
 } UE_free_list_t;
 
-/**
- * slice specific scheduler for the DL
- */
-typedef void (*slice_scheduler_dl)(module_id_t mod_id,
-                                   int         slice_idx,
-                                   frame_t     frame,
-                                   sub_frame_t subframe,
-                                   int        *mbsfn_flag);
-
-typedef struct {
-  slice_id_t id;
-
-  /// RB share for each slice
-  float     pct;
-
-  /// whether this slice is isolated from the others
-  int       isol;
-
-  int       prio;
-
-  /// Frequency ranges for slice positioning
-  int       pos_low;
-  int       pos_high;
-
-  // max mcs for each slice
-  int       maxmcs;
-
-  /// criteria for sorting policies of the slices
-  uint32_t  sorting;
-
-  /// Accounting policy (just greedy(1) or fair(0) setting for now)
-  int       accounting;
-
-  /// name of available scheduler
-  char     *sched_name;
-
-  /// pointer to the slice specific scheduler in DL
-  slice_scheduler_dl sched_cb;
-
-} slice_sched_conf_dl_t;
-
-typedef void (*slice_scheduler_ul)(module_id_t   mod_id,
-                                   int           slice_idx,
-                                   frame_t       frame,
-                                   sub_frame_t   subframe,
-                                   unsigned char sched_subframe,
-                                   uint16_t     *first_rb);
-
-typedef struct {
-  slice_id_t id;
-
-  /// RB share for each slice
-  float     pct;
-
-  // MAX MCS for each slice
-  int       maxmcs;
-
-  /// criteria for sorting policies of the slices
-  uint32_t  sorting;
-
-  /// starting RB (RB offset) of UL scheduling
-  int       first_rb;
-
-  /// name of available scheduler
-  char     *sched_name;
-
-  /// pointer to the slice specific scheduler in UL
-  slice_scheduler_ul sched_cb;
-
-} slice_sched_conf_ul_t;
-
-
-typedef struct {
-  /// counter used to indicate when all slices have pre-allocated UEs
-  //int      slice_counter;
-
-  /// indicates whether remaining RBs after first intra-slice allocation will
-  /// be allocated to UEs of the same slice
-  int       intraslice_share_active;
-  /// indicates whether remaining RBs after slice allocation will be
-  /// allocated to UEs of another slice. Isolated slices will be ignored
-  int       interslice_share_active;
-
-  /// number of active DL slices
-  int      n_dl;
-  slice_sched_conf_dl_t dl[MAX_NUM_SLICES];
-
-  /// number of active UL slices
-  int      n_ul;
-  slice_sched_conf_ul_t ul[MAX_NUM_SLICES];
-
-  /// common rb allocation list between slices
-  uint8_t rballoc_sub[NFAPI_CC_MAX][N_RBG_MAX];
-} slice_info_t;
-
 /**
  * describes contiguous RBs
  */
@@ -1421,9 +1320,6 @@ typedef struct eNB_MAC_INST_s {
   uint32_t ul_handle;
   UE_info_t UE_info;
 
-  /// slice-related configuration
-  slice_info_t slice_info;
-
   ///subband bitmap configuration
   SBMAP_CONF sbmap_conf;
   /// CCE table used to build DCI scheduling information

openair2/LAYER2/MAC/mac_proto.h

@@ -187,8 +187,6 @@ void add_msg3(module_id_t module_idP, int CC_id, RA_t *ra, frame_t frameP,
 
 void init_UE_info(UE_info_t *UE_info);
 
-void init_slice_info(slice_info_t *sli);
-
 int mac_top_init(int eMBMS_active, char *uecap_xer,
                  uint8_t cba_group_active, uint8_t HO_active);
 

openair2/LAYER2/MAC/main.c

@@ -57,32 +57,6 @@ void init_UE_info(UE_info_t *UE_info)
   memset(UE_info->active, 0, sizeof(UE_info->active));
 }
 
-void init_slice_info(slice_info_t *sli)
-{
-  sli->intraslice_share_active = 1;
-  sli->interslice_share_active = 1;
-
-  sli->n_dl = 1;
-  memset(sli->dl, 0, sizeof(slice_sched_conf_dl_t) * MAX_NUM_SLICES);
-  sli->dl[0].pct = 1.0;
-  sli->dl[0].prio = 10;
-  sli->dl[0].pos_high = N_RBG_MAX;
-  sli->dl[0].maxmcs = 28;
-  sli->dl[0].sorting = 0x012345;
-  sli->dl[0].sched_name = "schedule_ue_spec";
-  sli->dl[0].sched_cb = dlsym(NULL, sli->dl[0].sched_name);
-  AssertFatal(sli->dl[0].sched_cb, "DLSCH scheduler callback is NULL\n");
-
-  sli->n_ul = 1;
-  memset(sli->ul, 0, sizeof(slice_sched_conf_ul_t) * MAX_NUM_SLICES);
-  sli->ul[0].pct = 1.0;
-  sli->ul[0].maxmcs = 20;
-  sli->ul[0].sorting = 0x0123;
-  sli->ul[0].sched_name = "schedule_ulsch_rnti";
-  sli->ul[0].sched_cb = dlsym(NULL, sli->ul[0].sched_name);
-  AssertFatal(sli->ul[0].sched_cb, "ULSCH scheduler callback is NULL\n");
-}
-
 void mac_top_init_eNB(void)
 {
   module_id_t i, j;
@@ -139,7 +113,6 @@ void mac_top_init_eNB(void)
     mac[i]->ul_algo = *(default_sched_ul_algo_t *) d;
     mac[i]->ul_algo.data = mac[i]->ul_algo.setup();
     init_UE_info(&mac[i]->UE_info);
-    init_slice_info(&mac[i]->slice_info);
   }
 
   RC.mac = mac;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -68,8 +68,6 @@
 
 extern RAN_CONTEXT_t RC;
 
-extern int n_active_slices;
-
   // Note the 2 scs values in the table names represent resp. scs_common and pdcch_scs
 /// LUT for the number of symbols in the coreset indexed by coreset index (4 MSB rmsi_pdcch_config)
 uint8_t nr_coreset_nsymb_pdcch_type_0_scs_15_15[15] = {2,2,2,3,3,3,1,1,2,2,3,3,1,2,3};