Merge remote-tracking branch 'origin/feature-slice+restart-w35' into develop_integration_2018_w36

Conflicts:
	openair2/ENB_APP/flexran_agent_common_internal.c
	openair2/LAYER2/MAC/eNB_scheduler_dlsch.c

cmake_targets/CMakeLists.txt

@@ -871,6 +871,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)

common/utils/load_module_shlib.c

@@ -120,75 +120,116 @@ int ret;
 
 int load_module_shlib(char *modname,loader_shlibfunc_t *farray, int numf, void *autoinit_arg)
 {
-   void *lib_handle;
-   initfunc_t fpi;
-   checkverfunc_t fpc;
-   getfarrayfunc_t fpg;
-   char *shlib_path;
-   char *afname=NULL;
-   int ret=0;
-
-   if (loader_data.shlibpath  == NULL) {
-      loader_init();
-   }
+  void *lib_handle = NULL;
+  initfunc_t fpi;
+  checkverfunc_t fpc;
+  getfarrayfunc_t fpg;
+  char *shlib_path = NULL;
+  char *afname = NULL;
+  int ret = 0;
+  int lib_idx = -1;
+
+  if (!modname) {
+    fprintf(stderr, "[LOADER] load_module_shlib(): no library name given\n");
+    return -1;
+  }
 
-   shlib_path = loader_format_shlibpath(modname);
+  if (!loader_data.shlibpath) {
+     loader_init();
+  }
 
-   ret = 0;
-   lib_handle = dlopen(shlib_path, RTLD_LAZY|RTLD_NODELETE|RTLD_GLOBAL);
-   if (!lib_handle) {
-      fprintf(stderr,"[LOADER] library %s is not loaded: %s\n", shlib_path,dlerror());
+  shlib_path = loader_format_shlibpath(modname);
+
+  for (int i = 0; i < loader_data.numshlibs; i++) {
+    if (strcmp(loader_data.shlibs[i].name, modname) == 0) {
+      printf("[LOADER] library %s has been loaded previously, reloading function pointers\n",
+             shlib_path);
+      lib_idx = i;
+      break;
+    }
+  }
+  if (lib_idx < 0) {
+    lib_idx = loader_data.numshlibs;
+    ++loader_data.numshlibs;
+    if (loader_data.numshlibs > loader_data.maxshlibs) {
+      fprintf(stderr, "[LOADER] can not load more than %d shlibs\n",
+              loader_data.maxshlibs);
       ret = -1;
-   } else {
-      printf("[LOADER] library %s successfully loaded\n", shlib_path);
-      afname=malloc(strlen(modname)+15);
-      sprintf(afname,"%s_checkbuildver",modname);
-      fpc = dlsym(lib_handle,afname);
-      if (fpc != NULL ){
-	 int chkver_ret = fpc(loader_data.mainexec_buildversion, &(loader_data.shlibs[loader_data.numshlibs].shlib_buildversion));
-         if (chkver_ret < 0) {
-              fprintf(stderr,"[LOADER]  %s %d lib %s, version mismatch",__FILE__, __LINE__, modname);
-              exit_fun("[LOADER] unrecoverable error");
-         }
-      }
-      sprintf(afname,"%s_autoinit",modname);
-      fpi = dlsym(lib_handle,afname);
+      goto load_module_shlib_exit;
+    }
+    loader_data.shlibs[lib_idx].name = strdup(modname);
+    loader_data.shlibs[lib_idx].thisshlib_path = strdup(shlib_path);
+  }
 
-      if (fpi != NULL ) {
-	 fpi(autoinit_arg);
-      }
+  lib_handle = dlopen(shlib_path, RTLD_LAZY|RTLD_NODELETE|RTLD_GLOBAL);
+  if (!lib_handle) {
+    fprintf(stderr,"[LOADER] library %s is not loaded: %s\n", shlib_path,dlerror());
+    ret = -1;
+    goto load_module_shlib_exit;
+  }
+
+  printf("[LOADER] library %s successfully loaded\n", shlib_path);
+  afname = malloc(strlen(modname)+15);
+  if (!afname) {
+    fprintf(stderr, "[LOADER] unable to allocate memory for library %s\n", shlib_path);
+    ret = -1;
+    goto load_module_shlib_exit;
+  }
+  sprintf(afname,"%s_checkbuildver",modname);
+  fpc = dlsym(lib_handle,afname);
+  if (fpc) {
+    int chkver_ret = fpc(loader_data.mainexec_buildversion,
+                         &(loader_data.shlibs[lib_idx].shlib_buildversion));
+    if (chkver_ret < 0) {
+      fprintf(stderr, "[LOADER]  %s %d lib %s, version mismatch",
+              __FILE__, __LINE__, modname);
+      ret = -1;
+      goto load_module_shlib_exit;
+    }
+  }
+  sprintf(afname,"%s_autoinit",modname);
+  fpi = dlsym(lib_handle,afname);
 
-      if (farray != NULL) {
-          loader_data.shlibs[loader_data.numshlibs].funcarray=malloc(numf*sizeof(loader_shlibfunc_t));
-          loader_data.shlibs[loader_data.numshlibs].numfunc=0;
-          for (int i=0; i<numf; i++) {
-	      farray[i].fptr = dlsym(lib_handle,farray[i].fname);
-	      if (farray[i].fptr == NULL ) {
-	          fprintf(stderr,"[LOADER] %s %d %s function not found %s\n",__FILE__, __LINE__, dlerror(),farray[i].fname);
-                  ret= -1;
-	      } else { /* farray[i].fptr == NULL */
-                  loader_data.shlibs[loader_data.numshlibs].funcarray[i].fname=strdup(farray[i].fname); 
-                  loader_data.shlibs[loader_data.numshlibs].funcarray[i].fptr = farray[i].fptr;
-                  loader_data.shlibs[loader_data.numshlibs].numfunc++;                 
-              }/* farray[i].fptr != NULL */
-	  } /* for int i... */
-      }	else {  /* farray ! NULL */
-          sprintf(afname,"%s_getfarray",modname);
-          fpg = dlsym(lib_handle,afname);
-          if (fpg != NULL ) {
-	      loader_data.shlibs[loader_data.numshlibs].numfunc = fpg(&(loader_data.shlibs[loader_data.numshlibs].funcarray));
-          }            
-      } /* farray ! NULL */
-    loader_data.shlibs[loader_data.numshlibs].name=strdup(modname);
-    loader_data.shlibs[loader_data.numshlibs].thisshlib_path=strdup(shlib_path); 
-
-    (loader_data.numshlibs)++;
-    } /* lib_handle != NULL */ 
-	  	 
-   if ( shlib_path!= NULL) free(shlib_path);
-   if ( afname!= NULL) free(afname);
-   if (lib_handle != NULL) dlclose(lib_handle); 
-   return ret;	       
+  if (fpi) {
+    fpi(autoinit_arg);
+  }
+
+  if (farray) {
+    if (!loader_data.shlibs[lib_idx].funcarray) {
+      loader_data.shlibs[lib_idx].funcarray = malloc(numf*sizeof(loader_shlibfunc_t));
+      if (!loader_data.shlibs[lib_idx].funcarray) {
+        fprintf(stderr, "[LOADER] load_module_shlib(): unable to allocate memory\n");
+        ret = -1;
+        goto load_module_shlib_exit;
+      }
+    }
+    loader_data.shlibs[lib_idx].numfunc = 0;
+    for (int i = 0; i < numf; i++) {
+      farray[i].fptr = dlsym(lib_handle,farray[i].fname);
+      if (!farray[i].fptr) {
+        fprintf(stderr, "[LOADER] load_module_shlib(): function %s not found: %s\n",
+                  farray[i].fname, dlerror());
+        ret = -1;
+        goto load_module_shlib_exit;
+      }
+      loader_data.shlibs[lib_idx].funcarray[i].fname=strdup(farray[i].fname);
+      loader_data.shlibs[lib_idx].funcarray[i].fptr = farray[i].fptr;
+      loader_data.shlibs[lib_idx].numfunc++;
+    } /* for int i... */
+  } else {  /* farray ! NULL */
+    sprintf(afname,"%s_getfarray",modname);
+    fpg = dlsym(lib_handle,afname);
+    if (fpg) {
+      loader_data.shlibs[lib_idx].numfunc =
+          fpg(&(loader_data.shlibs[lib_idx].funcarray));
+    }
+  } /* farray ! NULL */
+
+load_module_shlib_exit:
+  if (shlib_path) free(shlib_path);
+  if (afname)     free(afname);
+  if (lib_handle) dlclose(lib_handle);
+  return ret;
 }
 
 void * get_shlibmodule_fptr(char *modname, char *fname)

openair1/PHY/defs_common.h

@@ -995,9 +995,10 @@ static inline void wait_sync(char *thread_name) {
 }
 
 static inline int wakeup_thread(pthread_mutex_t *mutex,pthread_cond_t *cond,int *instance_cnt,char *name) {
-
-  if (pthread_mutex_lock(mutex) != 0) {
-    LOG_E( PHY, "error locking mutex for %s\n",name);
+  int rc;
+  if ((rc = pthread_mutex_lock(mutex)) != 0) {
+    LOG_E(PHY, "wakeup_thread(): error locking mutex for %s (%d %s, %p)\n",
+        name, rc, strerror(rc), (void *)mutex);
     exit_fun("nothing to add");
     return(-1);
   }
@@ -1014,8 +1015,10 @@ static inline int wakeup_thread(pthread_mutex_t *mutex,pthread_cond_t *cond,int
 }
 
 static inline int wait_on_condition(pthread_mutex_t *mutex,pthread_cond_t *cond,int *instance_cnt,char *name) {
-  if (pthread_mutex_lock(mutex) != 0) {
-    LOG_E( PHY, "[SCHED][eNB] error locking mutex for %s\n",name);
+  int rc;
+  if ((rc = pthread_mutex_lock(mutex)) != 0) {
+    LOG_E(PHY, "[SCHED][eNB] wait_on_condition(): error locking mutex for %s (%d %s, %p)\n",
+        name, rc, strerror(rc), (void *)mutex);
     exit_fun("nothing to add");
     return(-1);
   }
@@ -1035,9 +1038,10 @@ static inline int wait_on_condition(pthread_mutex_t *mutex,pthread_cond_t *cond,
 }
 
 static inline int wait_on_busy_condition(pthread_mutex_t *mutex,pthread_cond_t *cond,int *instance_cnt,char *name) {
-
-  if (pthread_mutex_lock(mutex) != 0) {
-    LOG_E( PHY, "[SCHED][eNB] error locking mutex for %s\n",name);
+  int rc;
+  if ((rc = pthread_mutex_lock(mutex)) != 0) {
+    LOG_E(PHY, "[SCHED][eNB] wait_on_busy_condition(): error locking mutex for %s (%d %s, %p)\n",
+        name, rc, strerror(rc), (void *)mutex);
     exit_fun("nothing to add");
     return(-1);
   }
@@ -1057,9 +1061,10 @@ static inline int wait_on_busy_condition(pthread_mutex_t *mutex,pthread_cond_t *
 }
 
 static inline int release_thread(pthread_mutex_t *mutex,int *instance_cnt,char *name) {
-
-  if (pthread_mutex_lock(mutex) != 0) {
-    LOG_E( PHY, "[SCHED][eNB] error locking mutex for %s\n",name);
+  int rc;
+  if ((rc = pthread_mutex_lock(mutex)) != 0) {
+    LOG_E(PHY, "[SCHED][eNB] release_thread(): error locking mutex for %s (%d %s, %p)\n",
+        name, rc, strerror(rc), (void *)mutex);
     exit_fun("nothing to add");
     return(-1);
   }

openair2/COMMON/flexran_messages_def.h

+/*
+ * 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
+ */
+
+/*
+ * flexran_messages_def.h
+ *
+ *  Created on: Apr 26, 2018
+ *      Author: R. Schmidt
+ */
+
+MESSAGE_DEF(SOFT_RESTART_MESSAGE, MESSAGE_PRIORITY_MED_PLUS, IttiMsgEmpty, soft_restart_message)

openair2/COMMON/messages_def.h

@@ -38,4 +38,4 @@
 #include "sctp_messages_def.h"
 #include "udp_messages_def.h"
 #include "gtpv1_u_messages_def.h"
-
+#include "flexran_messages_def.h"

openair2/COMMON/platform_types.h

@@ -107,9 +107,15 @@ typedef enum {
     CR_HOL   = 2,
     CR_LC    = 3,
     CR_CQI   = 4,
-    CR_NUM   = 5
+    CR_LCP   = 5,
+    CR_NUM   = 6
 } sorting_criterion_t;
 
+typedef enum {
+    POL_FAIR   = 0,
+    POL_GREEDY = 1,
+    POL_NUM    = 2
+} accounting_policy_t;
 //-----------------------------------------------------------------------------
 // PHY TYPES
 //-----------------------------------------------------------------------------

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.h

@@ -87,4 +87,14 @@ int flexran_agent_register_mac_xface(mid_t mod_id, AGENT_MAC_xface *xface);
 /*Unregister technology specific callbacks*/
 int flexran_agent_unregister_mac_xface(mid_t mod_id, AGENT_MAC_xface*xface);
 
+/***************************************
+ * FlexRAN agent - slice configuration *
+ ***************************************/
+
+/* Inform controller about possibility to update slice configuration */
+void flexran_agent_slice_update(mid_t mod_id);
+
+/* return a pointer to the current config */
+Protocol__FlexSliceConfig *flexran_agent_get_slice_config(mid_t mod_id);
+
 #endif

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.h

@@ -107,4 +107,45 @@ int parse_ul_scheduler_parameters(mid_t mod_id, yaml_parser_t *parser);
 
 int load_dl_scheduler_function(mid_t mod_id, const char *function_name);
 
+/*** Functions for handling a slice config ***/
+
+/* allocate memory for a Protocol__FlexSliceConfig structure with n_dl DL slice
+ * configs and m_ul UL slice configs */
+Protocol__FlexSliceConfig *flexran_agent_create_slice_config(int n_dl, int m_ul);
+
+/* read the general slice parameters via RAN into the given
+ * Protocol__FlexSliceConfig struct */
+void flexran_agent_read_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *s);
+
+/* read the DL slice config via the RAN into a given Protocol__FlexDlSlice
+ * struct */
+void flexran_agent_read_slice_dl_config(mid_t mod_id, int slice_idx, Protocol__FlexDlSlice *dl_slice);
+
+/* read the UL slice config via the RAN into a given Protocol__FlexUlSlice
+ * struct */
+void flexran_agent_read_slice_ul_config(mid_t mod_id, int slice_idx, Protocol__FlexUlSlice *ul_slice);
+
+/* reads content of slice over the sc_update structure, so that it can be
+ * applied later by performing a diff between slice_config and sc_update */
+void prepare_update_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *slice);
+
+/* apply generic slice parameters (e.g. intra-/interslice sharing activated or
+ * not) if there are changes. Returns the number of changed parameters. */
+int apply_new_slice_config(mid_t mod_id, Protocol__FlexSliceConfig *olds, Protocol__FlexSliceConfig *news);
+
+/* apply new configuration of slice in DL if there are changes between the
+ * parameters. Returns the number of changed parameters. */
+int apply_new_slice_dl_config(mid_t mod_id, Protocol__FlexDlSlice *oldc, Protocol__FlexDlSlice *newc);
+
+/* apply new configuration of slice in UL if there are changes between the
+ * parameters. Returns the number of changed parameters. */
+int apply_new_slice_ul_config(mid_t mod_id, Protocol__FlexUlSlice *oldc, Protocol__FlexUlSlice *newc);
+
+/* inserts a new ue_config into the structure keeping ue to slice association
+ * updates and marks so it can be applied */
+void prepare_ue_slice_assoc_update(mid_t mod_id, Protocol__FlexUeConfig *ue_config);
+
+/* apply a new association between a UE and a slice (both DL and UL) */
+int apply_ue_slice_assoc_update(mid_t mod_id);
+
 #endif /*FLEXRAN_AGENT_MAC_INTERNAL_H_*/

openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_slice_verification.h

+/*
+ * 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);

openair2/ENB_APP/CONTROL_MODULES/PDCP/flexran_agent_pdcp.c

@@ -78,6 +78,7 @@ int flexran_agent_pdcp_stats_reply(mid_t mod_id,
   
   // Protocol__FlexHeader *header;
   int i;
+  int UE_id;
   // int cc_id = 0;
  
   
@@ -85,6 +86,7 @@ int flexran_agent_pdcp_stats_reply(mid_t mod_id,
   if (report_config->nr_ue > 0) {
     
     for (i = 0; i < report_config->nr_ue; i++) {
+      UE_id = flexran_get_ue_id(mod_id, i);
 
       /* Check flag for creation of buffer status report */
       if (report_config->ue_report_type[i].ue_report_flags & PROTOCOL__FLEX_UE_STATS_TYPE__FLUST_PDCP_STATS) {
@@ -95,7 +97,7 @@ int flexran_agent_pdcp_stats_reply(mid_t mod_id,
 	  goto error;
 	protocol__flex_pdcp_stats__init(pdcp_aggr_stats);
 	
-	flexran_agent_pdcp_aggregate_stats(mod_id, i, pdcp_aggr_stats);
+	flexran_agent_pdcp_aggregate_stats(mod_id, UE_id, pdcp_aggr_stats);
 
 	pdcp_aggr_stats->has_pkt_tx=1;
 	pdcp_aggr_stats->has_pkt_tx_bytes =1;
@@ -104,7 +106,7 @@ int flexran_agent_pdcp_stats_reply(mid_t mod_id,
 	pdcp_aggr_stats->has_pkt_tx_aiat =1; 
 	pdcp_aggr_stats->has_pkt_tx_aiat_w =1;
 
-	pdcp_aggr_stats->pkt_tx_sn = flexran_get_pdcp_tx_sn(mod_id, i, DEFAULT_DRB);
+	pdcp_aggr_stats->pkt_tx_sn = flexran_get_pdcp_tx_sn(mod_id, UE_id, DEFAULT_DRB);
 	pdcp_aggr_stats->has_pkt_tx_sn =1;
 	
 	pdcp_aggr_stats->has_pkt_rx =1;
@@ -115,7 +117,7 @@ int flexran_agent_pdcp_stats_reply(mid_t mod_id,
 	pdcp_aggr_stats->has_pkt_rx_aiat_w =1;
 	pdcp_aggr_stats->has_pkt_rx_oo =1;
 
-	pdcp_aggr_stats->pkt_rx_sn = flexran_get_pdcp_rx_sn(mod_id, i, DEFAULT_DRB);
+	pdcp_aggr_stats->pkt_rx_sn = flexran_get_pdcp_rx_sn(mod_id, UE_id, DEFAULT_DRB);
 	pdcp_aggr_stats->has_pkt_rx_sn =1;
 
 	pdcp_aggr_stats->sfn = flexran_get_pdcp_sfn(mod_id);

openair2/ENB_APP/MESSAGES/V2/config_common.proto

@@ -58,6 +58,87 @@ enum flex_qam {
      FLEQ_MOD_64QAM = 1;
 }
 
+//
+// Slice config related structures and enums
+//
+enum flex_dl_sorting {
+
+	CR_ROUND = 0;	// Highest HARQ first
+	CR_SRB12 = 1;	// Highest SRB1+2 first
+	CR_HOL   = 2;	// Highest HOL first
+	CR_LC    = 3;	// Greatest RLC buffer first
+	CR_CQI   = 4;	// Highest CQI first
+	CR_LCP   = 5;	// Highest LC priority first
+}
+
+enum flex_ul_sorting {
+	CRU_ROUND = 0;	// Highest HARQ first
+	CRU_BUF   = 1;	// Highest BSR first
+	CRU_BTS   = 2;	// More bytes to schedule first
+	CRU_MCS   = 3;  // Highest MCS first
+	CRU_LCP   = 4;  // Highest LC priority first
+	CRU_HOL   = 5;  // Highest HOL first
+}
+
+enum flex_dl_accounting_policy {
+	POL_FAIR   = 0;
+	POL_GREEDY = 1;
+	POL_NUM    = 2;
+}
+
+enum flex_ul_accounting_policy {
+	POLU_FAIR   = 0;
+	POLU_GREEDY = 1;
+	POLU_NUM    = 2;
+}
+
+enum flex_slice_label {
+	xMBB  = 0;
+	URLLC = 1;
+	mMTC  = 2;
+	xMTC  = 3;
+	Other = 4;
+}
+
+message flex_dl_slice {
+	optional uint32 id = 1;
+	optional flex_slice_label label = 2;
+	// should be between 0 and 100
+	optional uint32 percentage = 3;
+	// whether this slice should be exempted form interslice sharing
+	optional bool   isolation = 4;
+	// increasing value means increasing prio
+	optional uint32 priority = 5;
+	// min and max RB to use (in frequency) in the range [0, N_RBG_MAX]
+	optional uint32 position_low = 6;
+	optional uint32 position_high = 7;
+	// maximum MCS to be allowed in this slice
+	optional uint32 maxmcs = 8;
+	repeated flex_dl_sorting sorting = 9;
+	optional flex_dl_accounting_policy accounting = 10;
+	optional string scheduler_name = 11;
+}
+
+message flex_ul_slice {
+	optional uint32 id = 1;
+	optional flex_slice_label label = 2;
+	// should be between 0 and 100
+	optional uint32 percentage = 3;
+	// whether this slice should be exempted form interslice sharing
+	optional bool   isolation = 4;
+	// increasing value means increasing prio
+	optional uint32 priority = 5;
+	// RB start to use (in frequency) in the range [0, N_RB_MAX]
+	optional uint32 first_rb = 6;
+	// TODO RB number
+	//optional uint32 length_rb = 7;
+	// maximum MCS to be allowed in this slice
+	optional uint32 maxmcs = 8;
+	repeated flex_ul_sorting sorting = 9;
+	optional flex_ul_accounting_policy accounting = 10;
+	optional string scheduler_name = 11;
+}
+
 //
 // UE config related structures and enums
 //
@@ -177,4 +258,4 @@ enum flex_ue_state_change_type {
      FLUESC_ACTIVATED = 1;
      FLUESC_DEACTIVATED = 2;
      FLUESC_MOVED = 3;
-}
\ No newline at end of file
+}

openair2/ENB_APP/MESSAGES/V2/config_messages.proto

@@ -43,6 +43,19 @@ message flex_cell_config {
 	optional uint32 eutra_band= 37;       // operating band 
 	optional int32 dl_pdsch_power = 38;       // operating downlink power 
 	optional int32 ul_pusch_power = 39;       // operating uplink power
+
+	optional flex_slice_config slice_config = 42;
+}
+
+message flex_slice_config {
+	// whether remaining RBs after first intra-slice allocation will
+	// be allocated to UEs of the same slice
+	optional bool   intraslice_share_active = 3;
+	// whether remaining RBs after slice allocation will be allocated
+	// to UEs of another slice. Isolated slices will be ignored.
+	optional bool   interslice_share_active = 4;
+	repeated flex_dl_slice dl = 1;
+	repeated flex_ul_slice ul = 2;
 }
 
 message flex_ue_config {
@@ -82,6 +95,8 @@ message flex_ue_config {
 	repeated flex_scell_config scell_config = 28;  // Secondary cells configuration
 	optional uint32 scell_deactivation_timer = 29;// Deactivation timer for secondary cell
 	optional uint64 imsi = 30;
+	optional uint32 dl_slice_id = 31;
+	optional uint32 ul_slice_id = 32;
 }
 
 message flex_lc_ue_config {

openair2/ENB_APP/enb_app.c

@@ -64,6 +64,8 @@ extern RAN_CONTEXT_t RC;
 #   define ENB_REGISTER_RETRY_DELAY 10
 # endif
 
+#include "targets/RT/USER/lte-softmodem.h"
+
 /*------------------------------------------------------------------------------*/
 
 /*
@@ -244,6 +246,10 @@ void *eNB_app_task(void *args_p)
       LOG_I(ENB_APP, "Received %s\n", ITTI_MSG_NAME(msg_p));
       break;
 
+    case SOFT_RESTART_MESSAGE:
+      handle_reconfiguration(instance);
+      break;
+
     case S1AP_REGISTER_ENB_CNF:
 # if defined(ENABLE_USE_MME)
   	LOG_I(ENB_APP, "[eNB %d] Received %s: associated MME %d\n", instance, ITTI_MSG_NAME (msg_p),
@@ -321,3 +327,53 @@ void *eNB_app_task(void *args_p)
 
   return NULL;
 }
+
+void handle_reconfiguration(module_id_t mod_id)
+{
+  struct timespec start, end;
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  flexran_agent_info_t *flexran = RC.flexran[mod_id];
+
+  LOG_I(ENB_APP, "lte-softmodem soft-restart requested\n");
+
+  if (ENB_WAIT == flexran->node_ctrl_state) {
+    /* this is already waiting, just release */
+    pthread_mutex_lock(&flexran->mutex_node_ctrl);
+    flexran->node_ctrl_state = ENB_NORMAL_OPERATION;
+    pthread_mutex_unlock(&flexran->mutex_node_ctrl);
+    pthread_cond_signal(&flexran->cond_node_ctrl);
+    return;
+  }
+
+  if (stop_L1L2(mod_id) < 0) {
+    LOG_E(ENB_APP, "can not stop lte-softmodem, aborting restart\n");
+    return;
+  }
+
+  /* node_ctrl_state should have value ENB_MAKE_WAIT only if this method is not
+   * executed by the FlexRAN thread */
+  if (ENB_MAKE_WAIT == flexran->node_ctrl_state) {
+    LOG_I(ENB_APP, " * eNB %d: Waiting for FlexRAN RTController command *\n", mod_id);
+    pthread_mutex_lock(&flexran->mutex_node_ctrl);
+    flexran->node_ctrl_state = ENB_WAIT;
+    while (ENB_NORMAL_OPERATION != flexran->node_ctrl_state)
+      pthread_cond_wait(&flexran->cond_node_ctrl, &flexran->mutex_node_ctrl);
+    pthread_mutex_unlock(&flexran->mutex_node_ctrl);
+  }
+
+  if (restart_L1L2(mod_id) < 0) {
+    LOG_E(ENB_APP, "can not restart, killing lte-softmodem\n");
+    itti_terminate_tasks(TASK_PHY_ENB);
+    return;
+  }
+
+  clock_gettime(CLOCK_MONOTONIC, &end);
+  end.tv_sec -= start.tv_sec;
+  if (end.tv_nsec >= start.tv_nsec) {
+    end.tv_nsec -= start.tv_nsec;
+  } else {
+    end.tv_sec -= 1;
+    end.tv_nsec = end.tv_nsec - start.tv_nsec + 1000000000;
+  }
+  LOG_I(ENB_APP, "lte-softmodem restart succeeded in %ld.%ld s\n", end.tv_sec, end.tv_nsec / 1000000);
+}

openair2/ENB_APP/enb_app.h

@@ -31,11 +31,11 @@
 #define ENB_APP_H_
 
 #include <stdint.h>
+#include "platform_types.h"
 
 
 void *eNB_app_task(void *args_p);
 
-/* needed for flexran: start PHY and RRC when restarting */
-void enb_app_start_phy_rrc(uint32_t enb_id_start, uint32_t enb_id_end);
+void handle_reconfiguration(module_id_t mod_id);
 
 #endif /* ENB_APP_H_ */

openair2/ENB_APP/enb_config.c

@@ -101,54 +101,51 @@ void RCconfig_flexran()
     ue_TimersAndConstants_t300, ue_TimersAndConstants_t301,
     ue_TimersAndConstants_t310, ue_TimersAndConstants_t311,
     ue_TimersAndConstants_n310, ue_TimersAndConstants_n311,
-    ue_TransmissionMode;
-
-    int32_t     ue_multiple_max               = 0;
-
-    e_SL_CP_Len_r12                rxPool_sc_CP_Len;
-    e_SL_PeriodComm_r12            rxPool_sc_Period;
-    e_SL_CP_Len_r12                rxPool_data_CP_Len;
-    long                           rxPool_ResourceConfig_prb_Num;
-    long                           rxPool_ResourceConfig_prb_Start;
-    long                           rxPool_ResourceConfig_prb_End;
-    SL_OffsetIndicator_r12_PR      rxPool_ResourceConfig_offsetIndicator_present;
-    long                           rxPool_ResourceConfig_offsetIndicator_choice;
-    SubframeBitmapSL_r12_PR        rxPool_ResourceConfig_subframeBitmap_present;
-    char*                          rxPool_ResourceConfig_subframeBitmap_choice_bs_buf;
-    long                           rxPool_ResourceConfig_subframeBitmap_choice_bs_size;
-    long                           rxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
-
-    //SIB19
-    //for discRxPool
-    SL_CP_Len_r12_t                discRxPool_cp_Len;
-    e_SL_DiscResourcePool_r12__discPeriod_r12                   discRxPool_discPeriod;
-    long                           discRxPool_numRetx;
-    long                           discRxPool_numRepetition;
-    long                           discRxPool_ResourceConfig_prb_Num;
-    long                           discRxPool_ResourceConfig_prb_Start;
-    long                           discRxPool_ResourceConfig_prb_End;
-    SL_OffsetIndicator_r12_PR      discRxPool_ResourceConfig_offsetIndicator_present;
-    long                           discRxPool_ResourceConfig_offsetIndicator_choice;
-    SubframeBitmapSL_r12_PR        discRxPool_ResourceConfig_subframeBitmap_present;
-    char*                          discRxPool_ResourceConfig_subframeBitmap_choice_bs_buf;
-    long                           discRxPool_ResourceConfig_subframeBitmap_choice_bs_size;
-    long                           discRxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
-    //for discRxPoolPS
-    SL_CP_Len_r12_t                discRxPoolPS_cp_Len;
-    e_SL_DiscResourcePool_r12__discPeriod_r12                   discRxPoolPS_discPeriod;
-    long                           discRxPoolPS_numRetx;
-    long                           discRxPoolPS_numRepetition;
-    long                           discRxPoolPS_ResourceConfig_prb_Num;
-    long                           discRxPoolPS_ResourceConfig_prb_Start;
-    long                           discRxPoolPS_ResourceConfig_prb_End;
-    SL_OffsetIndicator_r12_PR      discRxPoolPS_ResourceConfig_offsetIndicator_present;
-    long                           discRxPoolPS_ResourceConfig_offsetIndicator_choice;
-    SubframeBitmapSL_r12_PR        discRxPoolPS_ResourceConfig_subframeBitmap_present;
-    char*                          discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_buf;
-    long                           discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_size;
-    long                           discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
-
+    ue_TransmissionMode, ue_multiple_max;
+
+  const char*       rxPool_sc_CP_Len;
+  const char*       rxPool_sc_Period;
+  const char*       rxPool_data_CP_Len;
+  libconfig_int     rxPool_ResourceConfig_prb_Num;
+  libconfig_int     rxPool_ResourceConfig_prb_Start;
+  libconfig_int     rxPool_ResourceConfig_prb_End;
+  const char*       rxPool_ResourceConfig_offsetIndicator_present;
+  libconfig_int     rxPool_ResourceConfig_offsetIndicator_choice;
+  const char*       rxPool_ResourceConfig_subframeBitmap_present;
+  char*             rxPool_ResourceConfig_subframeBitmap_choice_bs_buf;
+  libconfig_int     rxPool_ResourceConfig_subframeBitmap_choice_bs_size;
+  libconfig_int     rxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
 
+  //SIB19
+  //for discRxPool
+  const char*       discRxPool_cp_Len;
+  const char*       discRxPool_discPeriod;
+  libconfig_int     discRxPool_numRetx;
+  libconfig_int     discRxPool_numRepetition;
+  libconfig_int     discRxPool_ResourceConfig_prb_Num;
+  libconfig_int     discRxPool_ResourceConfig_prb_Start;
+  libconfig_int     discRxPool_ResourceConfig_prb_End;
+  const char*       discRxPool_ResourceConfig_offsetIndicator_present;
+  libconfig_int     discRxPool_ResourceConfig_offsetIndicator_choice;
+  const char*       discRxPool_ResourceConfig_subframeBitmap_present;
+  char*             discRxPool_ResourceConfig_subframeBitmap_choice_bs_buf;
+  libconfig_int     discRxPool_ResourceConfig_subframeBitmap_choice_bs_size;
+  libconfig_int     discRxPool_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
+
+  //for discRxPoolPS
+  const char*       discRxPoolPS_cp_Len;
+  const char*       discRxPoolPS_discPeriod;
+  libconfig_int     discRxPoolPS_numRetx;
+  libconfig_int     discRxPoolPS_numRepetition;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_Num;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_Start;
+  libconfig_int     discRxPoolPS_ResourceConfig_prb_End;
+  const char*       discRxPoolPS_ResourceConfig_offsetIndicator_present;
+  libconfig_int     discRxPoolPS_ResourceConfig_offsetIndicator_choice;
+  const char*       discRxPoolPS_ResourceConfig_subframeBitmap_present;
+  char*             discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_buf;
+  libconfig_int     discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_size;
+  libconfig_int     discRxPoolPS_ResourceConfig_subframeBitmap_choice_bs_bits_unused;
 
   /* get number of eNBs */
   paramdef_t ENBSParams[] = ENBSPARAMS_DESC;
@@ -292,7 +289,7 @@ void RCconfig_L1(void) {
         LOG_I(PHY,"%s() NFAPI PNF mode - RC.nb_CC[0]=%d for init_eNB_afterRU()\n", __FUNCTION__, RC.nb_CC[0]);
         LOG_I(PHY,"%s() NFAPI PNF mode - RC.nb_macrlc_inst:%d because used by mac_top_init_eNB()\n", __FUNCTION__, RC.nb_macrlc_inst);
 
-        mac_top_init_eNB();
+        //mac_top_init_eNB();
 
         configure_nfapi_pnf(RC.eNB[j][0]->eth_params_n.remote_addr, RC.eNB[j][0]->eth_params_n.remote_portc, RC.eNB[j][0]->eth_params_n.my_addr, RC.eNB[j][0]->eth_params_n.my_portd, RC.eNB[j][0]->eth_params_n     .remote_portd);
       }

openair2/ENB_APP/flexran_agent_common.h

@@ -166,4 +166,19 @@ void flexran_agent_send_update_stats(mid_t mod_id);
 err_code_t flexran_agent_enable_cont_stats_update(mid_t mod_id, xid_t xid, stats_request_config_t *stats_req) ;
 err_code_t flexran_agent_disable_cont_stats_update(mid_t mod_id);
 
+/* Handle a received eNB config reply message as an "order" to reconfigure. It
+ * does not come as a reconfiguration message as this is a "structured"
+ * ProtoBuf message (as opposed to "unstructured" YAML). There is no destructor
+ * since we do not reply to this message (yet). Instead, the controller has to
+ * issue another eNB config request message. */
+int flexran_agent_handle_enb_config_reply(mid_t mod_id, const void* params, Protocol__FlexranMessage **msg);
+
+/* Handle a received UE config reply message as an "order" to reconfigure the
+ * association of a UE to a slice.  It does not come as a reconfiguration
+ * message as this is a "structured" ProtoBuf message (as opposed to
+ * "unstructured" YAML). There is no destructor since we do not reply to this
+ * message (yet). Instead, the controller has to issue another eNB config
+ * request message. */
+int flexran_agent_handle_ue_config_reply(mid_t mod_id, const void* params, Protocol__FlexranMessage **msg);
+
 #endif

openair2/ENB_APP/flexran_agent_common_internal.c

@@ -31,9 +31,9 @@
 
 #include "flexran_agent_common_internal.h"
 #include "flexran_agent_mac_internal.h"
-
 /* needed to soft-restart the lte-softmodem */
 #include "targets/RT/USER/lte-softmodem.h"
+#include "enb_app.h"
 
 void handle_reconfiguration(mid_t mod_id)
 {
@@ -589,3 +589,32 @@ int apply_parameter_modification(void *parameter, yaml_parser_t *parser) {
   return -1;
   
 }
+
+void initiate_soft_restart(module_id_t mod_id, Protocol__FlexCellConfig *c)
+{
+  uint8_t cc_id = c->has_cell_id ? c->cell_id : 0;
+  if (c->has_eutra_band) {
+    flexran_agent_set_operating_eutra_band(mod_id, cc_id, c->eutra_band);
+    LOG_I(ENB_APP, "Setting eutra_band to %d\n", c->eutra_band);
+  }
+  if (c->has_dl_freq && c->has_ul_freq) {
+    flexran_agent_set_operating_dl_freq(mod_id, cc_id, c->dl_freq);
+    LOG_I(ENB_APP, "Setting dl_freq to %d\n", c->dl_freq);
+    int32_t ul_freq_offset = c->ul_freq - c->dl_freq;
+    flexran_agent_set_operating_ul_freq(mod_id, cc_id, ul_freq_offset);
+    LOG_I(ENB_APP, "Setting ul_freq to %d\n", c->ul_freq);
+  }
+  if (c->has_dl_bandwidth) {
+    flexran_agent_set_operating_bandwidth(mod_id, cc_id, c->dl_bandwidth);
+    LOG_I(ENB_APP, "Setting bandwidth to %d\n", c->dl_bandwidth);
+    if (c->has_ul_bandwidth && c->ul_bandwidth != c->dl_bandwidth)
+      LOG_W(ENB_APP, "UL/DL bandwidth mismatch, applied DL bandwidth\n");
+  } else if (c->has_ul_bandwidth) {
+    flexran_agent_set_operating_bandwidth(mod_id, cc_id, c->ul_bandwidth);
+    LOG_I(ENB_APP, "Setting bandwidth to %d\n", c->ul_bandwidth);
+  }
+
+  MessageDef *msg;
+  msg = itti_alloc_new_message(TASK_FLEXRAN_AGENT, SOFT_RESTART_MESSAGE);
+  itti_send_msg_to_task(TASK_ENB_APP, ENB_MODULE_ID_TO_INSTANCE(mod_id), msg);
+}

openair2/ENB_APP/flexran_agent_common_internal.h

@@ -32,6 +32,7 @@
 #include <yaml.h>
 
 #include "flexran_agent_defs.h"
+#include "flexran.pb-c.h"
 
 int apply_reconfiguration_policy(mid_t mod_id, const char *policy, size_t policy_length);
 
@@ -57,4 +58,7 @@ int skip_subsystem_parameters_config(yaml_parser_t *parser);
 //that is not yet implmeneted in order to skip its configuration, without affecting the rest
 int skip_parameter_modification(yaml_parser_t *parser);
 
+// applies reconfiguration parameters and notifies ENB APP
+void initiate_soft_restart(mid_t mod_id, Protocol__FlexCellConfig *c);
+
 #endif

openair2/ENB_APP/flexran_agent_handler.c

@@ -46,9 +46,9 @@ flexran_agent_message_decoded_callback agent_messages_callback[][3] = {
   {0, 0, 0}, /*PROTOCOK__FLEXRAN_MESSAGE__MSG_SF_TRIGGER_MSG*/
   {0, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_UL_SR_INFO_MSG*/
   {flexran_agent_enb_config_reply, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_ENB_CONFIG_REQUEST_MSG*/
-  {0, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_ENB_CONFIG_REPLY_MSG*/
+  {flexran_agent_handle_enb_config_reply, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_ENB_CONFIG_REPLY_MSG*/
   {flexran_agent_ue_config_reply, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_CONFIG_REQUEST_MSG*/
-  {0, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_CONFIG_REPLY_MSG*/
+  {flexran_agent_handle_ue_config_reply, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_CONFIG_REPLY_MSG*/
   {flexran_agent_lc_config_reply, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_LC_CONFIG_REQUEST_MSG*/
   {0, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_LC_CONFIG_REPLY_MSG*/
   {flexran_agent_mac_handle_dl_mac_config, 0, 0}, /*PROTOCOL__FLEXRAN_MESSAGE__MSG_DL_MAC_CONFIG_MSG*/
@@ -210,6 +210,7 @@ int flexran_agent_handle_stats(mid_t mod_id, const void *params, Protocol__Flexr
 
   //TODO: We do not deal with multiple CCs at the moment and eNB id is 0
   int enb_id = mod_id;
+  int UE_id;
 
   //eNB_MAC_INST *eNB = &eNB_mac_inst[enb_id];
   //UE_list_t *eNB_UE_list=  &eNB->UE_list;
@@ -249,8 +250,9 @@ int flexran_agent_handle_stats(mid_t mod_id, const void *params, Protocol__Flexr
   goto error;
       }
       for (i = 0; i < report_config.nr_ue; i++) {
-  report_config.ue_report_type[i].ue_rnti = flexran_get_ue_crnti(enb_id, i); //eNB_UE_list->eNB_UE_stats[UE_PCCID(enb_id,i)][i].crnti;
-  report_config.ue_report_type[i].ue_report_flags = ue_flags;
+        UE_id = flexran_get_ue_id(mod_id, i);
+        report_config.ue_report_type[i].ue_rnti = flexran_get_ue_crnti(enb_id, UE_id); //eNB_UE_list->eNB_UE_stats[UE_PCCID(enb_id,i)][i].crnti;
+        report_config.ue_report_type[i].ue_report_flags = ue_flags;
       }
       //Set the number of CCs and create a list with the cell stats configs
       report_config.nr_cc = MAX_NUM_CCs;
@@ -359,7 +361,8 @@ int flexran_agent_handle_stats(mid_t mod_id, const void *params, Protocol__Flexr
       goto error;
     }
     for (i = 0; i < report_config.nr_ue; i++) {
-      report_config.ue_report_type[i].ue_rnti = ue_req->rnti[i];
+      UE_id = flexran_get_ue_id(mod_id, i);
+      report_config.ue_report_type[i].ue_rnti = ue_req->rnti[UE_id];
       report_config.ue_report_type[i].ue_report_flags = ue_req->flags;
     }
     break;

openair2/LAYER2/MAC/config.c

@@ -733,7 +733,7 @@ rrc_mac_config_req_eNB(module_id_t Mod_idP,
     if (RC.mac == NULL)
       l2_init_eNB();
 
-    mac_top_init_eNB();
+    //mac_top_init_eNB();
 
     RC.mac[Mod_idP]->common_channels[CC_idP].mib = mib;
     RC.mac[Mod_idP]->common_channels[CC_idP].physCellId = physCellId;
@@ -852,16 +852,21 @@ rrc_mac_config_req_eNB(module_id_t Mod_idP,
       LOG_E(MAC, "%s:%d:%s: ERROR, UE_id == -1\n", __FILE__,
 	    __LINE__, __FUNCTION__);
     } else {
-      if (logicalChannelConfig)
+		if (logicalChannelConfig) {
         UE_list->
           UE_template[CC_idP][UE_id].lcgidmap
           [logicalChannelIdentity] =
           *logicalChannelConfig->
-	  ul_SpecificParameters->logicalChannelGroup;
-      else
-        UE_list->
-          UE_template[CC_idP][UE_id].lcgidmap
-          [logicalChannelIdentity] = 0;
+			ul_SpecificParameters->logicalChannelGroup;
+		UE_list->
+          UE_template[CC_idP][UE_id].lcgidpriority
+          [logicalChannelIdentity]=
+			logicalChannelConfig->ul_SpecificParameters->priority;
+
+		} else
+			UE_list->
+				UE_template[CC_idP][UE_id].lcgidmap
+				[logicalChannelIdentity] = 0;
     }
   }
 

openair2/LAYER2/MAC/eNB_scheduler.c

@@ -703,6 +703,10 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP, frame_t frameP,
       allocate_CCEs(module_idP, CC_id, frameP, subframeP, 2);
   }
 
+  if (mac_agent_registered[module_idP] && subframeP == 9) {
+    flexran_agent_slice_update(module_idP);
+  }
+
   stop_meas(&RC.mac[module_idP]->eNB_scheduler);
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME

openair2/LAYER2/MAC/eNB_scheduler_fairRR.c

@@ -542,8 +542,9 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
   uint16_t                temp_total_rbs_count;
   unsigned char           temp_total_ue_count;
   unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX];
+  uint8_t slice_allocation[MAX_NUM_CCs][N_RBG_MAX];
   int                     UE_id, i; 
-  uint16_t                j;
+  uint16_t                j,c;
   uint16_t                nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
   uint16_t                nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 //  uint16_t                nb_rbs_required_remaining_1[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
@@ -554,8 +555,6 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
   uint8_t CC_id;
   UE_list_t *UE_list = &RC.mac[Mod_id]->UE_list;
 
-  int N_RB_DL;
-  int transmission_mode = 0;
   UE_sched_ctrl *ue_sched_ctl;
   //  int rrc_status           = RRC_IDLE;
   COMMON_channels_t *cc;
@@ -590,14 +589,14 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
 
 
 	    dlsch_scheduler_pre_processor_reset(Mod_id,
-						UE_id,
-						CC_id,
+                                                0,
 						frameP,
 						subframeP,
-						N_RBG[CC_id],
+                                                min_rb_unit,
 						(uint16_t (*)[NUMBER_OF_UE_MAX])nb_rbs_required,
 						rballoc_sub,
-						MIMO_mode_indicator);
+						MIMO_mode_indicator,
+                                                mbsfn_flag);
 
 	}
     }
@@ -621,7 +620,6 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
     average_rbs_per_user[CC_id] = 0;
     cc = &RC.mac[Mod_id]->common_channels[CC_id];
     // Get total available RBS count and total UE count
-    N_RB_DL = to_prb(cc->mib->message.dl_Bandwidth);
     temp_total_rbs_count = RC.mac[Mod_id]->eNB_stats[CC_id].available_prbs;
     temp_total_ue_count = dlsch_ue_select[CC_id].ue_num;
 
@@ -658,19 +656,22 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
         nb_rbs_required_remaining[CC_id][UE_id] = cmin(average_rbs_per_user[CC_id], dlsch_ue_select[CC_id].list[i].nb_rb);
       }
 
-      transmission_mode = get_tmode(Mod_id,CC_id,UE_id);
+      /* slicing support has been introduced into the scheduler. Provide dummy
+       * data so that the preprocessor "simply works" */
+      for (c = 0; c < MAX_NUM_CCs; ++c)
+        for (j = 0; j < N_RBG_MAX; ++j)
+          slice_allocation[c][j] = 1;
 
       LOG_T(MAC,"calling dlsch_scheduler_pre_processor_allocate .. \n ");
       dlsch_scheduler_pre_processor_allocate (Mod_id,
                                               UE_id,
                                               CC_id,
                                               N_RBG[CC_id],
-                                              transmission_mode,
                                               min_rb_unit[CC_id],
-                                              N_RB_DL,
                                               (uint16_t (*)[NUMBER_OF_UE_MAX])nb_rbs_required,
                                               (uint16_t (*)[NUMBER_OF_UE_MAX])nb_rbs_required_remaining,
                                               rballoc_sub,
+                                              slice_allocation,
                                               MIMO_mode_indicator);
       temp_total_rbs_count -= ue_sched_ctl->pre_nb_available_rbs[CC_id];
       temp_total_ue_count--;

openair2/LAYER2/MAC/eNB_scheduler_primitives.c

@@ -62,8 +62,6 @@ extern uint16_t frame_cnt;
 
 extern RAN_CONTEXT_t RC;
 
-extern int n_active_slices;
-
 int choose(int n, int k)
 {
   int res = 1;
@@ -1853,7 +1851,7 @@ rnti_t UE_RNTI(module_id_t mod_idP, int ue_idP)
     return (rnti);
   }
 
-  LOG_D(MAC, "[eNB %d] Couldn't find RNTI for UE %d\n", mod_idP, ue_idP);
+  //LOG_D(MAC, "[eNB %d] Couldn't find RNTI for UE %d\n", mod_idP, ue_idP);
   //display_backtrace();
   return (NOT_A_RNTI);
 }
@@ -1963,6 +1961,9 @@ int add_new_ue(module_id_t mod_idP, int cc_idP, rnti_t rntiP, int harq_pidP
 	   sizeof(eNB_UE_STATS));
     UE_list->UE_sched_ctrl[UE_id].ue_reestablishment_reject_timer = 0;
 
+    /* default slice in case there was something different */
+    UE_list->assoc_dl_slice_idx[UE_id] = 0;
+    UE_list->assoc_ul_slice_idx[UE_id] = 0;
 
     UE_list->UE_sched_ctrl[UE_id].ta_update = 31;
 
@@ -4536,19 +4537,31 @@ harq_indication(module_id_t mod_idP, int CC_idP, frame_t frameP,
 
 // Flexran Slicing functions
 
-uint16_t flexran_nb_rbs_allowed_slice(float rb_percentage, int total_rbs)
+uint16_t nb_rbs_allowed_slice(float rb_percentage, int total_rbs)
 {
     return (uint16_t) floor(rb_percentage * total_rbs);
 }
 
-int ue_slice_membership(int UE_id, int slice_id)
+int ue_dl_slice_membership(module_id_t mod_id, int UE_id, int slice_idx)
 {
-  if ((slice_id < 0) || (slice_id > n_active_slices))
-    LOG_W(MAC, "out of range slice id %d\n", slice_id);
-
+  if ((slice_idx < 0)
+      || (slice_idx >= RC.mac[mod_id]->slice_info.n_dl)) {
+    LOG_W(MAC, "out of range slice index %d (slice ID %d)\n",
+          slice_idx, RC.mac[mod_id]->slice_info.dl[slice_idx].id);
+    return 0;
+  }
+  return RC.mac[mod_id]->UE_list.active[UE_id] == TRUE
+         && RC.mac[mod_id]->UE_list.assoc_dl_slice_idx[UE_id] == slice_idx;
+}
 
-  if ((UE_id % n_active_slices) == slice_id) {
-    return 1;	// this ue is a member of this slice
+int ue_ul_slice_membership(module_id_t mod_id, int UE_id, int slice_idx)
+{
+  if ((slice_idx < 0)
+      || (slice_idx >= RC.mac[mod_id]->slice_info.n_ul)) {
+    LOG_W(MAC, "out of range slice index %d (slice ID %d)\n",
+          slice_idx, RC.mac[mod_id]->slice_info.dl[slice_idx].id);
+    return 0;
   }
-  return 0;
+  return RC.mac[mod_id]->UE_list.active[UE_id] == TRUE
+         && RC.mac[mod_id]->UE_list.assoc_ul_slice_idx[UE_id] == slice_idx;
 }

openair2/LAYER2/MAC/mac.h

@@ -159,7 +159,7 @@
 #define MIN_MAC_HDR_RLC_SIZE    (1 + MIN_RLC_PDU_SIZE)
 
 /*!\brief maximum number of slices / groups */
-#define MAX_NUM_SLICES 4
+#define MAX_NUM_SLICES 10
 
 
 #define U_PLANE_INACTIVITY_VALUE 6000
@@ -849,6 +849,9 @@ typedef struct {
     /// LCGID mapping
     long lcgidmap[11];
 
+	///UE logical channel priority
+    long lcgidpriority[11];
+
     /// phr information
     int8_t phr_info;
 
@@ -1099,6 +1102,10 @@ typedef struct {
 
     /// Sorting criteria for the UE list in the MAC preprocessor
     uint16_t sorting_criteria[MAX_NUM_SLICES][CR_NUM];
+    uint16_t first_rb_offset[NFAPI_CC_MAX][MAX_NUM_SLICES];
+
+    int assoc_dl_slice_idx[MAX_MOBILES_PER_ENB];
+    int assoc_ul_slice_idx[MAX_MOBILES_PER_ENB];
 
 } UE_list_t;
 
@@ -1118,6 +1125,117 @@ typedef struct {
     int tail_freelist; ///the tail position of the delete list
 } UE_free_list_t;
 
+/// Structure for saving the output of each pre_processor instance
+typedef struct {
+    uint16_t nb_rbs_required[NFAPI_CC_MAX][MAX_MOBILES_PER_ENB];
+    uint16_t nb_rbs_accounted[NFAPI_CC_MAX][MAX_MOBILES_PER_ENB];
+    uint16_t nb_rbs_remaining[NFAPI_CC_MAX][MAX_MOBILES_PER_ENB];
+    uint8_t  slice_allocation_mask[NFAPI_CC_MAX][N_RBG_MAX];
+    uint8_t  MIMO_mode_indicator[NFAPI_CC_MAX][N_RBG_MAX];
+
+    uint32_t bytes_lcid[MAX_MOBILES_PER_ENB][MAX_NUM_LCID];
+    uint32_t wb_pmi[NFAPI_CC_MAX][MAX_MOBILES_PER_ENB];
+    uint8_t  mcs[NFAPI_CC_MAX][MAX_MOBILES_PER_ENB];
+
+} pre_processor_results_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];
+
+    pre_processor_results_t pre_processor_results[MAX_NUM_SLICES];
+
+    /// common rb allocation list between slices
+    uint8_t rballoc_sub[NFAPI_CC_MAX][N_RBG_MAX];
+} slice_info_t;
+
 /*! \brief eNB common channels */
 typedef struct {
     int physCellId;
@@ -1238,7 +1356,10 @@ typedef struct eNB_MAC_INST_s {
   /// UL handle
   uint32_t ul_handle;
   UE_list_t UE_list;
-  
+
+  /// 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/PDCP_v10.1.0/pdcp.c

@@ -169,6 +169,11 @@ boolean_t pdcp_data_req(
     start_meas(&UE_pdcp_stats[ctxt_pP->module_id].data_req);
   }
 
+  for (pdcp_uid = 0; pdcp_uid < MAX_MOBILES_PER_ENB; ++pdcp_uid) {
+    if (pdcp_enb[ctxt_pP->module_id].rnti[pdcp_uid] == ctxt_pP->rnti)
+      break;
+  }
+
   // PDCP transparent mode for MBMS traffic
 
   if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) {
@@ -366,13 +371,24 @@ boolean_t pdcp_data_req(
     LOG_DUMPMSG(PDCP,DEBUG_PDCP,(char *)pdcp_pdu_p->data,pdcp_pdu_size,
                 "[MSG] PDCP DL %s PDU on rb_id %d\n",(srb_flagP)? "CONTROL" : "DATA", rb_idP);
 
-    rlc_status = rlc_data_req(ctxt_pP, srb_flagP, MBMS_FLAG_NO, rb_idP, muiP, confirmP, pdcp_pdu_size, pdcp_pdu_p
+    /* if RLC buffer for this UE has been full, we want to skip all subsequent
+     * traffic for TM_SKIP_FULL_BUF_MS ms. Afterwards, it will be checkd again */
+    if (pdcp_enb[ctxt_pP->module_id].time_buf_full[pdcp_uid] == 0
+        || pdcp_enb[ctxt_pP->module_id].sfn - pdcp_enb[ctxt_pP->module_id].time_buf_full[pdcp_uid] >= TM_SKIP_FULL_BUF_MS) {
+      pdcp_enb[ctxt_pP->module_id].time_buf_full[pdcp_uid] = 0;
+      rlc_status = rlc_data_req(ctxt_pP, srb_flagP, MBMS_FLAG_NO, rb_idP, muiP,
+                                confirmP, pdcp_pdu_size, pdcp_pdu_p
 #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
-                             ,sourceL2Id
-                             ,destinationL2Id
+                                ,sourceL2Id
+                                ,destinationL2Id
 #endif
-                             );
-
+                               );
+    } else {
+      /* RLC would free pdcp_pdu_p, but since we skip it, have to do it
+       * ourselves and fake normal operation */
+      free_mem_block(pdcp_pdu_p, __func__);
+      rlc_status = RLC_OP_SKIPPED_FUL_BUF;
+    }
   }
 
   switch (rlc_status) {
@@ -383,18 +399,24 @@ boolean_t pdcp_data_req(
 
   case RLC_OP_STATUS_BAD_PARAMETER:
     LOG_W(PDCP, "Data sending request over RLC failed with 'Bad Parameter' reason!\n");
-    ret= FALSE;
-    break;
+    return FALSE;
 
   case RLC_OP_STATUS_INTERNAL_ERROR:
     LOG_W(PDCP, "Data sending request over RLC failed with 'Internal Error' reason!\n");
-    ret= FALSE;
-    break;
+    return FALSE;
 
   case RLC_OP_STATUS_OUT_OF_RESSOURCES:
+    pdcp_enb[ctxt_pP->module_id].time_buf_full[pdcp_uid] = pdcp_enb[ctxt_pP->module_id].sfn;
     LOG_W(PDCP, "Data sending request over RLC failed with 'Out of Resources' reason!\n");
-    ret= FALSE;
-    break;
+    int h = TM_SKIP_FULL_BUF_MS;
+    LOG_W(PDCP, "Blocking incoming traffic for %d ms\n", h);
+    return FALSE;
+
+  case RLC_OP_SKIPPED_FUL_BUF:
+    LOG_D(PDCP, "Skipping RLC request due to full buffer\n");
+    /* fake good return so that GTP doesn't spam us and return immediately so
+     * that dropped traffic is not counted in PDCP traffic stats */
+    return TRUE;
 
   default:
     LOG_W(PDCP, "RLC returned an unknown status code after PDCP placed the order to send some data (Status Code:%d)\n", rlc_status);
@@ -408,16 +430,6 @@ boolean_t pdcp_data_req(
     stop_meas(&UE_pdcp_stats[ctxt_pP->module_id].data_req);
   }
 
-  /*
-   * Control arrives here only if rlc_data_req() returns RLC_OP_STATUS_OK
-   * so we return TRUE afterwards
-   */
-  
-  for (pdcp_uid=0; pdcp_uid< MAX_MOBILES_PER_ENB;pdcp_uid++){
-    if (pdcp_enb[ctxt_pP->module_id].rnti[pdcp_uid] == ctxt_pP->rnti ) 
-      break;
-  }
-
   //LOG_I(PDCP,"ueid %d lcid %d tx seq num %d\n", pdcp_uid, rb_idP+rb_offset, current_sn);
   Pdcp_stats_tx[ctxt_pP->module_id][pdcp_uid][rb_idP+rb_offset]++;
   Pdcp_stats_tx_tmp_w[ctxt_pP->module_id][pdcp_uid][rb_idP+rb_offset]++;
@@ -1066,6 +1078,7 @@ void pdcp_add_UE(const protocol_ctxt_t* const  ctxt_pP){
       if (pdcp_enb[ctxt_pP->module_id].rnti[i] == 0 ){
 	pdcp_enb[ctxt_pP->module_id].rnti[i]=ctxt_pP->rnti;
 	pdcp_enb[ctxt_pP->module_id].uid[i]=i;
+        pdcp_enb[ctxt_pP->module_id].time_buf_full[i] = 0;
 	pdcp_enb[ctxt_pP->module_id].num_ues++;
 	printf("add new uid is %d %x\n\n", i, ctxt_pP->rnti);
 	// ret=1;

openair2/LAYER2/PDCP_v10.1.0/pdcp.h

@@ -106,6 +106,8 @@ typedef struct pdcp_enb_s {
   uint16_t uid[MAX_MOBILES_PER_ENB];
   rnti_t rnti[MAX_MOBILES_PER_ENB];
   uint16_t num_ues;
+#define TM_SKIP_FULL_BUF_MS (500)
+  uint64_t time_buf_full[MAX_MOBILES_PER_ENB];
   
   uint64_t sfn;
   frame_t  frame;

openair2/LAYER2/RLC/rlc.h

@@ -67,6 +67,7 @@ typedef uint64_t hash_key_t;
 #define  RLC_OP_STATUS_BAD_PARAMETER     22
 #define  RLC_OP_STATUS_INTERNAL_ERROR    2
 #define  RLC_OP_STATUS_OUT_OF_RESSOURCES 3
+#define  RLC_OP_SKIPPED_FUL_BUF          4
 
 #define  RLC_MUI_UNDEFINED     (mui_t)0