A simple qos packet scheduler for network routers
Download
1 / 17

A Simple QoS Packet Scheduler for Network Routers - PowerPoint PPT Presentation


  • 120 Views
  • Uploaded on

A Simple QoS Packet Scheduler for Network Routers. Su Wen Presenting the paper in SIGCOM 2001 “SRR: An O(1) Time Complexity Packet Scheduler for Flows in Multi-Service Packet Networks”. Quality of Service. Current Internet Service Best effort Packet scheduling: FIFO QoS

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' A Simple QoS Packet Scheduler for Network Routers' - conan-ortiz


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
A simple qos packet scheduler for network routers

A Simple QoS Packet Scheduler for Network Routers

Su Wen

Presenting the paper in SIGCOM 2001

“SRR: An O(1) Time Complexity Packet Scheduler for Flows in Multi-Service Packet Networks”


Quality of service
Quality of Service

  • Current Internet Service

    • Best effort

    • Packet scheduling: FIFO

  • QoS

    • Demanded by new network services

      • multimedia, audio/video

    • Meets requirement in bandwidth, delay, jitter


Qos approaches
QoS Approaches

  • Integrated Services

    • Provide service guarantees to individual flows in the network

      • GPS - Generalized Processor Sharing

      • Weighted Fair Queuing

  • Differentiated Services

    • Provide some service guarantees to different classes of traffic in the network

      • Example: hierarchical link-sharing

        • audio, video, telnet, ftp, mail


Bandwidth sharing

server

r

.

.

.

GPS Scheduler

Bandwidth Sharing

  • GPS - generalized processor sharing

  • ideal model: each flow gets its fair share of BW

    • Si(t1, t2) / Sj(t1, t2) = wi/wj

    • ri/r = wi/jwj

flows

  • wi - weight of flow i

  • Si (t1, t2) - amount of traffic served for flow I during time t1 to t2

  • ri - service rate of flow i

  • r - service rate of the server


Bandwidth sharing implementations
Bandwidth Sharing Implementations

  • Weighted Fair Sharing

    • An approximation/implementation of GPS

    • Each flow has separate queues

    • Two approaches:

      • time-stamp based: e.g. virtual clock

      • round robin


Implementation characteristics
Implementation Characteristics

  • Time Stamp based:

    • Fairly good fairness and delay bound

    • Time complexity: O(logN) - O(N)

  • Round Robin based: DRR, CORR

    • Time complexity: O(1)

    • Short term unfairness

      • bursty output


Srr smoothed round robin
SRR - Smoothed Round Robin

  • Good short term and long term fairness

    • emulate GPS

    • work conserving

      • forwards packets as long as there are active flows

  • O(1) time complexity

    • one lookup to decide what to send

  • Better scalability

  • Simplicity


Data structures
Data Structures

  • Weight Matrix (WM)

    • number of rows = N - number of flows

    • number of columns = k = log2wmax + 1

      • # of binary digits needed to represent the max normalized weight

    • WM size depends on # of flows and BW granularity

  • WSS - Weight Spread Sequence

    • WSS of order k (Sk) is a sequence of integers from 1 to k

    • recursively defined

      • S1 = 1

      • Sk = Sk-1, k, Sk-1


Weight matrix
Weight Matrix

  • Four flow f1 - f4, each with different BW requirement:

    • r1 = 64kbps, r2 = 128kbps, r3 = 320kbps, r4 = 192kbps

    • w1 = 1 -> {0 0 1}

    • w2 = 2 -> {0 1 0}

    • w3 = 5 -> {1 0 1}

    • w4 = 3 -> {0 1 1}

  • col1 col2 col3

  • row1 0 0 1

  • row2 0 1 0

  • row3 1 0 1

  • row4 0 1 1


Weight spread sequence
Weight Spread Sequence

Rule:

S1 = 1

Sk = Sk-1, k, Sk-1

  • To find WSS of order 3 - S3

    • S2, 3, S2

    • S1, 2, S1, 3, S1, 2, S1

    • 1, 2, 1, 3, 1, 2, 1

N - number of flows

wi - normalized weight of flow i

k - log2wmax + 1


Scheduling algorithm

deficiti - bytes need to be served of flow i

Li - length of packet of flow i

Lmax - length of maximum packet size

Serve_flow(): deficitj += Lmax

while (Lj <= deficitj) {

send pktj

deficitj -= Lj

}

Scheduling Algorithm

  • Generate a Service Queue:

    • for each value i in the WSS

      • if jth row of column i of WM has value 1

        • add flow j to the queue

  • Serve the flow indicated in the service queue in a round robin fashion

  • f1: {0 0 1}

  • f2: {0 1 0}

  • f3: {1 0 1}

  • f4: {0 1 1}

S3:

1, 2, 1, 3, 1, 2, 1

Flow Service Queue:

f2, f4,

f3

f2, f4,

f3,

f1, f3, f4,

f3

f3,


Fairness
Fairness

  • Long Term

    • Si(0, t) / Sj(0, t) = wi/wj

    • Si(0, t)/wi - Sj(0, t)/wj = 0

  • Short Term

    • Si(0, t)/wi - Sj(0, t)/wj < (k+2)Lmax/2*min(wi,wj)

Si(t1, t2) - amount of traffic served for flow i during time t1 to t2

wi - normalized weight of flow i

k - log2wmax + 1, the order of WSS


Delay
Delay

  • Df - maximum delay for flow f

    • Df < 2*Lmax/wf + 2*(N-1)*Lmax/ iwi

  • Inverse proportional to the weight of the flow

  • Proportional to total number of flows

  • Not strictly rate proportional, but better than DRR

    • simulation result shows so


Scalability
Scalability

  • Space requirement

    • N x k

      • At 1kbps granularity, k=16 can accommodate rates up to 64Mbps

      • At 1Mbps granularity, k=16 can accommodate rates up to 64Gbps

  • Time complexity

    • O(1) to choose packets for transmission

    • O(k) to add or delete a flow


Srr problems
SRR Problems

  • add_flow() and delete_flow() operations

    • SRR scheduler is called during busy period

      • packets are back-logged

    • add_flow() is called when new flow arrives

    • delete_flow() is called when queue of the flow is empty

  • If a flow is not back logged, add_flow() and may be called for every packet

    • quite expensive: O(k)

  • Solution:

    • delay the deletion of a flow

    • not strictly O(1) any more


Conclusion
Conclusion

  • SRR is simple

    • even I can understand!

  • Scalable

    • time and space

  • Good performance

    • fairness

    • delay


Questions
Questions?

  • How did he come up with the algorithm?


ad