Principles

WRR is presented in the following as a network scheduler. It can also be used to schedule tasks in a similar way.

A weighted round-robin network scheduler has ${\displaystyle n}$ input queues, ${\displaystyle q_{1},...,q_{n}}$. To each queue ${\displaystyle q_{i}}$ is associated ${\displaystyle w_{i}}$, a positive integer, called the weight. The WRR scheduler has a cyclic behavior. In each cycle, each queue ${\displaystyle q_{i}}$ has ${\displaystyle w_{i}}$ emissions opportunities.

The different WRR algorithms differ on the distributions of these opportunities in the cycle.

Classical WRR

In classical WRR^[2][3][4] the scheduler cycles over the queues. When a queue ${\displaystyle q_{i}}$ is selected, the scheduler will send packets, up to the emission of ${\displaystyle w_{i}}$ packet or the end of queue.

Constant and variables: 
    const N             // Nb of queues 
    const weight[1..N]  // weight of each queue
    queues[1..N]        // queues
    i                   // queue index
    c                   // packet counter
    
Instructions:
while true do 
    for i in 1 .. N do
        c := 0
        while (not queue[i].empty) and (c<weight[i]) do
            send(queue[i].head())
            queue[i].dequeue()
            c:= c+1

Interleaved WRR

Let ${\displaystyle w_{max}=\max\{w_{i}\}}$, be the maximum weight. In IWRR,^[1][5] each cycle is split into ${\displaystyle w_{max}}$ rounds. A queue with weight ${\displaystyle w_{i}}$ can emit one packet at round ${\displaystyle r}$ only if ${\displaystyle r\leq w_{i}}$.

Constant and variables: 
    const N             // Nb of queues 
    const weight[1..N]  // weight of each queue
    const w_max
    queues[1..N]        // queues
    i                   // queue index
    r                   // round counter
    
Instructions:

while true do
    for r in 1 .. w_max do 
        for i in 1 .. N do
            if (not queue[i].empty) and (weight[i] >= r) then
                send(queue[i].head())
                queue[i].dequeue()

Example

Example of scheduling for CWRR and IWRR

Consider a system with three queues ${\displaystyle q_{1},q_{2},q_{3}}$ and respective weights ${\displaystyle w_{1}=5,w_{2}=2,w_{3}=3}$. Consider a situation where they are 7 packets in the first queue, A,B,C,D,E,F,G, 3 in the second queue, U,V,W and 2 in the third queue X,Y. Assume that there is no more packet arrival.

With classical WRR, in the first cycle, the scheduler first selects ${\displaystyle q_{1}}$ and transmits the five packets at head of queue,A,B,C,D,E (since ${\displaystyle w_{1}=5}$), then it selects the second queue, ${\displaystyle q_{2}}$, and transmits the two packets at head of queue, U,V (since ${\displaystyle w_{2}=2}$), and last it selects the third queue, which has a weight equals to 3 but only two packets, so it transmits X,Y. Immediately after the end of transmission of Y, the second cycle starts, and F,G from ${\displaystyle q_{1}}$ are transmitted, followed by W from ${\displaystyle q_{2}}$.

With interleaved WRR, the first cycle is split into 5 rounds (since ${\displaystyle max(w_{1},w_{2},w_{3})=5}$). In the first one (r=1), one packet from each queue is sent (A,U,X), in the second round (r=2), another packet from each queue is also sent (B,V,Y), in the third round (r=3), only queues ${\displaystyle q_{1},q_{3}}$ are allowed to send a packet (${\displaystyle w_{1}>=r}$, ${\displaystyle w_{2}<r}$ and ${\displaystyle w_{3}>=r}$), but since ${\displaystyle q_{3}}$ is empty, only C from ${\displaystyle q_{1}}$ is sent, and in the fourth and fifth rounds, only D,E from ${\displaystyle q_{1}}$ are sent. Then starts the second cycle, where F,W,G are sent.