The Drift and Resource Allocation Minimization (DREAMIN) scheduler is a channel-aware inter-slice radio resource scheduler oriented to efficiently reducing SLA drift and resource usage. This repository has all the code we implemented to execute the experiments we show in our paper. It contains:
simulation/- our simulation of a downlink 5G scenariosimulation/intersched.py- implementations of inter-slice scheduling algorithms, including DREAMIN, RadioSaber, and a Weighted Round-Robinsimulation/intrasched.py- implementations of intra-slice scheduling algorithms, including Round-Robin, Proportional Fairness, and Maximum Throughputoptimal_model/- implementation of our problem formulation in docplex to run on IBM's Constraint Programming Optimizercqi-traces-noise0/- traces dataset from RadioSaber, originally available hereconfig/- CQI mapping tables, seed values for reproductible randomness, slice requirements, user demands, and other parameters for each experimental scenariorun_optimization_model.py- script for solving the formulated problem using IBM's Constraint Programming Optimizer and saving its results inresults/main.py- script for running the simulation and saving its metrics inmetrics/generate_plots.py- script for reading simulation metrics inmetrics/and generating plots inplots/execute_experiments.sh- script that automates all experiments and saves outputs inoutputs/
Use the bibtex below:
@inproceedings{icc_dgmk_2024,
author={Campos, Daniel and Almeida, Gabriel M and Abdel-Rahman, Mohammad J and Cardoso, Kleber V},
title = {DREAMIN: Channel-Aware Inter-Slices Radio Resource Scheduling for Efficient SLA Assurance},
booktitle = {ICC 2025-IEEE International Conference on Communications},
location = {Montreal, Canada},
year = {2025},
keywords = {Service level agreement, network slicing, resource block, radio resource scheduling, energy efficiency},
organization={IEEE},
pages = {2126--2131},
keywords={Measurement;Constraint handling;Network slicing;Quality of service;Minimization;Energy efficiency;Resource management;Indexes;Service level agreements;Service level agreement;network slicing;resource block;radio resource scheduling;energy efficiency},
doi={10.1109/ICC52391.2025.11162061}
}All experiments were executed in a Thinkpad E14 gen 4 (40 GB RAM and Intel i7-1255U 12 cores 4.7 GHz) running Ubuntu 20.04.
As all code is written in Python, this is the only language you need to have installed. You'll also need IBM's Constraint Programming Optimizer to execute the optimization model. To build the same environment we used in our evaluations, install:
- Python 3.8.10 with pip 20.0.2
- IBM ILOG CPLEX Optimization Studio 22.1.0
Python dependencies:
- tqdm
- numpy
- typing
- matplotlib
- pandas
- scipy
- docplex
Install all Python dependencies by running:
pip3 install tqdm numpy typing matplotlib pandas scipy docplexAdditionally, make sure the cpooptimizer_bin_path parameter at line 330 from optimal_model/Experiment.py matches the path to the binaries of IBM's Constraint Programming Optimizer.
In this work, we evaluate 4 different scenarios, each one with 3 slices:
small_plentiful- 10 TTIs, 1 user per slice, and enough resources to meet all SLA requirements for all userssmall_scarce- 10 TTIs, 1 user per slice, and higher SLA requirements that cannot be met for every user at every TTIlarge_plentiful- 475 TTIs, 1 user per slice, and enough resources to meet all SLA requirements for all users during most of the timelarge_scarce- 475 TTIs, 3 user per slice, and not enough resources to meet all SLA requirements for all users
Due to the limitations of optimally solving the implemented optimization model, we can only execute the solver for small scenarios.
Each scenario is executed 20 times.
At each time, a different set of users is selected, defined by the seed in config/seeds.json.
Note that the solver, which has a time limit of 1 hour to find the best solution, will solve 40 different problems (20 times the small_plentiful + 20 times the small_scarce), totalizing 40 hours of execution.
You can change the time_limit fields in config/small_plentiful/opt_model.json and config/small_scarce/opt_model.json to adjust how many seconds one search will take.
After obtaining the solutions from the optimization model, you'll be able to run the simulations.
Each simulation executes 20 times, following the same sets of users defined by config/seeds.json.
A different simulation is executed for each one of the evaluated inter-slice schedulers.
You can change which inter-slice schedulers will be evaluated in config/small_plentiful/simulation.json, config/small_scarce/simulation.json, config/large_plentiful/simulation.json, and config/large_scarce/simulation.json.
To run the optimization model and simulations and generate the plots with only one command, you may execute:
bash execute_experiments.shAt the end, you'll be able to check:
- The collected metrics from the simulations, saved as .csv files inside
metrics/ - The generated plots inside
plots/ - The outputs from the executed commands in
outputs/
If you want to execute only certain steps or scenarios of the experiment, check the following subsections.
To run the optimization model, execute:
python3 run_optimization_model.py <scenario> where <scenario> may be small_plentiful or small_scarce.
To run the simulations, execute:
python3 main.py <scenario>where <scenario> may be small_plentiful, small_scarce, large_plentiful, or large_scarce.
Note that, as the simulation config files for small_plentiful and small_scarce scenarios include the Optimal inter-slice scheduler, you need to have the results from the optimization model stored in results/ to execute this step.
To generate the plots, execute:
python3 generate_plots.py <scenario>where <scenario> may be small_plentiful, small_scarce, large_plentiful, or large_scarce.
Note that you need to execute the simulations of a scenario before generating its plots so the collected metrics are stored in metrics/ for analysis.
If you have any questions, please email Daniel "Dante" Campos: dcamposfsa@vt.edu