Optimised Uplink Scheduler for WiMAX

by

Sriraam A S Santhosh Kumar M L RaviSankar R

20072220 20072194 20072189

A project report submitted to the FACULTY OF INFORMATION AND COMMUNICATION ENGINEERING in partial fulllment of the requirements for the award of the degree of

BACHELOR OF ENGINEERING
in

COMPUTER SCIENCE AND ENGINEERING

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING ANNA UNIVERSITY CHENNAI CHENNAI - 600025 April 2011

CERTIFICATE
Certied that this project report titled Optimised Uplink Scheduler for WiMAX is the bonade work of Sriraam A S (20072220), RaviSankar R (20072189), SanthoshKumar ML(20072194) who carried out the project work under my supervision, for the fulllment of the requirements for the award of the degree of Bachelor of Engineering in Computer Science and Engineering. Certied further that to the best of my knowledge, the work reported herein does not form part of any other thesis or dissertation on the basis of which a degree or an award was conferred on an earlier occasion on these are any other candidates.

Place: Chennai Date:

V.Mary Anita Rajam, Selection Grade Lecturer, Department of Computer Science and Engineering, Anna University Chennai, Chennai - 600025

COUNTERSIGNED

Head of the Department, Department of Computer Science and Engineering, Anna University Chennai, Chennai 600025

ACKNOWLEDGEMENTS
We express our deep gratitude to our guide, V.Mary Anita Rajam for guiding us through every phase of the project. We appreciate her thoroughness, tolerance and ability to share her knowledge with us. We thank her for being easily approachable and quite thoughtful. Apart from adding her own input, she has encouraged us to think on our own and give form to our thoughts. We owe her for harnessing our potential and bringing out the best in us. Without her immense support through every step of the way, we could never have it to this extent. We are extremely grateful to Dr.K.S.EaswaraKumar, Head of the Department of Computer Science and Engineering, Anna University, Chennai 600025, for extending the facilities of the Department towards our project and for his unstinting support. We express our thanks to the panel of reviewers Dr.Arul Siromoney, Dr.A.P.Shanthi and

Dr.MadhanKarky for their valuable suggestions and critical reviews throughout the course of our project. We thank our parents, family, and friends for bearing with us throughout the course of our project and for the opportunity they provided us in undergoing this course in such a prestigious institution.

Sriraam

RaviSankar

Santhosh

ABSTRACT

WiMAX-Wireless Interoperability for Microwave Access is the last mile solution for economic broadband access for Metropolitan Area Networks(MAN). The IEEE 802.16 standard denes the specications for WiMAX networks. In the IEEE 802.16 standard, MAC layer scheduling is not dened specically. MAClayer scheduling plays a crucial part in the performance of a WiMAX network. In this thesis, an optimal uplink-scheduling algorithm that uses two parameters viz. modulation-type and serviceow-type to provide better performance for all classes of users in the network has been presented. In the proposed optimal scheduler, fairness for all classes of trafc is also provided. This is achieved by considering the trafc load and a fairness factor, alpha. The fairness factor can be modied to change the degree of fairness to be enforced. The combined approach of throughput, Quality of Service(QoS) and fairness provides an edge over the existing schedulers to provide better performance. In our optimal scheduler, the scheduling policy exploits higher datarate of certain modulation types to allocate increased number of bytes in a frame. Further, minimum bandwidth and maximum delay are the key parameters of QoS. Two modules, checkdeadline and checkminimumbandwidth in the proposed scheduler, ensures that minimum bandwidth and maximum delay is guaranteed. Also, all users in the network are provided fair chances at allocation process, keeping in mind the QoS characteristics as well. This scheduling policy has led to better performance of the network.

Contents
CERTIFICATE ACKNOWLEDGEMENTS ABSTRACT(ENGLISH) ABSTRACT(TAMIL) LIST OF FIGURES LIST OF TABLES LIST OF ABBREVIATIONS 1 INTRODUCTION 1.1 PROBLEM DOMAIN 1.2 SCOPE OF THE PROJECT 1.3 LITERATURE REVIEW 1.4 PROBLEM DEFINITION 1.5 CONTRIBUTIONS 1.6 ORGANIZATION OF THE REPORT REQUIREMENTS ANALYSIS 2.1 FUNCTIONAL REQUIREMENTS 2.2 NON-FUNCTIONAL REQUIREMENTS 2.2.1 User Interface 2.2.2 Performance Characteristics 2.2.3 Hardware Considerations 2.3 CONSTRAINTS AND ASSUMPTIONS 2.4 SYSTEM MODELS DESIGN 3.1 SYSTEM ARCHITECTURE 3.2 MODULE DESCRIPTIONS 3.2.1 Algorithm 1 3.2.2 Algorithm 2 SYSTEM DEVELOPMENT 4.1 IMPLEMENTATION DETAILS 4.2 SIMULATION ENVIRONMENT AND ITS PARAMETERS RESULTS AND DISCUSSIONS 5.1 RESULTS 5.2 ANALYSIS iv i ii iii iv vi vii viii 1 1 1 2 3 3 3 4 4 4 4 4 5 5 5 9 9 9 11 12 14 14 16 17 17 17

v 6 CONCLUSION 6.1 OVERALL CONCLUSION 6.2 FUTURE WORK AND EXTENSIONS 20 20 20

A SCREENSHOTS B TEST CASES

21 29

REFERENCES

37

List of Figures
2.1 2.2 2.3 2.4 3.1 5.1 5.2 5.3 5.4 A.1 A.2 A.3 A.4 A.5 A.6 A.7 Sequence Diagram Scenario Architecture Use Case Diagram Class Diagram Test case 1- Throughput Comparison Test case 1 - Waiting Time Comparison(Fairness) Test Case 2- Throughput Comparison Test Case 2- Waiting Time Comparison(Fairness) ScreenShot1 ScreenShot2 ScreenShot3 ScreenShot4 ScreenShot4 ScreenShot4 ScreenShot4 6 7 7 8 10 18 18 19 19 22 23 24 25 26 27 28

vi

List of Tables
2.1 Comparison of ModulationTypes vs SNR vs Data Rate 4

vii

LIST OF ABBREVIATIONS
SNR WiMAX QoS rtPS nrtPS UGS ertPS BE BS SS MAC CAC Signal-to-Noise Ratio Wireless interoperability for Microwave Access Quality of Service realtime Polling Service non realtime Polling Service Unsolicited Grants Service extended realtime Polling Service Best Effort Base Station Subscriber Station Medium Access Control Connection Admission Control

viii

C HAPTER 1

INTRODUCTION
1.1 PROBLEM DOMAIN

The problem of optimal allocation of bandwidth for each user in the network in WiMAX IEEE 802.16 is an interesting research problem. Different heuristics have been suggested to provide an optimal scheduling algorithm. When several users are part of a WiMAX network, it is the job of the Base Station(BS) to schedule the trafc ow in both uplink and downlink for each Subscriber Station(SS) connected to it and to maximize utilization. Several classes of users exist based on the type of the application they run. Some applications require a high data-rate with minimal delay while some applications can tolerate delay. It is the job of the uplink-scheduler to decide the Subscriber Station and the duration of utilization of the medium. In the design of an uplink-scheduler, the balance between providing high good-put and fairness to users is delicate and there arises the need for an efcient scheduling algorithm to optimize network usage.

1.2

SCOPE OF THE PROJECT

The purpose of the project is to analyze the existing schedulers for WiMAX and to provide an optimal scheduling algorithm. The existing scheduler is channel-unaware (that ignores the state of the network) and aims to provide strict priority scheduling. This could lead to starvation and poor performance for low priority trafc. Further, the network resource utilization is not optimal. In our project, a channel aware scheduling algorithm that could adapt based on Signal to Noise Ratio(SNR) has been developed along with fairness to several classes of users. It is implemented as a component of ns-3 simulator and can be used by students and researchers for analysis and improvement.

1.3

LITERATURE REVIEW

MAC-layer Schedulers are classied as different types. They may be primarily classied as Downlink and Uplink Schedulers. Flow of trafc from the Base Station(BS) to Subscriber Station(SS) is controlled by a Downlink-scheduler while ow from SS to BS is controlled by an Uplink Scheduler. They may also be classied as Channel-aware and channel unaware schedulers. Also, they are categorized as Inter-class and Intra-class schedulers. Channel aware schedulers consider the channel quality and state in scheduling decisions while channel unaware class is further categorized into homogeneous and hybrid schedulers. The homogeneous schedulers include Weighted Round Robin(WRR) or Decit Weighted Round Robin which cannot holdup QoS requirements strictly. Weighted Fair Queuing(WFQ) is also employed to assure QoS based on weights but calculation of weights is not optimal. Strict priority scheme is also employed. Here, the ve kinds of service ows, Unsolicited Grants Service(UGS), extended Real Time Polling Service(ertPS), real time Polling Service(rtPS), non-real time Polling Service(nrtPS) and Best Effort(BE) are serviced with priority UGS >> ertPS >> rtPS >> nrtPS >> BE . In this scheme, fairness and throughput could not be guaranteed. A hybrid scheduler uses a different approach for each class of trafc. The hybrid scheduler may employ Earliest Deadline First(EDF) for rtPS and employ Weighted Fair Queuing for nrtPS and BE services. Different combinations of scheduling policies have different benets and desirable performance characteristics. In [3] the authors propose a novel hybrid scheduler that employs Priority and Earliest Due Date(EDD) for different classes of service. Yet, this approach misses out the advantage of a channel aware scheduler. The authors in [4] propose a hierarchical scheduler which utilizes both channel state as well as weighted fairness to optimize bandwidth allocation. However, the algorithm considers aggregate bandwidth requests and SNR for weight allocation for each class. The algorithm in [2] uses too many queues to accomplish the task. Also, the criteria for assigning weights is inefcient. While all the earlier works present solutions to fairness or throughput or priority, no algorithm fuses all the requirements to obtain better performance. The algorithm presented in [1] introduces LatencyRate scheduling and token bucket algorithm but it proves to be quite complex.

1.4

PROBLEM DEFINITION

The Up-link scheduler is a component of Base-station(BS) in the MAC layer of IEEE 802.16 standard. The role of the up-link scheduler is to transmit information to Subscriber Stations(SS) regarding the time during which each SS has to transmit its data to BS.The information is in the form of Uplink MAP(ULMAP) . The physical frame is divided into equal-interval physical time-slots. The information about the time slots and its allocation to a user is embedded in a ULMAP which is later broad-casted to all SSs. The problem at hand is to manage the bandwidth available in such a way as to provide high good-put and fairness along with Quality of Service(QoS) for all the existing connections in the Network.

1.5

CONTRIBUTIONS

As seen in the Literary Review, the existing schedulers focus on one performance characteristic at a time, either throughput or fairness or Quality of Service. In our optimal scheduler, all the three performance characteristics have been provided. Hence the optimal scheduler can obtain higher throughput than earlier schedulers, can provide fairness to all users in the network and provide the guaranteed Quality of Service(QoS) to users. Further, the optimal scheduler can exploit the channel characteristic i.e. Signal to Noise Ratio (SNR) for scheduling decisions, which includes adaptability of the scheduler in a dynamic wireless environment.

1.6

ORGANIZATION OF THE REPORT

In this thesis report, chapter 2 deals with Requirements analysis and chapter 3 deals with system design. Chapter 4 explains the system development and implementation details. Chapter 5 contains test results and discussions. Chapter 6 deals with conclusion of the project and the future work and extensions.

C HAPTER 2

REQUIREMENTS ANALYSIS
2.1 FUNCTIONAL REQUIREMENTS
The NS-3 simulator works well in a linux

The Simulation is performed using NS-3 simulator.

environment.The scheduler works for a SISO(single input and single output) environment.

2.2
2.2.1

NON-FUNCTIONAL REQUIREMENTS
User Interface

The user interface for NS-3 simulator is Command-line. The proposed scheduling algorithm is implemented in NS-3 scheduler and used in a WIMAX network.

2.2.2

Performance Characteristics

The performance of the algorithm can be measured in terms of throughput- no. of bytes of bandwidth allocated for uplink. The performance of the algorithm can also be measured using the degree of fairness in allocation to multiple users. The following table presents the different modulation-types available and their corresponding SNR values and Datarate.

TABLE 2.1: Comparison of ModulationTypes vs SNR vs Data Rate

Modulation BPSK 1/2 QPSK 1/2 QPSK 3/4 16-QAM 1/2 16-QAM 3/4 64-QAM 2/3 64-QAM 3/4

SNR(dB) 3.0 6.0 8.5 11.5 15.0 19.0 21.0

Data Rate(Mbps) 2.13 3.39 5.08 6.67 10.17 13.5 15.2 4

2.2.3

Hardware Considerations

The NS-3 simulator is used to simulate the performance of the scheduling algorithm. The simulator does not have a strict hardware requirement since it is basically a C++ application. Intel Dual core and core 2 Duo processors with 2GB of primary memory and 2 GB of secondary storage is more than sufcient.

2.3

CONSTRAINTS AND ASSUMPTIONS

The NS-3 simulator does not dene eRTPS (extended Real Time Polling Services) type of service ow as of version 3.10. Also, the current version of NS-3 simulator does not support MIMO interfaces.

2.4

SYSTEM MODELS

In gure 2.1, a sequence diagram is shown where the role of scheduler with base station and subscriber station is shown. In gure 2.2, a scenario of the WiMAX network in Point-to-Multipoint(PMP) node is shown. Here , 5 subscriber stations are connected to one base station. In gure 2.3, architecture of Base station is shown. Here, the physical layer provides information to MAC layer and obtains Uplink

Maps(ULMAP) from the MAC layer. The uplink scheduler remains to be a part of MAC-layer. In gure 2.4, a use-case diagram that represents the various use-cases for uplink-scheduling process is shown.

F IGURE 2.1: Sequence Diagram

7
F IGURE 2.2: Scenario

F IGURE 2.3: Architecture

F IGURE 2.4: Use Case Diagram

C HAPTER 3

DESIGN
3.1 SYSTEM ARCHITECTURE

WiMAX works in two modes of operation, Point-to-Multipoint mode and Mesh Mode. In this thesis, we consider Point-to-Multipoint mode(PMP) where any communication between Subscriber Stations(SS) happens through a Base Station(BS). In this system, the rst phase is the connection establishment where an SS requests for a connection to a BS with certain trafc characteristics. If the Connection Admission Control (CAC) module of the BS accepts the connection, the connection is established. It is the role of CAC to prevent performance degradation for existing users or any users for that matter after connection establishment.There are predened classes of service ows with different characteristics. They are

Unsolicited Grants Service(UGS), Real Time Polling Service(rtPS), Non-Real-time Polling Service(nrtPS), extended Real Time Polling Service(ertPS) and Best Effort(BE). The SS can request bandwidth dynamically or be granted xed bandwidth as requested during connection establishment. It is the job of the uplink Scheduler to choose SS, one at a time and service its bandwidth requirements based on the service ow characteristics. uplink-scheduling. Figure 3.1 shows a class diagram, containing various classes used in

3.2

MODULE DESCRIPTIONS

In the following section, two algorithms have been presented. The algorithm 2, shown below is a progressive renement of algorithm 1. The descriptions for the two algorithms have also been provided. Algorithm 1: The job of an uplink-scheduler is to allocate bandwidth for each service ow in the Subscriber Station. A service ow has its own Quality of Service characteristics like maximum delay and minimum bandwidth. In step 1, the scheduler allocates initial values for variables such as availableSymbols, symbolstoallocation, etc. Then, the scheduler obtains a list of all the Subscriber Stations connected to the Base Station. This list is then iterated, servicing for each Subscriber Station(SS), one at a time. If an SS is just entering the network and no Quality of Service characteristic has been dened, then a slot is allocated for the SS to establish a service ow. If an SS wants to join the network, then a slot for that SS is also allocated. Following this, for

10
F IGURE 3.1: Class Diagram

each service ow, a unicast polling request is sent to the SS. In step 2, 4 lists, high list, inter list, low list, mod list[7] are initialised.The modulation types have been shown in table 2.1. In step 3, each service ow with a particular modulation type, say i, is put in mod list[i]. In step 4, each service ow in mod list, iterated starting from mod list[7], is enqueued in the three queues, high,inter and low list based on type of service ow, as can be seen in algorithm. In step 5, the number of slots available in this frame (freeSlots) is calculated. With that, the polling requests in high list are allocated slots rst. In step 6, with the available freeSlots, the DATA transfer requests are allocated in the ratio of 0.6:0.3:0.1 to high, inter and low list. In step 7, the deadline of a service ow in the queue is calculated and if found to expire after the current frame, the service ow is pushed onto the front of the queue.

11 In step 8, the minimum bandwidth requirement of a service ow is checked against the granted bandwidth. If found insufcient, the service ow is pushed onto the front of the queue.

3.2.1

Algorithm 1

1) Initialize scheduler.

2)Initialise high_list,inter_list, low_list, mod_list[7]

3)For service Flows with i modulation, insert serviceFlow in mod_list[i]

4) From mod_list insert a)UGS and polling requests in high_list

b)Insert rtPS serviceFlows to inter_list.

c)Insert nrtPS serviceFlows to inter_list.

d)Insert BE serviceFlows to low_list.

The job of an uplink-scheduler is to allocate bandwidth for each service flow in the Subscriber S In step 2, 4 lists, high\_list, inter\_list, low\_list, mod\_list[7] is initialised.

5) while(freeSlots > 0 and high_list != empty) provide bandwidth for unicast Polling requests in high_list.

6) If(freeSlots > 0) distribute remaining FreeSlots proportionally to high_list, inter_list, low_list based on ratio of 0.6:0.3:0.1

7) Check Deadline(inter_list)

8) Check minimumBandwidth(inter_list)

12

9)If deadline or min BW violation Elevate Priority by migration to high_list.

3.2.2

Algorithm 2

Description: The job of an uplink-scheduler is to allocate bandwidth for each service ow in the Subscriber Station. A service ow has its own Quality of Service characteristics like maximum delay and minimum bandwidth. In step 1, the scheduler allocates initial values for variables such as availableSymbols,

symbolstoallocation, etc. Then, the scheduler obtains a list of all the Subscriber Stations connected to the Base Station. This list is then iterated, servicing for each Subscriber Station(SS), one at a time. If an SS is just entering the network and no Quality of Service characteristic has been dened, then a slot is allocated for the SS to establish a service ow. If an SS wants to join the network, then a slot for that SS is also allocated. Following this, for each service ow, a unicast polling request is sent to the SS. In step 2, 4 lists, high list, inter list, low list are initialised. In step 3, each service ow is is enqueued in the three queues, high,inter and low list based on type of service ow, as can be seen in algorithm. In step 4, service ows in each queue are sorted based on the modulation type so that serviceow with modulation type-7 is at head of queue while modulation type-1 is towards the tail of the queue. In step 5, the available slots are distributed across each queue based on size of queue and fairness factor. In step 6, the queues are processed sequentially in the order high list, inter list and low list. In step 7, the deadline of a service ow in inter queue is calculated and if found to expire after the current frame, the service ow is pushed onto the front of the queue. In step 8, the minimum bandwidth requirement of a service ow in interqueue is checked against the granted bandwidth. If found insufcient, the service ow is pushed onto the front of the queue.

1) Initialize scheduler.

13 2)Initialise high_list,inter_list,low_list,

3) For each ServiceFlow,Enqueue a)UGS and polling requests in high_list

b)Insert rtPS serviceFlows to inter_list.

c)Insert nrtPS serviceFlows to inter_list.

d)Insert BE serviceFlows to low_list.

4) Sort each list based on Modulation type.

5) while(FreeSlots >0) and (high_list != empty) Provide bandwidth for Unicast polling requests in high_list

6) If(FreeSlots>0) Distribute Remaining FreeSlots proportionally to high_list,inter_list, low_list based on queue-size and

fairness factor

7) Check Deadline(inter_list)

8) Check minimumBandwidth(inter_list)

9)If deadline or min BW violation Elevate Priority by migration to front of list

C HAPTER 4

SYSTEM DEVELOPMENT
The NS-3 simulator is used to implement the proposed scheduling algorithm.

4.1

IMPLEMENTATION DETAILS

The NS-3 simulator has separate modules for WiMAX. The scheduler is implemented and integrated into /src/devices/wimax folder and then, NS-3 simulator is compiled. Several other les like wimaxphy, bsnetdevice, ns 3.9/build /debug/bindings/ python/ns3 module wimax.cc were modied to account for the new scheduler class. In the new scheduler class, bs-uplink-scheduler-new1, the schedule() function is overloaded to implement the proposed optimised scheduling algorithm. In the initialization phase, allocations for ranging and service ow creation are setup. Once they are completed, we allocate unicast polls for all existing service ows and service the UGS bandwidth requests. Then, based on specied scheduling policy, other service ows are serviced. In the implemented scheduler, GetSSRecords() method is used to access connection information about all Subscriber Stations connected to the Base Station. The modulation-type data of SSRecord is primarily used in the scheduling process.Each SSRecord may contain more than one ServiceFlow record within it. The schedule-type data of ServiceFlow of SSRecord will indicate the QoS characteristic of the established connection by an application. The SSRecords are later converted into Uplink-Job (ULJob) structure to be encapsulated in Uplink-Map(ULmap) structure and input into m UplinkAllocations queue. Several modules are involved in scheduling including Check Deadline and Check Bandwidth. Check Deadline: Deadline is a Quality of Service (QoS) characteristic that indicated maximum delay that is allowed between subsequent bandwidth allocations. Deadline expiry entails that the bandwidth request has to be processed immediately. The checking usually happens for RTPS trafc alone job > GetDeadline() is a function that returns the deadline for the job. deadline now/ f rame duration > 3 is used to decide upon deadline expiry. The jobs whose deadline expire, are promoted to the front of the queue where they have higher chance of being served at the earliest. 14 The condition

15 Check Minimum Bandwidth:

Minimum bandwidth is the amount of bandwidth i.e number of bytes per unit time that is guaranteed for a subscriber station and is usually dened during service ow allocation. In this particular module, for each service ow, it is checked if the minimum that is promised has been granted or not. serviceFlow > GetRecord () > GetBacklogged () serviceFlow > GetRecord () > GetBwSinceLastExpiry() serviceFlow > GetMinReservedTra f f icRate() The above mentioned functions are used accordingly to check for minimum bandwidth. The jobs which did not get sufcient bandwidth get promoted to front of the queue where chances of being served in the next frame is high. The service ows are sorted in the 3 lists, high, inter and low list based on the Modulation type, such that higher data-rate services are at the head of the queue and lower towards the tail of the queue. The sorting is performed using a simple compare function.

bool compare(Ptr<UlJob> job_1,Ptr<UlJob> job_2) { int mod1=job_1->GetSsRecord ()->GetModulationType(); int mod2=job_2->GetSsRecord ()->GetModulationType(); if(mod1>mod2) return true; else return false; }

The available bandwidth indicated by freeslots is distributed among the 3 queues based on the formula : weight of high list=(alpha*0.5)+((1-alpha)*(size of high list/total size)) weigh of inter list=(alpha*(0.3333))+((1-alpha)*((size of inter list/total size)) weight of low list=(alpha*(0.1667))+((1-alpha)*(size of low list/total size)

16 In the above formula, the alpha value indicates the fairness factor. It can be changed to modify the degree of fairness enforced in the scheduling policy. The weight calculated above is then combined with freeSlots to obtain the upper threshold of number of slots for each queue. Each queue is then processed sequentially to allocate slots for serviceows. The allocation is performed by creating Uplink Map (ULMAP) structures that specify which SS gets to transmit and for what duration. This ULMAP is added to the m uplinkallocations queue. The other components of MAC layer and PHY layer will take care of sending the ULMAPS to all the Subscriber Stations from this queue.

4.2

SIMULATION ENVIRONMENT AND ITS PARAMETERS

Simulations of the wimax network in PMP mode were performed with the implemented scheduling algorithm. In our simulations, 8 subscriber stations(SS) connected to 1 Base station(BS) running UDP applications was performed to analyse the effectiveness of the scheduling algorithm. Two different

scenarios were simulated to check the performance of the algorithms.Each test simulates network with different ServiceFlows existing in it. Also, the fairness degree,alpha was also varied to know the variation in the performance. The throughput has been analysed for the implementation of algorihtm 1 and algorithm 2. Due to the nature of the trafc ows and better scheduling policy, algorithm 2 results in better throughput than others as shown in Figure 5.1. Also waiting time of jobs has been analysed and visualised as shown in Figure 5.2. Scenario 1: Service Flows, RTPS-4 BE-4 Scenario 2: Service Flows, NRTPS-2 BE-6

C HAPTER 5

RESULTS AND DISCUSSIONS

5.1 RESULTS

The graphs depicting the performance comparison for the scheduling algorithms indicate that the optimised algorithm performs with improved throughput than the other algorithm. It is also noted that the improvement in performance is partly accounted to improvement of fairness as shown in graph. In our rst scenario, four real-time Polling Services(rtPS) service ows and four Best Effort(BE) service ows were simulated. In Figure 5.1,x-axis represents the time in seconds while y-axis represents number of bytes allocated in bytes. In the gure 5.1, the two graphs indicate the performance of the 2 algorithms. The green-coloured graph represents the throughput at intervals of time by algorithm 2 while red-coloured graph represents that of algorithm 1. As can be seen from the graph, the algorithm 2 shows higher throughput than algorithm 1. In Figure 5.2, the bar graph represents the waiting time of each queue used in the algorithm. In the x-axis, the 3 queues- hq,iq and lq(high, inter and low) are presented. The y-axis represents the waiting time of different service ows in each of the queues. The red graph represents waiting time of algorithm 1 while green represents that of algorithm 2. It can be seen that the low list (indicated by lp in graph) has reduced waiting time for algorithm 2 than algorithm 1. This indicates the amount of fairness provided by the algorithm. In our second scenario, two non real-time Polling Services(nrtPS) service ows and six Best Effort(BE) service Flows were simulated. In Figure 5.3 the graph shows that the optimised algorithm, algorithm 2, results in higher throughput than the algorithm 1.However the dips and increments in the graph are due to the higher concentration of Best effort trafc in the network which has low bandwidth demands. In Figure 5.4, the waiting time of service ows in low list in algorithm 2 is found to be lesser than algorithm 1. This signies the provision of fairness for all classes of users in the network.

5.2

ANALYSIS

The improved throughput in the optimised algorithm has several factors attributing to it. The channel-aware characteristic of the algorithm that considers the SNR of the network at present is one factor. Adding to 17

18
F IGURE 5.1: Test case 1- Throughput Comparison

F IGURE 5.2: Test case 1 - Waiting Time Comparison(Fairness)

that, the fact that all service ows are serviced with fairness as sufcient, throughput improves accordingly. Though it is arguable that the performance of the algorithm may be affected in a network where high priority service ows are predominant,the odds are quite minimal as the fairness also considers the current trafc characteristics to decide upon measure of fairness.The optimised algorithm is seen to perform quite well in all the test cases.

19

F IGURE 5.3: Test Case 2- Throughput Comparison

F IGURE 5.4: Test Case 2- Waiting Time Comparison(Fairness)

C HAPTER 6

CONCLUSION
6.1 OVERALL CONCLUSION

The MAC-layer uplink-scheduling algorithm has signicant impact on the performance of the network. In our project, we developed an optimised uplink-scheduling algorithm for MAC layer to provide both high throughput and fairness to users. The performance improvement is signicant and throughput increases by almost twice that of an existing scheduler. The waiting time of the requests also seems to have reduced in the optimised scheduler. The integration of channel aware characteristic i.e Signal to Noise Ratio(SNR) along with QoS has contributed to the improvement of the schedulers performance.

6.2

FUTURE WORK AND EXTENSIONS

The future work could include further optimizations to exploit other characteristics of the WiMAX network. On availability of ertPS service Flow as part of ns-3 simulator, further simulations can be performed to analyse performance. Also, fairness based on users in a much larger scale and further improvement in performance is possible.

20

A PPENDIX A

SCREENSHOTS

21

22
F IGURE A.1: ScreenShot1

23
F IGURE A.2: ScreenShot2

24
F IGURE A.3: ScreenShot3

25
F IGURE A.4: ScreenShot4

26
F IGURE A.5: ScreenShot4

27
F IGURE A.6: ScreenShot4

28

F IGURE A.7: ScreenShot4

A PPENDIX B

TEST CASES
//nrtps-2 be-6 #include "ns3/core-module.h" #include "ns3/common-module.h" #include "ns3/node-module.h" #include "ns3/helper-module.h" #include "ns3/mobility-module.h" #include "ns3/contrib-module.h" #include "ns3/wimax-module.h" #include <iostream> #include "ns3/global-route-manager.h" #include<unistd.h> #include<fcntl.h> NS_LOG_COMPONENT_DEFINE ("wimaxIpV4Simulation"); using namespace ns3; int main (int argc, char *argv[]) { // default values int nbSS = 8 , duration =4, schedType = 1; bool verbose = false;

WimaxHelper::SchedulerType scheduler = WimaxHelper::SCHED_TYPE_SIMPLE; LogComponentEnable ("UdpClient", LOG_LEVEL_INFO); LogComponentEnable ("UdpServer", LOG_LEVEL_INFO); LogComponentEnable ("UplinkSchedulerSimple", LOG_LEVEL_INFO);

CommandLine cmd; cmd.AddValue ("nbSS", "number of subscriber station to create", nbSS); cmd.AddValue ("scheduler", "type of scheduler to use with the network devices", schedType); 29

30 cmd.AddValue ("duration", "duration of the simulation in seconds", duration); cmd.AddValue ("verbose", "turn on all WimaxNetDevice log components", verbose); //cmd.AddValue ("alpha", "alpha component", alpha); cmd.Parse (argc, argv); //int f=open("/home/santhosh/alpha",2); //write(f,argv[1],strlen(argv[1])); /*switch (schedType) { case 0: scheduler = WimaxHelper::SCHED_TYPE_SIMPLE; break; case 1: scheduler = WimaxHelper::SCHED_TYPE_MBQOS; break; case 2: scheduler = WimaxHelper::SCHED_TYPE_RTPS; break; default: scheduler = WimaxHelper::SCHED_TYPE_SIMPLE; } */ NodeContainer ssNodes; NodeContainer bsNodes; ssNodes.Create (nbSS); bsNodes.Create (1); WimaxHelper wimax; NetDeviceContainer ssDevs, bsDevs; ssDevs = wimax.Install (ssNodes, WimaxHelper::DEVICE_TYPE_SUBSCRIBER_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler); bsDevs = wimax.Install (bsNodes, WimaxHelper::DEVICE_TYPE_BASE_STATION, WimaxHelper::SIMPLE_PHY_TYPE_OFDM, scheduler);

31

Ptr<SubscriberStationNetDevice> ss[nbSS]; for (int i = 0; i < nbSS; i++) { ss[i] = ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> (); ss[i]->SetModulationType (WimaxPhy::MODULATION_TYPE_QAM16_12); } Ptr<BaseStationNetDevice> bs; bs = bsDevs.Get (0)->GetObject<BaseStationNetDevice> (); MobilityHelper mobility; mobility.Install (bsNodes); mobility.Install (ssNodes); InternetStackHelper stack; stack.Install (bsNodes); stack.Install (ssNodes); Ipv4AddressHelper address; address.SetBase ("10.1.1.0", "255.255.255.0"); for (int i = 0; i < nbSS; i++) { ss[i] = ssDevs.Get (i)->GetObject<SubscriberStationNetDevice> (); ss[i]->SetModulationType ((WimaxPhy::ModulationType)(i%7)); } Ipv4InterfaceContainer SSinterfaces = address.Assign (ssDevs); Ipv4InterfaceContainer BSinterface = address.Assign (bsDevs); if (verbose) { wimax.EnableLogComponents (); } /*------------------------------*/ UdpServerHelper udpServer[nbSS / 2]; ApplicationContainer serverApps[nbSS / 2]; // Turn on all wimax logging

32 UdpClientHelper udpClient[nbSS / 2]; ApplicationContainer clientApps[nbSS / 2]; for (int i = 0; i < nbSS / 2; i++) { // set server port to 100+(i*10) udpServer[i] = UdpServerHelper (100 + (i * 10)); serverApps[i] = udpServer[i].Install (ssNodes.Get (i)); serverApps[i].Start (Seconds (1)); serverApps[i].Stop (Seconds (duration)); udpClient[i] = UdpClientHelper (SSinterfaces.GetAddress (i), 100 + (i * 10)); udpClient[i].SetAttribute ("MaxPackets", UintegerValue (1200)); udpClient[i].SetAttribute ("Interval", TimeValue (Seconds (0.1))); udpClient[i].SetAttribute ("PacketSize", UintegerValue (800)); clientApps[i] = udpClient[i].Install (ssNodes.Get (i + (nbSS / 2))); clientApps[i].Start (Seconds (1)); clientApps[i].Stop (Seconds (duration));

} Simulator::Stop (Seconds (duration + 0.1)); /* * Setup 1 transport connections between each SS and the BS */ int i; for (i = 0; i < nbSS/8; i++) { IpcsClassifierRecord DlClassifiernrtps (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), SSinterfaces.GetAddress (i), Ipv4Mask ("255.255.255.255"), 0, 65000,

33 100 + (i * 10), 100 + (i * 10), 17, 1); ServiceFlow DlServiceFlownrtps = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN, ServiceFlow::SF_TYPE_NRTPS, DlClassifiernrtps); ss[i]->AddServiceFlow (DlServiceFlownrtps); IpcsClassifierRecord ulClassifiernrtps (SSinterfaces.GetAddress (i + (nbSS / 2)), Ipv4Mask ("255.255.255.255"), Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), 0, 65000, 100 + (i * 10), 100 + (i * 10), 17, 1); ServiceFlow ulServiceFlownrtps = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP, ServiceFlow::SF_TYPE_NRTPS, ulClassifiernrtps); ss[i + (nbSS / 2)]->AddServiceFlow (ulServiceFlownrtps);

/*----------------------------------------------------------------------------------------------int j=i+(nbSS/8); IpcsClassifierRecord DlClassifierrtps (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), SSinterfaces.GetAddress (i), Ipv4Mask ("255.255.255.255"), 0, 65000, 100 + (j * 10), 100 + (j * 10), 17,

34 1); ServiceFlow DlServiceFlowrtps = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN, ServiceFlow::SF_TYPE_BE, DlClassifierrtps); ss[j]->AddServiceFlow (DlServiceFlowrtps); IpcsClassifierRecord ulClassifierrtps (SSinterfaces.GetAddress (j + (nbSS / 2)), Ipv4Mask ("255.255.255.255"), Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), 0, 65000, 100 + (j * 10), 100 + (j * 10), 17, 1); ServiceFlow ulServiceFlowrtps = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP, ServiceFlow::SF_TYPE_BE, ulClassifierrtps); ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowrtps);

j=i+(nbSS/4); IpcsClassifierRecord DlClassifierbe (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), SSinterfaces.GetAddress (i), Ipv4Mask ("255.255.255.255"), 0, 65000, 100 + (j * 10), 100 + (j * 10), 17, 1); ServiceFlow DlServiceFlowbe = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN, ServiceFlow::SF_TYPE_BE, DlClassifierbe); ss[j]->AddServiceFlow (DlServiceFlowbe);

35 IpcsClassifierRecord ulClassifierbe (SSinterfaces.GetAddress (j + (nbSS / 2)), Ipv4Mask ("255.255.255.255"), Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), 0, 65000, 100 + (j * 10), 100 + (j * 10), 17, 1); ServiceFlow ulServiceFlowbe = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP, ServiceFlow::SF_TYPE_BE, ulClassifierbe); ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowbe);

j++; IpcsClassifierRecord DlClassifierbe1 (Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), SSinterfaces.GetAddress (i), Ipv4Mask ("255.255.255.255"), 0, 65000, 100 + (j * 10), 100 + (j * 10), 17, 1); ServiceFlow DlServiceFlowbe1 = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN, ServiceFlow::SF_TYPE_BE, DlClassifierbe1); ss[j]->AddServiceFlow (DlServiceFlowbe1); IpcsClassifierRecord ulClassifierbe1 (SSinterfaces.GetAddress (j + (nbSS / 2)), Ipv4Mask ("255.255.255.255"), Ipv4Address ("0.0.0.0"), Ipv4Mask ("0.0.0.0"), 0, 65000,

36 100 + (j * 10), 100 + (j * 10), 17, 1); ServiceFlow ulServiceFlowbe1 = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP, ServiceFlow::SF_TYPE_BE, ulClassifierbe1); ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowbe1);

} NS_LOG_INFO ("Starting simulation....."); Simulator::Run (); for (int i = 0; i < nbSS; i++) { ss[i] = 0; } bs = 0; Simulator::Destroy (); NS_LOG_INFO ("Done."); return 0; }

REFERENCES
[1] D. Eden Ricardo, J. Walter Godoy, and F. Augusto, A New Scheduler for IEEE 802.16 with Delay Bound Guarantee, in Networking and Services (ICNS), 2010 Sixth International Conference, 2010. [2] L. Elmabruk, A. Irfan, and C. Pauline, An Integrated Uplink Scheduler In IEEE 802.16, in Computer Modeling and Simulation, 2008. EMS 08. Second UKSIM European Symposium , 2010. [3] R. Perumalraja, L. Chung-Horng, and S. Anand, QoS Assured Uplink Scheduler for WiMAX Networks, in Canada Proceedings in Vehicular Technology Conference, 2010. [4] Z. Yurdakul and S. Oktug, A Hierarchical Channel-Aware Uplink Scheduler for WiMAX Base Stations, in Telecommunications (AICT), 2010 Sixth Advanced International Conference, 2010.

37