Optimised Uplink Scheduler for WiMAX

Optimised Uplink Scheduler for WiMAXby

Sriraam A S 20072220Santhosh Kumar M L 20072194

RaviSankar R 20072189

A project report submitted to the

FACULTY OF INFORMATION AND

COMMUNICATION ENGINEERING

in partial fulfillment 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

Certified that this project report titled “Optimised Uplink Scheduler for WiMAX” is the bonafide work of

Sriraam A S (20072220), RaviSankar R (20072189), SanthoshKumar ML(20072194) who carried out

the project work under my supervision, for the fulfillment of the requirements for the award of the degree of

Bachelor of Engineering in Computer Science and Engineering. Certified 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 V.Mary Anita Rajam,Date: 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 andDr.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 defines the specifications for

WiMAX networks. In the IEEE 802.16 standard, MAC layer scheduling is not defined specifically. MAC-

layer 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 serviceflow-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 traffic is also provided. This is achieved by considering the traffic load

and a fairness factor, alpha. The fairness factor can be modified 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 i

ACKNOWLEDGEMENTS ii

ABSTRACT(ENGLISH) iii

ABSTRACT(TAMIL) iv

LIST OF FIGURES vi

LIST OF TABLES vii

LIST OF ABBREVIATIONS viii

1 INTRODUCTION 11.1 PROBLEM DOMAIN 11.2 SCOPE OF THE PROJECT 11.3 LITERATURE REVIEW 21.4 PROBLEM DEFINITION 31.5 CONTRIBUTIONS 31.6 ORGANIZATION OF THE REPORT 3

2 REQUIREMENTS ANALYSIS 42.1 FUNCTIONAL REQUIREMENTS 42.2 NON-FUNCTIONAL REQUIREMENTS 4

2.2.1 User Interface 42.2.2 Performance Characteristics 42.2.3 Hardware Considerations 5

2.3 CONSTRAINTS AND ASSUMPTIONS 52.4 SYSTEM MODELS 5

3 DESIGN 93.1 SYSTEM ARCHITECTURE 93.2 MODULE DESCRIPTIONS 9

3.2.1 Algorithm 1 113.2.2 Algorithm 2 12

4 SYSTEM DEVELOPMENT 144.1 IMPLEMENTATION DETAILS 144.2 SIMULATION ENVIRONMENT AND ITS PARAMETERS 16

5 RESULTS AND DISCUSSIONS 175.1 RESULTS 175.2 ANALYSIS 17

iv

v

6 CONCLUSION 206.1 OVERALL CONCLUSION 206.2 FUTURE WORK AND EXTENSIONS 20

A SCREENSHOTS 21

B TEST CASES 29

REFERENCES 37

List of Figures

2.1 Sequence Diagram 62.2 Scenario 72.3 Architecture 72.4 Use Case Diagram 8

3.1 Class Diagram 10

5.1 Test case 1- Throughput Comparison 185.2 Test case 1 - Waiting Time Comparison(Fairness) 185.3 Test Case 2- Throughput Comparison 195.4 Test Case 2- Waiting Time Comparison(Fairness) 19

A.1 ScreenShot1 22A.2 ScreenShot2 23A.3 ScreenShot3 24A.4 ScreenShot4 25A.5 ScreenShot4 26A.6 ScreenShot4 27A.7 ScreenShot4 28

vi

List of Tables

2.1 Comparison of ModulationTypes vs SNR vs Data Rate 4

vii

LIST OF ABBREVIATIONS

SNR Signal-to-Noise Ratio

WiMAX Wireless interoperability for Microwave Access

QoS Quality of Service

rtPS realtime Polling Service

nrtPS non realtime Polling Service

UGS Unsolicited Grants Service

ertPS extended realtime Polling Service

BE Best Effort

BS Base Station

SS Subscriber Station

MAC Medium Access Control

CAC Connection Admission Control

viii

CHAPTER 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 traffic flow 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 efficient 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

traffic. 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

2

1.3 LITERATURE REVIEW

MAC-layer Schedulers are classified as different types. They may be primarily classified as Downlink and

Uplink Schedulers. Flow of traffic from the Base Station(BS) to Subscriber Station(SS) is controlled by a

Downlink-scheduler while flow from SS to BS is controlled by an Uplink Scheduler.

They may also be classified 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 Deficit 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 five kinds of service flows, 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 traffic. 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 benefits 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 inefficient. 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 Latency-

Rate scheduling and token bucket algorithm but it proves to be quite complex.

3

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.

CHAPTER 2

REQUIREMENTS ANALYSIS

2.1 FUNCTIONAL REQUIREMENTS

The Simulation is performed using NS-3 simulator. The NS-3 simulator works well in a linux

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

2.2 NON-FUNCTIONAL REQUIREMENTS

2.2.1 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 SNR(dB) Data Rate(Mbps)BPSK 1/2 3.0 2.13QPSK 1/2 6.0 3.39QPSK 3/4 8.5 5.0816-QAM 1/2 11.5 6.6716-QAM 3/4 15.0 10.1764-QAM 2/3 19.0 13.564-QAM 3/4 21.0 15.2

4

5

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 sufficient.

2.3 CONSTRAINTS AND ASSUMPTIONS

The NS-3 simulator does not define eRTPS (extended Real Time Polling Services) type of service flow as

of version 3.10. Also, the current version of NS-3 simulator does not support MIMO interfaces.

2.4 SYSTEM MODELS

In figure 2.1, a sequence diagram is shown where the role of scheduler with base station and subscriber

station is shown. In figure 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 figure 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 figure

2.4, a use-case diagram that represents the various use-cases for uplink-scheduling process is shown.

6

FIGURE 2.1: Sequence Diagram

7

FIGURE 2.2: Scenario

FIGURE 2.3: Architecture

8

FIGURE 2.4: Use Case Diagram

CHAPTER 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 first phase is the connection establishment where

an SS requests for a connection to a BS with certain traffic 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 predefined classes of service flows 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 fixed 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 flow characteristics. Figure 3.1 shows a class diagram, containing various classes used in

uplink-scheduling.

3.2 MODULE DESCRIPTIONS

In the following section, two algorithms have been presented. The algorithm 2, shown below is a progressive

refinement 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 flow in the Subscriber Station. A

service flow 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 defined, then a slot is allocated for the SS to establish a

service flow. If an SS wants to join the network, then a slot for that SS is also allocated. Following this, for

9

10

FIGURE 3.1: Class Diagram

each service flow, 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 flow with a particular modulation type, say i, is put in mod list[i].

In step 4, each service flow 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 flow, 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 first.

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 flow in the queue is calculated and if found to expire after the current

frame, the service flow is pushed onto the front of the queue.

11

In step 8, the minimum bandwidth requirement of a service flow is checked against the granted bandwidth.

If found insufficient, the service flow 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 Station. A service flow 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 defined, then a slot is allocated for the SS to establish a service flow. If an SS wants to join the network, then a slot for that SS is also allocated. Following this, for each service flow, a unicast polling request is sent to the SS.

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 flow in the Subscriber

Station. A service flow 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 defined, then a slot is allocated

for the SS to establish a service flow. If an SS wants to join the network, then a slot for that SS is also

allocated. Following this, for each service flow, 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 flow is is enqueued in the three queues, high,inter and low list based on type of service

flow, as can be seen in algorithm.

In step 4, service flows in each queue are sorted based on the modulation type so that serviceflow 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 flow in inter queue is calculated and if found to expire after the current

frame, the service flow is pushed onto the front of the queue.

In step 8, the minimum bandwidth requirement of a service flow in interqueue is checked against the granted

bandwidth. If found insufficient, the service flow 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

CHAPTER 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 files like wimaxphy,

bsnetdevice, ns− 3.9/build/debug/bindings/python/ns3 module wimax.cc were modified 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 flow creation are setup. Once they are

completed, we allocate unicast polls for all existing service flows and service the UGS bandwidth requests.

Then, based on specified scheduling policy, other service flows 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 traffic alone

job− > GetDeadline() is a function that returns the deadline for the job. The condition

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

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 defined during service flow allocation. In this particular module, for each

service flow, 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 sufficient bandwidth get promoted to front of the queue where chances of being served in the next

frame is high.

The service flows 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 serviceflows.

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 traffic flows 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

CHAPTER 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 first scenario, four real-time Polling Services(rtPS) service flows and four Best Effort(BE) service

flows 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 figure 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 flows 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 flows 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 traffic in the network which has low bandwidth demands. In Figure

5.4, the waiting time of service flows in low list in algorithm 2 is found to be lesser than algorithm 1. This

signifies 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

FIGURE 5.1: Test case 1- Throughput Comparison

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

that, the fact that all service flows are serviced with fairness as sufficient, throughput improves accordingly.

Though it is arguable that the performance of the algorithm may be affected in a network where high priority

service flows are predominant,the odds are quite minimal as the fairness also considers the current traffic

characteristics to decide upon measure of fairness.The optimised algorithm is seen to perform quite well in

all the test cases.

19

FIGURE 5.3: Test Case 2- Throughput Comparison

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

CHAPTER 6

CONCLUSION

6.1 OVERALL CONCLUSION

The MAC-layer uplink-scheduling algorithm has significant 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 significant 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 scheduler’s 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

APPENDIX A

SCREENSHOTS

21

22

FIGURE A.1: ScreenShot1

23


24


25


26


27


28


APPENDIX 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");


{

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 (); // Turn on all wimax logging

}

/*------------------------------*/

UdpServerHelper udpServer[nbSS / 2];

ApplicationContainer serverApps[nbSS / 2];

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"),


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"),


Ipv4Mask ("0.0.0.0"),

0,

65000,

100 + (j * 10),

100 + (j * 10),

17,

1);

ServiceFlow ulServiceFlowrtps = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP,


ulClassifierrtps);

ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowrtps);

j=i+(nbSS/4);

IpcsClassifierRecord DlClassifierbe (Ipv4Address ("0.0.0.0"),

Ipv4Mask ("0.0.0.0"),


Ipv4Mask ("255.255.255.255"),

0,

65000,

100 + (j * 10),

100 + (j * 10),

17,

1);

ServiceFlow DlServiceFlowbe = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN,


DlClassifierbe);

ss[j]->AddServiceFlow (DlServiceFlowbe);

35

IpcsClassifierRecord ulClassifierbe (SSinterfaces.GetAddress (j + (nbSS / 2)),

Ipv4Mask ("255.255.255.255"),


Ipv4Mask ("0.0.0.0"),

0,

65000,

100 + (j * 10),

100 + (j * 10),

17,

1);

ServiceFlow ulServiceFlowbe = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP,


ulClassifierbe);

ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowbe);

j++;

IpcsClassifierRecord DlClassifierbe1 (Ipv4Address ("0.0.0.0"),

Ipv4Mask ("0.0.0.0"),


Ipv4Mask ("255.255.255.255"),

0,

65000,

100 + (j * 10),

100 + (j * 10),

17,

1);

ServiceFlow DlServiceFlowbe1 = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_DOWN,


DlClassifierbe1);

ss[j]->AddServiceFlow (DlServiceFlowbe1);

IpcsClassifierRecord ulClassifierbe1 (SSinterfaces.GetAddress (j + (nbSS / 2)),

Ipv4Mask ("255.255.255.255"),


Ipv4Mask ("0.0.0.0"),

0,

65000,

36

100 + (j * 10),

100 + (j * 10),

17,

1);

ServiceFlow ulServiceFlowbe1 = wimax.CreateServiceFlow (ServiceFlow::SF_DIRECTION_UP,


ulClassifierbe1);

ss[j + (nbSS / 2)]->AddServiceFlow (ulServiceFlowbe1);

}

NS_LOG_INFO ("Starting simulation.....");

Simulator::Run ();


{

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

Optimised Uplink Scheduler for WiMAX

Documents

Transcript of Optimised Uplink Scheduler for WiMAX