Towards Fair and QoS-Aware Bandwidth Allocation in Next-Generation Multi-Gigabit WANs
Abstract
1. Introduction
2. Related Work
2.1. Fairness in Bandwidth Allocation
2.2. QoS-Aware Bandwidth Allocation
2.3. Integration of Fairness and QoS
2.4. Energy Efficiency in Bandwidth Allocation
2.5. Research Gap
3. Proposed Framework for FQ-DBA
3.1. Objectives
- Fairness: Ensure equitable bandwidth allocation among users and applications, preventing the starvation of low-priority traffic.
- QoS Awareness: Prioritise traffic based on QoS requirements, such as latency, jitter, and packet loss, for critical applications.
- Efficiency: Optimise bandwidth utilisation to maximise throughput and minimise latency.
- Scalability: Operate efficiently in large-scale, high-capacity multi-gigabit networks.
- Energy Efficiency: Reduce energy consumption in network devices.
3.2. Key Features
- Traffic Classification: FQ-DBA classifies traffic based on application type (e.g., VoIP, video streaming, file transfer) and QoS requirements, ensuring that high-priority traffic receives the necessary resources.
- Fairness Enforcement: The algorithm calculates the fair share of bandwidth for each user or application and ensures that low-priority traffic receives a minimum guaranteed bandwidth to prevent starvation.
- QoS-Aware Allocation: FQ-DBA implements priority queuing and bandwidth reservation to meet the QoS requirements of critical applications. Bandwidth allocation is dynamically adjusted based on real-time network conditions.
- Dynamic Bandwidth Allocation: The algorithm treats available bandwidth as a shared resource pool and allocates it dynamically based on demand, fairness, and QoS requirements.
- Performance Optimisation: FQ-DBA implements congestion control and latency reduction mechanisms to optimise network performance.
3.3. Algorithm Components
- i.
- Traffic Classification
- Application Awareness: Classify traffic based on application type and QoS requirements.
- User Fairness: Identify users or traffic flows to ensure fair resource allocation.
- ii.
- Bandwidth Demand Estimation
- Historical Data Analysis: Use historical traffic patterns to estimate bandwidth requirements.
- Real-Time Monitoring: Continuously monitor traffic demands and network conditions to adjust bandwidth allocation dynamically.
- iii.
- Fairness Enforcement
- Fair Share Calculation: Calculate the fair share of bandwidth for each user or application based on predefined fairness criteria (e.g., max-min fairness, proportional fairness).
- Starvation Prevention: Ensure that low-priority traffic receives a minimum guaranteed bandwidth.
- iv.
- QoS-Aware Allocation
- Priority Queuing: Implement priority queues to handle high-priority traffic with strict QoS requirements.
- Bandwidth Reservation: Reserve bandwidth for critical applications to ensure QoS guarantees.
- Dynamic Adjustment: Adjust bandwidth allocation dynamically to meet QoS requirements as network conditions change.
- v.
- Dynamic Bandwidth Allocation
- Resource Pooling: Treat available bandwidth as a shared resource pool and allocate it dynamically based on demand and fairness criteria.
- Load Balancing: Distribute traffic across available paths to prevent congestion and ensure efficient resource utilisation.
- vi.
- Performance Optimisation
- Congestion Control: Implement congestion avoidance mechanisms (e.g., rate limiting, traffic shaping) to prevent network overload.
- Latency Reduction: Optimise path selection and bandwidth allocation to minimise end-to-end latency for latency-sensitive applications.
3.4. Algorithm Workflow: (Figure 1)
- Initialisation: Classify traffic and initialise monitoring mechanisms.
- Bandwidth Demand Estimation: Estimate bandwidth requirements using historical data and real-time monitoring.
- Fairness Enforcement: Calculate fair shares and allocate bandwidth to ensure fairness.
- QoS-Aware Allocation: Prioritise high-priority traffic and reserve bandwidth for critical applications.
- Dynamic Bandwidth Allocation: Allocate bandwidth dynamically based on demand, fairness, and QoS requirements.
- Performance Optimisation: Monitor network performance and adjust bandwidth allocation to optimise throughput, latency, and resource utilisation.

3.4.1. Key Workflow Summary
- Initialise: Configure queues, QoS policies, and fairness thresholds.
- Monitor: Capture and classify live traffic.
- Assess Fairness: Compute fairness index across classes.
- Allocate:
- Enforce priority-based bandwidth if fair.
- Redistribute if unfair (fairness < threshold).
- Adjust Dynamically:
- Increase bandwidth for congested queues.
- Decrease bandwidth for underutilised queues.
- Repeat: Iterate at fixed intervals.
3.4.2. FQ DBA Algorithm
| Algorithm 1: Fair and QoS-Aware Dynamic Bandwidth Allocation (FQ-DBA) | |
| 1. | function FQ-DBA(node): |
| 2. | //Initialisation configureQueues() |
| 3. | defineQoSParameters() |
| 4. | setFairnessThreshold() |
| 5. | while simulationRunning: |
| 6. | //Step 1: Real-Time Traffic Capture currentTraffic = captureTraffic(node) |
| 7. | classifiedTraffic = classifyTraffic(currentTraffic) |
| 8. | //Step 2: Calculate Fairness fairnessIndex = calculateFairnessIndex(classifiedTraffic) |
| 9. | //Step 3: Allocate Bandwidth for each trafficClass in classifiedTraffic: |
| 10. | if fairnessIndex < fairnessThreshold: adjustBandwidthAllocations(classifiedTraffic) |
| 11. | if trafficClass == “Real-Time”: allocateBandwidth(trafficClass, highPriority) |
| 12. | else if trafficClass == “Interactive”: allocateBandwidth(trafficClass, mediumPriority) |
| 13. | else if trafficClass == “Background”: allocateBandwidth(trafficClass, lowPriority) |
| 14. | //Step 4: Dynamic Adjustment if queueLengthExceedsThreshold(): |
| 15 | for each trafficClass in classifiedTraffic: |
| 16 | if queueLength(trafficClass) > queueThreshold: increaseBandwidth(trafficClass) |
| 17 | else: decreaseBandwidth(trafficClass) |
| 18 | wait(timeInterval) |
4. Research Methodology
4.1. Research Philosophy
4.2. Datasets for Simulation and Validation
- Traffic Pattern Datasets:
- Real-world traces from CAIDA, MAWI, and ISP backbone captures.
- Synthetic generators including ON/OFF, self-similar, and flash crowd models.
- QoS-classified flows (VoIP, video streaming, bulk transfers, gaming).
- Adversarial traffic patterns (e.g., DDoS-like bursts, QoS abuse attempts).
- Network Performance Datasets:
- Link utilisation logs from operational backbones.
- Latency and jitter measurements per flow and per class.
- Packet drop statistics (congestion-induced and policy-driven).
- SLA compliance data for baseline benchmarking.
4.3. Simulation Methodology
- Topology Setup: Hybrid fat-tree plus ISP-like core topology with 10 Gbps links.
- Traffic Injection: Multi-class traffic generation with strict priority and weighted fair queuing.
- Execution:
- Dynamic weight adjustment based on real-time demand.
- QoS policing through rate limiting and priority-aware scheduling.
- Tools Used:
- NS-3 for packet-level simulation.
- Python-based SDN-style controllers for centralised policy orchestration.
- Dockerised testbed for reproducibility and automated deployment.
4.4. Performance Metrics Framework
- Fairness: Jain’s fairness index and per-class throughput ratios.
- QoS Compliance: 99th percentile latency, jitter bounds, and packet loss rates.
- Efficiency: Link utilisation and achieved goodput.
- Resilience: Recovery time following traffic surges or overloads.
4.5. Validation Framework
- Baseline Comparisons: FQ-DBA was benchmarked against Static Allocation, IPACT-based DBA, and ML-based DBA (e.g., LSTM-DBA).
- Stress Testing: Experiments included overload scenarios (up to 150% capacity) and mixed criticality workloads.
- Statistical Validation: Key metrics were reported with 95% confidence intervals. ANOVA tests were conducted to evaluate whether observed improvements were statistically significant.
5. Evaluation of FQ-DBA
5.1. Simulation Setup
- Static Allocation (Fixed BW per user)
- Proportional Fair (PF) Allocation
- Hierarchical Token Bucket (HTB)
5.2. Network Parameters
5.3. Simulation Results
5.3.1. Fairness Comparison (Jain’s Index)

5.3.2. QoS Compliance (% Flows Meeting SLA)

5.3.3. Throughput Efficiency

5.3.4. Latency and Jitter (ms)

5.3.5. Stress Testing and Resilience
- Overload Scenario: FQ-DBA preserved >90% SLA compliance for high-priority flows even under 150% capacity. Competing schemes degraded sharply, with PF dropping to <70% compliance.
- Mixed-Criticality Workloads: The algorithm-maintained fairness (Jain’s index > 0.9) while dynamically reallocating resources to prevent starvation of bulk flows during flash crowd events.
- Resilience Metric: Recovery time following traffic spikes was under 200 ms, compared to >500 ms for PF and HTB.
6. Discussion
7. Conclusions
- Integration of Fairness and QoS: FQ-DBA ensures equitable bandwidth allocation while meeting stringent service-level objectives for latency-sensitive traffic.
- Resilience Under Stress: The algorithm demonstrates robustness against overload and mixed-criticality workloads, with recovery times under 200 ms.
- Reproducibility and Validation: A transparent framework was developed using real-world and synthetic datasets, statistical validation (confidence intervals and ANOVA), and open benchmarking tools to facilitate independent verification.
Author Contributions
Funding
Data Availability Statement
Conflicts of Interest
Appendix A
| Algorithm A1: Simulation of FQ-DBA Algorithm in ns-3 |
| include “ns3/core-module.h” include “ns3/network-module.h” include “ns3/internet-module.h” include “ns3/applications-module.h” include “ns3/point-to-point-module.h” include “ns3/traffic-control-module.h” include “ns3/flow-monitor-module.h” include <iostream> include <vector> include <map> using namespace ns3; //Traffic classes enum TrafficClass { REAL_TIME, INTERACTIVE, BACKGROUND }; //Function to classify traffic (placeholder for DPI/ML logic) TrafficClass ClassifyTraffic(Ptr<Packet> packet) { //Example: Classify based on packet size (replace with DPI/ML logic) if (packet->GetSize() <= 100) { return REAL_TIME;//Small packets are likely real-time traffic } else if (packet->GetSize() <= 1500) { return INTERACTIVE;//Medium packets are likely interactive traffic } else { return BACKGROUND;//Large packets are background traffic } } //Function to calculate fairness index (placeholder for fairness calculation) double CalculateFairnessIndex(const std::map<TrafficClass, uint32_t>& bandwidthAllocation) { //Example: Calculate fairness index (replace with actual fairness calculation) double sum = 0, sumSquares = 0; for (const auto& [trafficClass, bandwidth]: bandwidthAllocation) { sum += bandwidth; sumSquares += bandwidth bandwidth; } return (sum sum)/(bandwidthAllocation.size() sumSquares);//Jain’s fairness index } //Function to allocate bandwidth void AllocateBandwidth(TrafficClass trafficClass, uint32_t priority) { //Example: Allocate bandwidth based on priority (replace with actual logic) std::cout << “Allocating bandwidth for traffic class “ << trafficClass << “ with priority “ << priority << std::endl; } //Function to adjust bandwidth allocations (placeholder for dynamic adjustment logic) void AdjustBandwidthAllocations(const std::map<TrafficClass, uint32_t>& bandwidthAllocation) { //Example: Adjust bandwidth allocations (replace with actual logic) for (const auto& [trafficClass, bandwidth]: bandwidthAllocation) { if (bandwidth < 100) {//Example condition std::cout << “Increasing bandwidth for traffic class “ << trafficClass << std::endl; } else { std::cout << “Decreasing bandwidth for traffic class “ << trafficClass << std::endl; } } } //Main FQ-DBA function void FQDBA(Ptr<Node> node) { //Initialize queues and QoS parameters std::cout << “Initializing FQ-DBA for node “ << node->GetId() << std::endl; //Simulation loop while (true) { //Step 1: Real-Time Traffic Capture Ptr<Packet> packet = Create<Packet>(100);//Example packet TrafficClass trafficClass = ClassifyTraffic(packet); //Step 2: Calculate Fairness std::map<TrafficClass, uint32_t> bandwidthAllocation = { {REAL_TIME, 100},//Example bandwidth allocation {INTERACTIVE, 200}, {BACKGROUND, 50} }; double fairnessIndex = CalculateFairnessIndex(bandwidthAllocation); double fairnessThreshold = 0.8;//Example fairness threshold //Step 3: Allocate Bandwidth if (fairnessIndex < fairnessThreshold) { AdjustBandwidthAllocations(bandwidthAllocation); } else { for (const auto& [trafficClass, bandwidth]: bandwidthAllocation) { uint32_t priority = (trafficClass == REAL_TIME) ? 3: (trafficClass == INTERACTIVE) ? 2: 1; AllocateBandwidth(trafficClass, priority); } } //Step 4: Dynamic Adjustment if (bandwidthAllocation[REAL_TIME] > 150) {//Example condition std::cout << “Queue length exceeds threshold! Adjusting bandwidth allocations.” << std::endl; AdjustBandwidthAllocations(bandwidthAllocation); } //Wait for the next interval (simulate time progression) Simulator::Schedule(Seconds(1), &FQDBA, node); break;//Exit loop after one iteration (for demonstration) } } int main(int argc, char argv[]) { //NS-3 simulation setup CommandLine cmd(__FILE__); cmd.Parse(argc, argv); //Create nodes NodeContainer nodes; nodes.Create(2);//Example: 2-node topology //Install internet stack InternetStackHelper internet; internet.Install(nodes); //Create point-to-point link PointToPointHelper p2p; p2p.SetDeviceAttribute(“DataRate”, StringValue(“5 Mbps”)); p2p.SetChannelAttribute(“Delay”, StringValue(“2 ms”)); NetDeviceContainer devices = p2p.Install(nodes); //Assign IP addresses Ipv4AddressHelper ipv4; ipv4.SetBase(“10.1.1.0”, “255.255.255.0”); Ipv4InterfaceContainer interfaces = ipv4.Assign(devices); //Schedule FQ-DBA execution Simulator::Schedule(Seconds(1), &FQDBA, nodes.Get(0)); //Run simulation Simulator::Run(); Simulator::Destroy(); return 0; } |
References
- Jaffe, J.M. Bottleneck flow control. IEEE Trans. Commun. 1981, 29, 954–962. [Google Scholar] [CrossRef]
- Kelly, F.P.; Maulloo, A.K.; Tan, D.K.H. Rate control for communication networks: Shadow prices, proportional fairness and stability. J. Oper. Res. Soc. 1998, 49, 237–252. [Google Scholar] [CrossRef]
- Demers, A.; Keshav, S.; Shenker, S. Analysis and simulation of a fair queueing algorithm. ACM SIGCOMM Comput. Commun. Rev. 1989, 19, 1–12. [Google Scholar] [CrossRef]
- Kramer, G.; Mukherjee, B.; Pesavento, G. IPACT: A dynamic protocol for an Ethernet PON (EPON). IEEE Commun. Mag. 2002, 40, 74–80. [Google Scholar] [CrossRef]
- Blake, S.; Black, D.; Carlson, M.; Davies, E.; Wang, Z.; Weiss, W. An architecture for differentiated services. In Proceedings of the INET’98 Conference, Geneva, Switzerland, 21–24 July 1998. RFC 2475. [Google Scholar]
- Zhang, Y.; Roughan, M.; Willinger, W.; Qiu, L. Spatio-temporal compressive sensing and internet traffic matrices. In Proceedings of the SIGCOMM’09: Proceedings of the ACM SIGCOMM 2009 Conference on Data Communication, Barcelona, Spain, 16–21 August 2009; Volume 39, pp. 267–278. [Google Scholar]
- Xu, Z.; Tang, J.; Meng, J.; Zhang, W.; Wang, Y.; Liu, C.H.; Yang, D. Experience-driven networking: A deep reinforcement learning based approach. In Proceedings of the IEEE INFOCOM 2018—IEEE Conference on Computer Communications, Honolulu, HI, USA, 16–19 April 2018; pp. 1871–1879. [Google Scholar]
- Blenk, A.; Basta, A.; Reisslein, M.; Kellerer, W. Survey on network virtualization hypervisors for software defined networking. IEEE Commun. Surv. Tutor. 2016, 18, 655–685. [Google Scholar] [CrossRef]
- Teixeira, R.; Duffield, N.; Rexford, J.; Roughan, M. Traffic matrix reloaded: Impact of routing changes. In Proceedings of the 6th International Workshop on Passive and Active Network Measurement, Boston, MA, USA, 31 March–1 April 2005; pp. 251–264. [Google Scholar]
- Gupta, M.; Singh, S. Greening of the internet. In Proceedings of the SIGCOMM’03: Proceedings of the 2003 Conference on Applications, Technologies, Architectures, and Protocols for Computer Communications, Karlsruhe, Germany, 25–29 August 2003; Volume 33, pp. 19–26. [Google Scholar]
- Chiaraviglio, L.; Mellia, M.; Neri, F. Energy-aware backbone networks: A case study. In Proceedings of the 2009 IEEE International Conference on Communications Workshops, Dresden, Germany, 14–18 June 2009; Volume 50, pp. 100–107. [Google Scholar]

| Line 1. |
|
| Line 2. |
|
| Line 3. |
|
| Line 4. |
|
| Line 5. |
|
| Line 6. |
|
| Line 7. |
|
| Line 8. |
|
| Line 9. |
|
| Line 10. |
|
| Line 11. |
|
| Line 12. |
|
| Line 13. |
|
| Line 14. |
|
| Line 15. |
|
| Line 16. |
|
| Line 17. |
|
| Line 18. |
|
| Parameter | Value |
|---|---|
| Total Bandwidth | 10 Gbps |
| Number of Flows | 100–500 (mixed traffic) |
| Traffic Types | VoIP, Video, Bulk Data |
| QoS Requirements | Latency (<50 ms), Jitter (<10 ms), Min BW Guarantee |
| Congestion Scenario | Random bursts (50–90% load) |
| Algorithm | Jain’s Fairness Index (0–1) |
|---|---|
| Static | 0.65 |
| PF | 0.82 |
| HTB | 0.78 |
| FQ-DBA | 0.94 |
| Traffic Type | FQ-DBA | HTB | PF |
|---|---|---|---|
| VoIP | 98% | 85% | 76% |
| Video | 95% | 80% | 72% |
| Bulk Data | 90% | 75% | 68% |
| Algorithm | Average. Utilisation (%) |
|---|---|
| Static | 70% |
| PF | 85% |
| HTB | 88% |
| FQ-DBA | 93% |
| Algorithm | Avg. Latency/ms | Max Jitter/ms |
|---|---|---|
| Static | 45 | 15 |
| PF | 38 | 12 |
| HTB | 32 | 9 |
| FQ-DBA | 28 | 6 |
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2025 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).
Share and Cite
Chapanduka, G.; Nleya, B.; Chidzonga, R. Towards Fair and QoS-Aware Bandwidth Allocation in Next-Generation Multi-Gigabit WANs. Electronics 2025, 14, 4658. https://doi.org/10.3390/electronics14234658
Chapanduka G, Nleya B, Chidzonga R. Towards Fair and QoS-Aware Bandwidth Allocation in Next-Generation Multi-Gigabit WANs. Electronics. 2025; 14(23):4658. https://doi.org/10.3390/electronics14234658
Chicago/Turabian StyleChapanduka, Godwin, Bakhe Nleya, and Richard Chidzonga. 2025. "Towards Fair and QoS-Aware Bandwidth Allocation in Next-Generation Multi-Gigabit WANs" Electronics 14, no. 23: 4658. https://doi.org/10.3390/electronics14234658
APA StyleChapanduka, G., Nleya, B., & Chidzonga, R. (2025). Towards Fair and QoS-Aware Bandwidth Allocation in Next-Generation Multi-Gigabit WANs. Electronics, 14(23), 4658. https://doi.org/10.3390/electronics14234658

