diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index 39a24564dd31e23be2d0a8b0e8ac67c3804f9f74..a083cac1c38fc02a08fefa03a597f371e3a20eee 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -870,6 +870,7 @@ add_library(FLEXRAN_AGENT
${OPENAIR2_DIR}/ENB_APP/flexran_agent_net_comm.c
${OPENAIR2_DIR}/ENB_APP/flexran_agent_async.c
${OPENAIR2_DIR}/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
+ ${OPENAIR2_DIR}/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
)
set(FLEXRAN_AGENT_LIB FLEXRAN_AGENT)
#include_directories(${OPENAIR2_DIR}/ENB_APP)
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
index dea1aa05b93a5da6d1ea4bcac50829eae687ae74..d75712d430ca118e3b4fcdfc8df9d7da6f59fd34 100644
--- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c
@@ -31,6 +31,7 @@
#include "flexran_agent_common_internal.h"
#include "flexran_agent_mac_internal.h"
+#include "flexran_agent_mac_slice_verification.h"
/* from flexran_agent_mac.c */
extern Protocol__FlexSliceConfig *slice_config[NUM_MAX_ENB];
@@ -1141,107 +1142,203 @@ void overwrite_slice_config_ul(Protocol__FlexUlSlice *exist, Protocol__FlexUlSli
}
}
-void prepare_update_slice_config_dl(mid_t mod_id, Protocol__FlexDlSlice *dls)
+void fill_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *s)
{
- if (!dls->has_id) {
- LOG_E(FLEXRAN_AGENT, "[%d] Incoming DL slice configuration has no ID\n", mod_id);
- return;
- }
- /* a percentage of zero will be interpreted as removal command */
- if (sc_update[mod_id]->n_dl >= MAX_NUM_SLICES
- && (!dls->has_percentage || dls->percentage > 0)) {
- LOG_E(FLEXRAN_AGENT, "[%d] Cannot create more than %ld slices in DL\n",
- mod_id, sc_update[mod_id]->n_dl);
- return;
- }
- if (sc_update[mod_id]->n_dl == 1 && dls->has_percentage && dls->percentage == 0) {
- LOG_E(FLEXRAN_AGENT, "[%d] Cannot delete last slice ID %d in DL\n",
- mod_id, sc_update[mod_id]->dl[0]->id);
- return;
- }
+ /* TODO fill the slice depending on the chosen label */
+ /* for now, we fill it up with the information from slice 0 */
+ /* assume there is an ID (will be checked later) */
+ if (!s->has_label) {
+ s->has_label = 1;
+ s->label = sc_update[mod_id]->dl[0]->label;
+ }
+ if (!s->has_percentage) {
+ s->has_percentage = 1;
+ s->percentage = sc_update[mod_id]->dl[0]->percentage;
+ }
+ if (!s->has_isolation) {
+ s->has_isolation = 1;
+ s->isolation = sc_update[mod_id]->dl[0]->isolation;
+ }
+ if (!s->has_priority) {
+ s->has_priority = 1;
+ s->priority = sc_update[mod_id]->dl[0]->priority;
+ }
+ if (!s->has_position_low) {
+ s->has_position_low = 1;
+ s->position_low = sc_update[mod_id]->dl[0]->position_low;
+ }
+ if (!s->has_position_high) {
+ s->has_position_high = 1;
+ s->position_high = sc_update[mod_id]->dl[0]->position_high;
+ }
+ if (!s->has_maxmcs) {
+ s->has_maxmcs = 1;
+ s->maxmcs = sc_update[mod_id]->dl[0]->maxmcs;
+ }
+ if (s->n_sorting == 0) {
+ s->n_sorting = sc_update[0]->dl[0]->n_sorting;
+ /* TODO Dangerous? */
+ s->sorting = sc_update[0]->dl[0]->sorting;
+ }
+ if (!s->has_accounting) {
+ /* TODO Dangerous? */
+ s->accounting = sc_update[0]->dl[0]->accounting;
+ }
+ /* scheduler name not set, cannot be changed for the moment */
+}
- Protocol__FlexDlSlice *to = NULL;
+Protocol__FlexDlSlice *get_existing_dl_slice(mid_t mod_id, int id)
+{
for (int i = 0; i < sc_update[mod_id]->n_dl; ++i) {
- if (dls->id == sc_update[mod_id]->dl[i]->id) {
- to = sc_update[mod_id]->dl[i];
- break;
+ if (id == sc_update[mod_id]->dl[i]->id) {
+ return sc_update[mod_id]->dl[i];
}
}
+ return NULL;
+}
- /* create new slice -> read contents from existing slice config index 0 */
- if (!to) {
- LOG_I(FLEXRAN_AGENT,
- "[%d] Creating DL slice with ID %d, taking default values from DL slice 0\n",
- mod_id, dls->id);
- to = sc_update[mod_id]->dl[sc_update[mod_id]->n_dl];
- sc_update[mod_id]->n_dl++;
- memcpy(to, slice_config[mod_id]->dl[0], sizeof(*to));
- to->id = dls->id;
- }
-
- overwrite_slice_config_dl(to, dls);
+Protocol__FlexDlSlice *create_new_dl_slice(mid_t mod_id, int id)
+{
+ LOG_I(FLEXRAN_AGENT,
+ "[%d] Creating DL slice with ID %d, taking default values from DL slice 0\n",
+ 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");
+ to->id = id;
+ return to;
}
-void prepare_update_slice_config_ul(mid_t mod_id, Protocol__FlexUlSlice *uls)
+void fill_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *s)
{
- if (!uls->has_id) {
- LOG_E(FLEXRAN_AGENT, "[%d] Incoming UL slice configuration has no ID\n", mod_id);
- return;
- }
- /* a percentage of zero will be interpreted as removal command */
- if (sc_update[mod_id]->n_ul >= MAX_NUM_SLICES
- && (!uls->has_percentage || uls->percentage > 0)) {
- LOG_E(FLEXRAN_AGENT, "[%d] Cannot create more than %ld slices in UL\n",
- mod_id, sc_update[mod_id]->n_ul);
- return;
- }
- if (sc_update[mod_id]->n_ul == 1 && uls->has_percentage && uls->percentage == 0) {
- LOG_E(FLEXRAN_AGENT, "[%d] Cannot delete last slice ID %d in UL\n",
- mod_id, sc_update[mod_id]->ul[0]->id);
- return;
- }
+ /* TODO fill the slice depending on the chosen label */
+ /* for now, we fill it up with the information from slice 0 */
+ /* assume there is an ID (will be checked later) */
+ if (!s->has_label) {
+ s->has_label = 1;
+ s->label = sc_update[mod_id]->ul[0]->label;
+ }
+ if (!s->has_percentage) {
+ s->has_percentage = 1;
+ s->percentage = sc_update[mod_id]->ul[0]->percentage;
+ }
+ if (!s->has_isolation) {
+ s->has_isolation = 1;
+ s->isolation = sc_update[mod_id]->ul[0]->isolation;
+ }
+ if (!s->has_priority) {
+ s->has_priority = 1;
+ s->priority = sc_update[mod_id]->ul[0]->priority;
+ }
+ if (!s->has_first_rb) {
+ s->has_first_rb = 1;
+ s->first_rb = sc_update[mod_id]->ul[0]->first_rb;
+ }
+ if (!s->has_maxmcs) {
+ s->has_maxmcs = 1;
+ s->maxmcs = sc_update[mod_id]->ul[0]->maxmcs;
+ }
+ if (s->n_sorting == 0) {
+ s->n_sorting = sc_update[0]->ul[0]->n_sorting;
+ /* TODO Dangerous? */
+ s->sorting = sc_update[0]->ul[0]->sorting;
+ }
+ if (!s->has_accounting) {
+ /* TODO Dangerous? */
+ s->accounting = sc_update[0]->ul[0]->accounting;
+ }
+ /* scheduler name not set, cannot be changed for the moment */
+}
- Protocol__FlexUlSlice *to = NULL;
+Protocol__FlexUlSlice *get_existing_ul_slice(mid_t mod_id, int id)
+{
for (int i = 0; i < sc_update[mod_id]->n_ul; ++i) {
- if (uls->id == sc_update[mod_id]->ul[i]->id) {
- to = sc_update[mod_id]->ul[i];
- break;
+ if (id == sc_update[mod_id]->ul[i]->id) {
+ return sc_update[mod_id]->ul[i];
}
}
+ return NULL;
+}
- /* create new slice -> read contents from existing slice config index 0 */
- if (!to) {
- LOG_I(FLEXRAN_AGENT,
- "[%d] Creating UL slice with ID %d, taking default values from UL slice 0\n",
- mod_id, uls->id);
- to = sc_update[mod_id]->ul[sc_update[mod_id]->n_ul];
- sc_update[mod_id]->n_ul++;
- memcpy(to, slice_config[mod_id]->ul[0], sizeof(*to));
- to->id = uls->id;
- }
-
- overwrite_slice_config_ul(to, uls);
+Protocol__FlexUlSlice *create_new_ul_slice(mid_t mod_id, int id)
+{
+ LOG_I(FLEXRAN_AGENT,
+ "[%d] Creating UL slice with ID %d, taking default values from UL slice 0\n",
+ 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");
+ to->id = id;
+ return to;
}
-void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *slice)
+void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *sup)
{
+ int verified = 1;
if (!sc_update[mod_id]) {
LOG_E(FLEXRAN_AGENT, "Can not update slice policy (no existing slice profile)\n");
return;
}
pthread_mutex_lock(&sc_update_mtx);
-
- if (slice->n_dl == 0)
+ if (sup->n_dl == 0) {
LOG_I(FLEXRAN_AGENT, "[%d] no DL slice configuration in flex_slice_config message\n", mod_id);
- for (int i = 0; i < slice->n_dl; i++)
- prepare_update_slice_config_dl(mod_id, slice->dl[i]);
+ } else {
+ /* verify slice parameters */
+ for (int i = 0; i < sup->n_dl; i++) {
+ fill_dl_slice(mod_id, sup->dl[i]);
+ verified = verified && flexran_verify_dl_slice(mod_id, sup->dl[i]);
+ if (!verified) break;
+ }
- if (slice->n_ul == 0)
+ /* verify group-based parameters (e.g. sum percentage should not exceed
+ * 100%). Can be used to perform admission control */
+ verified = verified && flexran_verify_group_dl_slices(mod_id,
+ sc_update[mod_id]->dl, sc_update[mod_id]->n_dl, sup->dl, sup->n_dl);
+
+ if (verified) {
+ for (int i = 0; i < sup->n_dl; i++) {
+ /* if all verifications were successful, get existing slice for ID or
+ * create new one and overwrite with the update */
+ Protocol__FlexDlSlice *dls = get_existing_dl_slice(mod_id, sup->dl[i]->id);
+ if (!dls) dls = create_new_dl_slice(mod_id, sup->dl[i]->id);
+ overwrite_slice_config_dl(dls, sup->dl[i]);
+ }
+ } else {
+ LOG_E(FLEXRAN_AGENT, "[%d] DL slice verification failed, refusing application\n", mod_id);
+ }
+ }
+
+ verified = 1;
+ if (sup->n_ul == 0) {
LOG_I(FLEXRAN_AGENT, "[%d] no UL slice configuration in flex_slice_config message\n", mod_id);
- for (int i = 0; i < slice->n_ul; i++)
- prepare_update_slice_config_ul(mod_id, slice->ul[i]);
+ } else {
+ /* verify slice parameters */
+ for (int i = 0; i < sup->n_ul; i++) {
+ fill_ul_slice(mod_id, sup->ul[i]);
+ verified = verified && flexran_verify_ul_slice(mod_id, sup->ul[i]);
+ if (!verified) break;
+ }
+ /* verify group-based parameters (e.g. sum percentage should not exceed
+ * 100%). Can be used to perform admission control */
+ verified = verified && flexran_verify_group_ul_slices(mod_id,
+ sc_update[mod_id]->ul, sc_update[mod_id]->n_ul, sup->ul, sup->n_ul);
+
+ if (verified) {
+ for (int i = 0; i < sup->n_ul; i++) {
+ /* if all verifications were successful, get existing slice for ID or
+ * create new one and overwrite with the update */
+ Protocol__FlexUlSlice *uls = get_existing_ul_slice(mod_id, sup->ul[i]->id);
+ if (!uls) uls = create_new_ul_slice(mod_id, sup->ul[i]->id);
+ overwrite_slice_config_ul(uls, sup->ul[i]);
+ }
+ } else {
+ LOG_E(FLEXRAN_AGENT, "[%d] UL slice verification failed, refusing application\n", mod_id);
+ }
+ }
pthread_mutex_unlock(&sc_update_mtx);
/* perform the slice configuration reads a couple of times. If there are
@@ -1299,11 +1396,6 @@ int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protoco
flexran_set_dl_slice_accounting_policy(mod_id, slice_idx, newc->accounting);
changes++;
}
- if (strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
- LOG_E(FLEXRAN_AGENT, "[%d][DL slice %d] setting the DL scheduler is not supported, reverting\n",
- mod_id, newc->id);
- newc->scheduler_name = oldc->scheduler_name;
- }
return changes;
}
@@ -1365,11 +1457,6 @@ int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protoco
LOG_W(FLEXRAN_AGENT, "[%d][UL slice %d] setting the accounting is not supported\n",
mod_id, slice_idx);
}
- if (strcmp(oldc->scheduler_name, newc->scheduler_name) != 0) {
- LOG_E(FLEXRAN_AGENT, "[%d][UL slice %d] setting the UL scheduler is not supported, reverting\n",
- mod_id, slice_idx);
- newc->scheduler_name = oldc->scheduler_name;
- }
return changes;
}
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
new file mode 100644
index 0000000000000000000000000000000000000000..addc8d2e7523e3b463a51da47354a74b43cd932e
--- /dev/null
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.c
@@ -0,0 +1,340 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ * contact@openairinterface.org
+ */
+
+/*! \file flexran_agent_mac_slice_verification.c
+ * \brief MAC Agent slice verification helper functions
+ * \author Robert Schmidt
+ * \date 2018
+ * \version 0.1
+ */
+
+
+#include "flexran_agent_mac_slice_verification.h"
+
+/* overlap check for UL slices, helper type */
+struct sregion_s {
+ int start;
+ int length;
+};
+
+/* forward declaration of locally-used verification functions */
+int flexran_dl_slice_verify_pct(int pct);
+int flexran_dl_slice_verify_priority(int prio);
+int flexran_dl_slice_verify_position(int pos_low, int pos_high);
+int flexran_dl_slice_verify_maxmcs(int maxmcs);
+int flexran_ul_slice_verify_pct(int pct);
+int flexran_ul_slice_verify_priority(int prio);
+int flexran_ul_slice_verify_first_rb(int first_rb);
+int flexran_ul_slice_verify_maxmcs(int maxmcs);
+int check_ul_slice_overlap(mid_t mod_id, struct sregion_s *sr, int n);
+
+int flexran_verify_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *dls)
+{
+ /* check mandatory parameters */
+ if (!dls->has_id) {
+ LOG_E(FLEXRAN_AGENT, "[%d] Incoming DL slice configuration has no ID\n", mod_id);
+ return 0;
+ }
+
+ /* verify parameters individualy */
+ /* label is enum */
+ if (!flexran_dl_slice_verify_pct(dls->percentage)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal DL slice percentage (%d)\n", mod_id, dls->percentage);
+ return 0;
+ }
+ /* isolation is a protobuf bool */
+ if (!flexran_dl_slice_verify_priority(dls->priority)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal DL slice priority (%d)\n", mod_id, dls->priority);
+ return 0;
+ }
+ if (!flexran_dl_slice_verify_position(dls->position_low, dls->position_high)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal DL slice position low (%d) and/or high (%d)\n",
+ mod_id, dls->position_low, dls->position_high);
+ return 0;
+ }
+ if (!flexran_dl_slice_verify_maxmcs(dls->maxmcs)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal DL slice max mcs %d\n", mod_id, dls->maxmcs);
+ return 0;
+ }
+ if (dls->n_sorting == 0) {
+ LOG_E(FLEXRAN_AGENT, "[%d] no sorting in DL slice", mod_id);
+ return 0;
+ }
+ if (!dls->sorting) {
+ LOG_E(FLEXRAN_AGENT, "[%d] no sorting found in DL slice\n", mod_id);
+ return 0;
+ }
+ /* sorting is an enum */
+ /* accounting is an enum */
+ if (dls->scheduler_name) {
+ LOG_E(FLEXRAN_AGENT, "[%d] setting the scheduler is not allowed\n", mod_id);
+ return 0;
+ }
+
+ return 1;
+}
+
+int flexran_verify_group_dl_slices(mid_t mod_id, Protocol__FlexDlSlice **existing,
+ int n_ex, Protocol__FlexDlSlice **update, int n_up)
+{
+ int i, j, n;
+ int pct, pct_orig;
+ /* for every update, array points to existing slice, or NULL if update
+ * creates new slice */
+ Protocol__FlexDlSlice *s[n_up];
+ for (i = 0; i < n_up; i++) {
+ s[i] = NULL;
+ for (j = 0; j < n_ex; j++) {
+ if (existing[j]->id == update[i]->id)
+ s[i] = existing[j];
+ }
+ }
+
+ /* check that number of created and number of added slices in total matches
+ * [1,10] */
+ n = n_ex;
+ for (i = 0; i < n_up; i++) {
+ /* new slice */
+ if (!s[i]) n += 1;
+ /* slice will be deleted */
+ else if (s[i]->percentage == 0) n -= 1;
+ /* else "only" an update */
+ }
+
+ if (n < 1 || n > MAX_NUM_SLICES) {
+ LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting slices (%d -> %d)\n", mod_id, n_ex, n);
+ return 0;
+ }
+
+ /* check that the sum of all slices percentages (including removed/added
+ * slices) matches [1,100] */
+ pct = 0;
+ for (i = 0; i < n_ex; i++) {
+ pct += existing[i]->percentage;
+ }
+ pct_orig = pct;
+ for (i = 0; i < n_up; i++) {
+ /* if there is an existing slice, subtract its percentage and add the
+ * update's percentage */
+ if (s[i])
+ pct -= s[i]->percentage;
+ pct += update[i]->percentage;
+ }
+ if (pct < 1 || pct > 100) {
+ LOG_E(FLEXRAN_AGENT, "[%d] invalid total RB share (%d%% -> %d%%)\n", mod_id, pct_orig, pct);
+ return 0;
+ }
+
+ return 1;
+}
+
+int flexran_verify_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *uls)
+{
+ /* check mandatory parameters */
+ if (!uls->has_id) {
+ LOG_E(FLEXRAN_AGENT, "[%d] Incoming UL slice configuration has no ID\n", mod_id);
+ return 0;
+ }
+
+ /* verify parameters individually */
+ /* label is enum */
+ if (!flexran_ul_slice_verify_pct(uls->percentage)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal UL slice percentage (%d)\n", mod_id, uls->percentage);
+ return 0;
+ }
+ /* isolation is a protobuf bool */
+ if (!flexran_ul_slice_verify_priority(uls->priority)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal UL slice percentage (%d)\n", mod_id, uls->priority);
+ return 0;
+ }
+ if (!flexran_ul_slice_verify_first_rb(uls->first_rb)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal UL slice first RB (%d)\n", mod_id, uls->first_rb);
+ return 0;
+ }
+ if (!flexran_ul_slice_verify_maxmcs(uls->maxmcs)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] illegal UL slice max mcs (%d)\n", mod_id, uls->maxmcs);
+ return 0;
+ }
+ if (uls->n_sorting == 0) {
+ LOG_E(FLEXRAN_AGENT, "[%d] no sorting in UL slice\n", mod_id);
+ return 0;
+ }
+ if (!uls->sorting) {
+ LOG_E(FLEXRAN_AGENT, "[%d] no sorting found in UL slice\n", mod_id);
+ return 0;
+ }
+ /* sorting is an enum */
+ /* accounting is an enum */
+ if (uls->scheduler_name) {
+ LOG_E(FLEXRAN_AGENT, "[%d] setting the scheduler is not allowed\n", mod_id);
+ return 0;
+ }
+
+ return 1;
+}
+
+int flexran_verify_group_ul_slices(mid_t mod_id, Protocol__FlexUlSlice **existing,
+ int n_ex, Protocol__FlexUlSlice **update, int n_up)
+{
+ int i, j, n;
+ int pct, pct_orig;
+ /* for every update, array "s" points to existing slice, or NULL if update
+ * creates new slice; array "offs" gives the offset of this slice */
+ Protocol__FlexUlSlice *s[n_up];
+ int offs[n_up];
+ for (i = 0; i < n_up; i++) {
+ s[i] = NULL;
+ offs[i] = 0;
+ for (j = 0; j < n_ex; j++) {
+ if (existing[j]->id == update[i]->id) {
+ s[i] = existing[j];
+ offs[i] = j;
+ }
+ }
+ }
+
+ /* check that number of created and number of added slices in total matches
+ * [1,10] */
+ n = n_ex;
+ for (i = 0; i < n_up; i++) {
+ /* new slice */
+ if (!s[i]) n += 1;
+ /* slice will be deleted */
+ else if (s[i]->percentage == 0) n -= 1;
+ /* else "only" an update */
+ }
+
+ if (n < 1 || n > MAX_NUM_SLICES) {
+ LOG_E(FLEXRAN_AGENT, "[%d] Illegal number of resulting slices (%d -> %d)\n", mod_id, n_ex, n);
+ return 0;
+ }
+
+ /* check that the sum of all slices percentages (including removed/added
+ * slices) matches [1,100] */
+ pct = 0;
+ for (i = 0; i < n_ex; i++) {
+ pct += existing[i]->percentage;
+ }
+ pct_orig = pct;
+ for (i = 0; i < n_up; i++) {
+ /* if there is an existing slice, subtract its percentage and add the
+ * update's percentage */
+ if (s[i])
+ pct -= s[i]->percentage;
+ pct += update[i]->percentage;
+ }
+ if (pct < 1 || pct > 100) {
+ LOG_E(FLEXRAN_AGENT, "[%d] invalid total RB share (%d%% -> %d%%)\n", mod_id, pct_orig, pct);
+ return 0;
+ }
+
+ /* check that there is no overlap in slices resulting as the combination of
+ * first_rb and percentage */
+ struct sregion_s sregion[n];
+ const int N_RB = flexran_get_N_RB_UL(mod_id, 0); /* assume PCC */
+ int k = n_ex;
+ for (i = 0; i < n_ex; i++) {
+ sregion[i].start = existing[i]->first_rb;
+ sregion[i].length = existing[i]->percentage * N_RB / 100;
+ }
+ for (i = 0; i < n_up; i++) {
+ ptrdiff_t d = s[i] ? offs[i] : k++;
+ AssertFatal(d >= 0 && d < k, "illegal pointer offset (%ld, k=%d)\n", d, k);
+ sregion[d].start = update[i]->first_rb;
+ sregion[d].length = update[i]->percentage * N_RB / 100;
+ }
+ AssertFatal(k == n, "illegal number of slices while calculating overlap\n");
+ if (!check_ul_slice_overlap(mod_id, sregion, k)) {
+ LOG_E(FLEXRAN_AGENT, "[%d] UL slices are overlapping\n", mod_id);
+ return 0;
+ }
+
+ return 1;
+}
+
+int flexran_dl_slice_verify_pct(int pct)
+{
+ return pct >= 0 && pct <= 100;
+}
+
+int flexran_dl_slice_verify_priority(int prio)
+{
+ return prio >= 0;
+}
+
+int flexran_dl_slice_verify_position(int pos_low, int pos_high)
+{
+ return pos_low < pos_high && pos_low >= 0 && pos_high <= N_RBG_MAX;
+}
+
+int flexran_dl_slice_verify_maxmcs(int maxmcs)
+{
+ return maxmcs >= 0 && maxmcs <= 28;
+}
+
+int flexran_ul_slice_verify_pct(int pct)
+{
+ return pct >= 0 && pct <= 100;
+}
+
+int flexran_ul_slice_verify_priority(int prio)
+{
+ return prio >= 0;
+}
+
+int flexran_ul_slice_verify_first_rb(int first_rb)
+{
+ return first_rb >= 0 && first_rb < 100;
+}
+
+int flexran_ul_slice_verify_maxmcs(int maxmcs)
+{
+ return maxmcs >= 0 && maxmcs <= 20;
+}
+
+int sregion_compare(const void *_a, const void *_b)
+{
+ const struct sregion_s *a = (const struct sregion_s *)_a;
+ const struct sregion_s *b = (const struct sregion_s *)_b;
+ const int res = a->start - b->start;
+ if (res < 0) return -1;
+ else if (res == 0) return 0;
+ else return 1;
+}
+
+int check_ul_slice_overlap(mid_t mod_id, struct sregion_s *sr, int n)
+{
+ int i;
+ int overlap, op, u;
+ const int N_RB = flexran_get_N_RB_UL(mod_id, 0); /* assume PCC */
+ qsort(sr, n, sizeof(sr[0]), sregion_compare);
+ for (i = 0; i < n; i++) {
+ u = i == n-1 ? N_RB : sr[i+1].start;
+ AssertFatal(sr[i].start <= u, "unsorted slice list\n");
+ overlap = sr[i].start + sr[i].length - u;
+ if (overlap <= 0) continue;
+ op = overlap * 100 / sr[i].length;
+ LOG_W(FLEXRAN_AGENT, "[%d] slice overlap of %d%% detected\n", mod_id, op);
+ if (op >= 10) /* more than 10% overlap -> refuse */
+ return 0;
+ }
+ return 1;
+}
diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8f4030d3664be1e1388d8d42cae8feed9a4dd90
--- /dev/null
+++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ * contact@openairinterface.org
+ */
+
+/*! \file flexran_agent_mac_slice_verification.h
+ * \brief MAC Agent slice verification helper functions
+ * \author Robert Schmidt
+ * \date 2018
+ * \version 0.1
+ */
+
+#include "flexran_agent_common_internal.h"
+#include "flexran_agent_mac_internal.h"
+
+int flexran_verify_dl_slice(mid_t mod_id, Protocol__FlexDlSlice *dls);
+int flexran_verify_group_dl_slices(mid_t mod_id, Protocol__FlexDlSlice **existing,
+ int n_ex, Protocol__FlexDlSlice **update, int n_up);
+int flexran_verify_ul_slice(mid_t mod_id, Protocol__FlexUlSlice *uls);
+int flexran_verify_group_ul_slices(mid_t mod_id, Protocol__FlexUlSlice **existing,
+ int n_ex, Protocol__FlexUlSlice **update, int n_up);
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
index c4c1cd1ca5ee379e7a5e53a0bd560b2004b7a39c..7a58cff2e54e6b48b32b7a9eef16ecb7a69df1e7 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
@@ -414,193 +414,7 @@ schedule_dlsch(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP, in
slice_info_t *sli = &RC.mac[module_idP]->slice_info;
memset(sli->rballoc_sub, 0, sizeof(sli->rballoc_sub));
- sli->tot_pct_dl = 0;
- sli->avg_pct_dl = 1.0 / sli->n_dl;
- //sli->slice_counter = sli->n_dl;
-
- for (i = 0; i < sli->n_dl; i++) {
- if (sli->dl[i].pct < 0) {
- LOG_W(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: invalid percentage %f. resetting to zero",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].pct);
- sli->dl[i].pct = 0;
- }
- sli->tot_pct_dl += sli->dl[i].pct;
- }
-
- // Check for *intra*slice share activation
- if (sli->intraslice_share_active_current != sli->intraslice_share_active) {
- if (sli->intraslice_share_active != 1 && sli->intraslice_share_active != 0) {
- LOG_W(MAC,
- "[eNB %d][DL] frame %d subframe %d: invalid intraslice sharing status (%d), revert to its previous value (%d)\n",
- module_idP, frameP, subframeP, sli->intraslice_share_active, sli->intraslice_share_active_current);
- sli->intraslice_share_active = sli->intraslice_share_active_current;
- } else {
- LOG_N(MAC, "[eNB %d][DL] frame %d subframe %d: intraslice sharing status has changed (%x-->%x)\n",
- module_idP, frameP, subframeP, sli->intraslice_share_active_current, sli->intraslice_share_active);
- sli->intraslice_share_active_current = sli->intraslice_share_active;
- }
- }
-
- // Check for *inter*slice share activation
- if (sli->interslice_share_active_current != sli->interslice_share_active) {
- if (sli->interslice_share_active != 1 && sli->interslice_share_active != 0) {
- LOG_W(MAC,
- "[eNB %d][DL] frame %d subframe %d: invalid interslice sharing status (%d), revert to its previous value (%d)\n",
- module_idP, frameP, subframeP, sli->interslice_share_active, sli->interslice_share_active_current);
- sli->interslice_share_active = sli->interslice_share_active_current;
- } else {
- LOG_N(MAC, "[eNB %d][DL] frame %d subframe %d: interslice sharing status has changed (%x-->%x)\n",
- module_idP, frameP, subframeP, sli->interslice_share_active_current, sli->interslice_share_active);
- sli->interslice_share_active_current = sli->interslice_share_active;
- }
- }
-
for (i = 0; i < sli->n_dl; i++) {
-
- // Load any updated functions
- if (sli->dl[i].update_sched > 0) {
- sli->dl[i].sched_cb = dlsym(NULL, sli->dl[i].sched_name);
- sli->dl[i].update_sched = 0;
- sli->dl[i].update_sched_current = 0;
- LOG_I(MAC, "update dl scheduler (%s) slice index %d ID %d\n",
- sli->dl[i].sched_name, i, sli->dl[i].id);
- }
-
- if (sli->tot_pct_dl <= 1.0) { // the new total RB share is within the range
-
- // check if the number of slices has changed, and log
- if (sli->n_dl_current != sli->n_dl) {
- if ((sli->n_dl > 0) && (sli->n_dl <= MAX_NUM_SLICES)) {
- LOG_I(MAC, "[eNB %d]frame %d subframe %d: number of active DL slices has changed: %d-->%d\n",
- module_idP, frameP, subframeP, sli->n_dl_current, sli->n_dl);
- sli->n_dl_current = sli->n_dl;
- } else {
- LOG_W(MAC, "invalid number of DL slices %d, revert to the previous value %d\n",
- sli->n_dl, sli->n_dl_current);
- sli->n_dl = sli->n_dl_current;
- }
- }
-
- // check if the slice rb share has changed, and log the console
- if (sli->dl[i].pct_current != sli->dl[i].pct) { // new slice percentage
- LOG_I(MAC,
- "[eNB %d][SLICE %d][DL] frame %d subframe %d: total percentage %f-->%f, slice RB percentage has changed: %f-->%f\n",
- module_idP, sli->dl[i].id, frameP, subframeP,
- sli->tot_pct_dl_current, sli->tot_pct_dl,
- sli->dl[i].pct_current, sli->dl[i].pct);
- sli->tot_pct_dl_current = sli->tot_pct_dl;
- sli->dl[i].pct_current = sli->dl[i].pct;
- }
-
- // check if the slice max MCS, and log the console
- if (sli->dl[i].maxmcs_current != sli->dl[i].maxmcs) {
- if ((sli->dl[i].maxmcs >= 0) && (sli->dl[i].maxmcs < 29)) {
- LOG_I(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: slice MAX MCS has changed: %d-->%d\n",
- module_idP, sli->dl[i].id, frameP, subframeP,
- sli->dl[i].maxmcs_current, sli->dl[i].maxmcs);
- sli->dl[i].maxmcs_current = sli->dl[i].maxmcs;
- } else {
- LOG_W(MAC, "[eNB %d][SLICE %d][DL] invalid slice max mcs %d, revert the previous value %d\n",
- module_idP, sli->dl[i].id, sli->dl[i].maxmcs, sli->dl[i].maxmcs_current);
- sli->dl[i].maxmcs = sli->dl[i].maxmcs_current;
- }
- }
-
- // check if a new scheduler, and log the console
- if (sli->dl[i].update_sched_current != sli->dl[i].update_sched) {
- LOG_I(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: DL scheduler for this slice is updated: %s \n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].sched_name);
- sli->dl[i].update_sched_current = sli->dl[i].update_sched;
- }
-
- } else {
- // here we can correct the values, e.g. reduce proportionally
-
- if (sli->n_dl == sli->n_dl_current) {
- LOG_W(MAC,
- "[eNB %d][SLICE %d][DL] invalid total RB share (%f->%f), reduce proportionally the RB share by 0.1\n",
- module_idP, sli->dl[i].id, sli->tot_pct_dl_current, sli->tot_pct_dl);
- if (sli->dl[i].pct >= sli->avg_pct_dl) {
- sli->dl[i].pct -= 0.1;
- sli->tot_pct_dl -= 0.1;
- }
- } else {
- LOG_W(MAC,
- "[eNB %d][SLICE %d][DL] invalid total RB share (%f->%f), revert the number of slice to its previous value (%d->%d)\n",
- module_idP, sli->dl[i].id, sli->tot_pct_dl_current, sli->tot_pct_dl,
- sli->n_dl, sli->n_dl_current);
- sli->n_dl = sli->n_dl_current;
- sli->dl[i].pct = sli->dl[i].pct_current;
- }
- }
-
- // Check for new slice positions
- if (sli->dl[i].pos_low > sli->dl[i].pos_high ||
- sli->dl[i].pos_low < 0 ||
- sli->dl[i].pos_high > N_RBG_MAX) {
- LOG_W(MAC, "[eNB %d][SLICE %d][DL] invalid slicing position (%d-%d), using previous values (%d-%d)\n",
- module_idP, sli->dl[i].id,
- sli->dl[i].pos_low, sli->dl[i].pos_high,
- sli->dl[i].pos_low_current, sli->dl[i].pos_high_current);
- sli->dl[i].pos_low = sli->dl[i].pos_low_current;
- sli->dl[i].pos_high = sli->dl[i].pos_high_current;
- } else {
- if (sli->dl[i].pos_low_current != sli->dl[i].pos_low) {
- LOG_N(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: start frequency has changed (%d-->%d)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].pos_low_current, sli->dl[i].pos_low);
- sli->dl[i].pos_low_current = sli->dl[i].pos_low;
- }
- if (sli->dl[i].pos_high_current != sli->dl[i].pos_high) {
- LOG_N(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: end frequency has changed (%d-->%d)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].pos_high_current, sli->dl[i].pos_high);
- sli->dl[i].pos_high_current = sli->dl[i].pos_high;
- }
- }
-
- // Check for new sorting policy
- if (sli->dl[i].sorting_current != sli->dl[i].sorting) {
- LOG_I(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: UE sorting policy has changed (%x-->%x)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].sorting_current, sli->dl[i].sorting);
- sli->dl[i].sorting_current = sli->dl[i].sorting;
- }
-
- // Check for new slice isolation
- if (sli->dl[i].isol_current != sli->dl[i].isol) {
- if (sli->dl[i].isol != 1 && sli->dl[i].isol != 0) {
- LOG_W(MAC,
- "[eNB %d][SLICE %d][DL] frame %d subframe %d: invalid slice isolation setting (%d), revert to its previous value (%d)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].isol, sli->dl[i].isol_current);
- sli->dl[i].isol = sli->dl[i].isol_current;
- } else {
- LOG_I(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: slice isolation setting has changed (%x-->%x)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].isol_current, sli->dl[i].isol);
- sli->dl[i].isol_current = sli->dl[i].isol;
- }
- }
-
- // Check for new slice priority
- if (sli->dl[i].prio_current != sli->dl[i].prio) {
- LOG_I(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: slice priority setting has changed (%d-->%d)\n",
- module_idP, sli->dl[i].id, frameP, subframeP, sli->dl[i].prio_current, sli->dl[i].prio);
- sli->dl[i].prio_current = sli->dl[i].prio;
- }
-
- // Check for new accounting policy
- if (sli->dl[i].accounting_current != sli->dl[i].accounting) {
- if (sli->dl[i].accounting > 1 || sli->dl[i].accounting < 0) {
- LOG_W(MAC,
- "[eNB %d][SLICE %d][DL] frame %d subframe %d: invalid accounting policy (%d), revert to its previous value (%d)\n",
- module_idP, sli->dl[i].id, frameP, subframeP,
- sli->dl[i].accounting, sli->dl[i].accounting_current);
- sli->dl[i].accounting = sli->dl[i].accounting_current;
- } else {
- LOG_N(MAC, "[eNB %d][SLICE %d][DL] frame %d subframe %d: UE sorting policy has changed (%x-->%x)\n",
- module_idP, sli->dl[i].id, frameP, subframeP,
- sli->dl[i].accounting_current, sli->dl[i].accounting);
- sli->dl[i].accounting_current = sli->dl[i].accounting;
- }
- }
-
// Run each enabled slice-specific schedulers one by one
sli->dl[i].sched_cb(module_idP, i, frameP, subframeP, mbsfn_flag/*, dl_info*/);
}
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
index 68cd5de8bdffbfe7395b9d1dae6a36a596b5f7d6..4618d363f98bce612e06445b17228ced3ab324ca 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
@@ -1038,112 +1038,7 @@ schedule_ulsch(module_id_t module_idP, frame_t frameP,
}
}
- // perform slice-specifc operations
-
- sli->tot_pct_ul = 0;
- sli->avg_pct_ul = 1.0 / sli->n_ul;
-
for (i = 0; i < sli->n_ul; i++) {
- if (sli->ul[i].pct < 0 ){
- LOG_W(MAC,
- "[eNB %d][SLICE %d][UL] frame %d subframe %d: invalid percentage %f. resetting to zero",
- module_idP, sli->ul[i].id, frameP, subframeP, sli->ul[i].pct);
- sli->ul[i].pct = 0;
- }
- sli->tot_pct_ul += sli->ul[i].pct;
- }
-
- for (i = 0; i < sli->n_ul; i++) {
-
- // Load any updated functions
- if (sli->ul[i].update_sched > 0 ) {
- sli->ul[i].sched_cb = dlsym(NULL, sli->ul[i].sched_name);
- sli->ul[i].update_sched = 0;
- sli->ul[i].update_sched_current = 0;
- //sli->ul[i].pct_current = sli->ul[i].pct;
- //sli->tot_pct_ul_current += sli->ul[i].pct;
- //if (sli->tot_pct_ul_current > 1)
- //sli->tot_pct_ul_current = 1;
- LOG_I(MAC,"update ul scheduler (%s) slice index %d ID %d\n",
- sli->ul[i].sched_name, i, sli->ul[i].id);
- }
- // the new total RB share is within the range
- if (sli->tot_pct_ul <= 1.0){
-
- // check if the number of slices has changed, and log
- if (sli->n_ul_current != sli->n_ul ){
- if ((sli->n_ul > 0) && (sli->n_ul <= MAX_NUM_SLICES)) {
- LOG_I(MAC,"[eNB %d]frame %d subframe %d: number of active UL slices has changed: %d-->%d\n",
- module_idP, frameP, subframeP, sli->n_ul_current, sli->n_ul);
- sli->n_ul_current = sli->n_ul;
- } else {
- LOG_W(MAC,"invalid number of UL slices %d, revert to the previous value %d\n",
- sli->n_ul, sli->n_ul_current);
- sli->n_ul = sli->n_ul_current;
- }
- }
-
- // check if the slice rb share has changed, and log the console
- if (sli->ul[i].pct_current != sli->ul[i].pct){
- LOG_I(MAC,"[eNB %d][SLICE %d][UL] frame %d subframe %d: total percentage %f-->%f, slice RB percentage has changed: %f-->%f\n",
- module_idP, sli->ul[i].id, frameP, subframeP, sli->tot_pct_ul_current,
- sli->tot_pct_ul, sli->ul[i].pct_current, sli->ul[i].pct);
- sli->tot_pct_ul_current = sli->tot_pct_ul;
- sli->ul[i].pct_current = sli->ul[i].pct;
- }
-
- // check if the slice max MCS, and log the console
- if (sli->ul[i].maxmcs_current != sli->ul[i].maxmcs){
- if ((sli->ul[i].maxmcs >= 0) && (sli->ul[i].maxmcs <= 20)){
- LOG_I(MAC,"[eNB %d][SLICE %d][UL] frame %d subframe %d: slice MAX MCS has changed: %d-->%d\n",
- module_idP, sli->ul[i].id, frameP, subframeP,
- sli->ul[i].maxmcs_current, sli->ul[i].maxmcs);
- sli->ul[i].maxmcs_current = sli->ul[i].maxmcs;
- } else {
- LOG_W(MAC,"[eNB %d][SLICE %d][UL] invalid slice max mcs %d, revert the previous value %d\n",
- module_idP, sli->ul[i].id, sli->ul[i].maxmcs, sli->ul[i].maxmcs_current);
- sli->ul[i].maxmcs = sli->ul[i].maxmcs_current;
- }
- }
-
- if (sli->ul[i].first_rb_current != sli->ul[i].first_rb){
- if (sli->ul[i].first_rb >= 0){ // FIXME: Max limit is checked in the scheduler
- LOG_N(MAC,"[eNB %d][SLICE %d][UL] frame %d subframe %d: slice first rb has changed: %d-->%d\n",
- module_idP, sli->ul[i].id, frameP, subframeP,
- sli->ul[i].first_rb_current, sli->ul[i].first_rb);
- sli->ul[i].first_rb_current = sli->ul[i].first_rb;
- } else {
- LOG_W(MAC,"[eNB %d][SLICE %d][UL] invalid slice first rb %d, revert the previous value %d\n",
- module_idP, sli->ul[i].id, sli->ul[i].first_rb,
- sli->ul[i].first_rb_current);
- sli->ul[i].first_rb = sli->ul[i].first_rb_current;
- }
- }
-
- // check if a new scheduler, and log the console
- if (sli->ul[i].update_sched_current != sli->ul[i].update_sched) {
- LOG_I(MAC,"[eNB %d][SLICE %d][UL] frame %d subframe %d: UL scheduler for this slice is updated: %s \n",
- module_idP, sli->ul[i].id, frameP, subframeP, sli->ul[i].sched_name);
- sli->ul[i].update_sched_current = sli->ul[i].update_sched;
- }
- } else {
- if (sli->n_ul == sli->n_ul_current) {
- LOG_W(MAC,"[eNB %d][SLICE %d][UL] invalid total RB share (%f->%f), reduce proportionally the RB share by 0.1\n",
- module_idP, sli->ul[i].id, sli->tot_pct_ul_current, sli->tot_pct_ul);
- if (sli->ul[i].pct > sli->avg_pct_ul) {
- sli->ul[i].pct -= 0.1;
- sli->tot_pct_ul -= 0.1;
- }
- } else {
- // here we can correct the values, e.g. reduce proportionally
- LOG_W(MAC,"[eNB %d][SLICE %d][UL] invalid total RB share (%f->%f), revert the number of slice to its previous value (%d->%d)\n",
- module_idP, sli->ul[i].id, sli->tot_pct_ul_current,
- sli->tot_pct_ul, sli->n_ul, sli->n_ul_current);
- sli->n_ul = sli->n_ul_current;
- sli->ul[i].pct = sli->ul[i].pct_current;
- }
- }
-
// Run each enabled slice-specific schedulers one by one
sli->ul[i].sched_cb(module_idP, i, frameP, subframeP, sched_subframe, first_rb);
}
diff --git a/openair2/LAYER2/MAC/mac.h b/openair2/LAYER2/MAC/mac.h
index 5507f643f0647715fc7be4f89ddd92e2d060740e..6148b63363cb8f5d7bd456d6b701b0f64e2cd48c 100644
--- a/openair2/LAYER2/MAC/mac.h
+++ b/openair2/LAYER2/MAC/mac.h
@@ -1151,38 +1151,29 @@ typedef void (*slice_scheduler_dl)(module_id_t mod_id,
typedef struct {
slice_id_t id;
- /// RB share for each slice for past and current time
+ /// RB share for each slice
float pct;
- float pct_current;
- /// whether this slice is isolated from the others for past and current time
+ /// whether this slice is isolated from the others
int isol;
- int isol_current;
int prio;
- int prio_current;
/// Frequency ranges for slice positioning
int pos_low;
int pos_high;
- int pos_low_current;
- int pos_high_current;
- // max mcs for each slice for past and current time
+ // max mcs for each slice
int maxmcs;
- int maxmcs_current;
/// criteria for sorting policies of the slices
uint32_t sorting;
- uint32_t sorting_current;
/// Accounting policy (just greedy(1) or fair(0) setting for now)
int accounting;
- int accounting_current;
/// Whether the scheduler callback should be updated
int update_sched;
- int update_sched_current;
/// name of available scheduler
char *sched_name;
@@ -1202,25 +1193,20 @@ typedef void (*slice_scheduler_ul)(module_id_t mod_id,
typedef struct {
slice_id_t id;
- /// RB share for each slice for past and current time
+ /// RB share for each slice
float pct;
- float pct_current;
- // MAX MCS for each slice for past and current time
+ // MAX MCS for each slice
int maxmcs;
- int maxmcs_current;
/// criteria for sorting policies of the slices
uint32_t sorting;
- uint32_t sorting_current;
/// starting RB (RB offset) of UL scheduling
int first_rb;
- int first_rb_current;
/// Slice scheduler callback update needed
int update_sched;
- int update_sched_current;
/// name of available scheduler
char *sched_name;
@@ -1238,28 +1224,16 @@ typedef struct {
/// indicates whether remaining RBs after first intra-slice allocation will
/// be allocated to UEs of the same slice
int intraslice_share_active;
- int intraslice_share_active_current;
/// indicates whether remaining RBs after slice allocation will be
/// allocated to UEs of another slice. Isolated slices will be ignored
int interslice_share_active;
- int interslice_share_active_current;
- /// number of active slices for past and current time in DL
+ /// number of active DL slices
int n_dl;
- int n_dl_current;
- /// RB share stats for DL
- float tot_pct_dl;
- float tot_pct_dl_current;
- float avg_pct_dl;
slice_sched_conf_dl_t dl[MAX_NUM_SLICES];
- /// number of active slices for past and current time in UL
+ /// number of active UL slices
int n_ul;
- int n_ul_current;
- /// RB share stats for UL
- float tot_pct_ul;
- float tot_pct_ul_current;
- float avg_pct_ul;
slice_sched_conf_ul_t ul[MAX_NUM_SLICES];
pre_processor_results_t pre_processor_results[MAX_NUM_SLICES];
diff --git a/openair2/LAYER2/MAC/main.c b/openair2/LAYER2/MAC/main.c
index 4c3e22acb78600345144201e60ab2abbf5212296..e34e0e1dd031fa52fb418752ff96603200698c32 100644
--- a/openair2/LAYER2/MAC/main.c
+++ b/openair2/LAYER2/MAC/main.c
@@ -138,44 +138,24 @@ void mac_top_init_eNB(void)
sli = &mac->slice_info;
sli->intraslice_share_active = 1;
- sli->intraslice_share_active_current = 1;
sli->interslice_share_active = 1;
- sli->interslice_share_active_current = 1;
sli->n_dl = 1;
- sli->n_dl_current = 1;
- sli->tot_pct_dl = 1;
- sli->tot_pct_dl_current = 1;
- sli->avg_pct_dl = 0.25;
memset(sli->dl, 0, sizeof(slice_sched_conf_dl_t) * MAX_NUM_SLICES);
sli->dl[0].pct = 1.0;
- sli->dl[0].pct_current = 1.0;
sli->dl[0].prio = 10;
- sli->dl[0].prio_current = 10;
sli->dl[0].pos_high = N_RBG_MAX;
- sli->dl[0].pos_high_current = N_RBG_MAX;
sli->dl[0].maxmcs = 28;
- sli->dl[0].maxmcs_current = 28;
sli->dl[0].sorting = 0x012345;
- sli->dl[0].sorting_current = 0x012345;
sli->dl[0].update_sched = 1;
- sli->dl[0].update_sched_current = 1;
sli->dl[0].sched_name = "schedule_ue_spec";
sli->n_ul = 1;
- sli->n_ul_current = 1;
- sli->tot_pct_ul = 1;
- sli->tot_pct_ul_current = 1;
- sli->avg_pct_ul = 0.25;
memset(sli->ul, 0, sizeof(slice_sched_conf_ul_t) * MAX_NUM_SLICES);
sli->ul[0].pct = 1.0;
- sli->ul[0].pct_current = 1.0;
sli->ul[0].maxmcs = 20;
- sli->ul[0].maxmcs_current = 20;
sli->ul[0].sorting = 0x0123;
- sli->ul[0].sorting_current = 0x0123;
sli->ul[0].update_sched = 1;
- sli->ul[0].update_sched_current = 1;
sli->ul[0].sched_name = "schedule_ulsch_rnti";
}