Egress scheduling

Queue scheduling policies manage the distribution of scheduling resources available to process traffic in egress queues. The following figure illustrates the default queue scheduling policy.

The queue scheduling policies define the following hierarchy of scheduling tiers:

• Tier 0: Up to 12 schedulers, each of which can provide shaping for single or multiple queues. The egress queues are processed initially by tier 0 schedulers, which in turn feed into the tier 1 scheduler.
• Tier 1: One scheduler, which provides aggregate-level shaping for all queues.

A total of 13 tier 0 and tier 1 schedulers can be defined. Within a queue scheduling policy, each defined queue must be mapped as an input to one of the tier 0 schedulers. The tier 0 schedulers are in turn mapped as inputs to the tier 1 scheduler. For each queue scheduler, shaper bucket thresholds determine how the scheduling resources are distributed by the scheduler.

The queue scheduling policies are applied at subinterface-level (such as CVLANs) to manage the defined subinterface queues. They are also applied at interface-level for any traffic that does not match any policies defined for subinterfaces.

The queue scheduling policies also support the mapping of each of the 12 egress queues to one of four scheduling classes: 0, 2, 4, and 6. If multiple queues are assigned to the same tier 0 scheduler, they must also be assigned to the same scheduling class.

The queues within a tier 0 scheduler draw bandwidth proportional to their weights. The tier 0 scheduler draws bandwidth based on the scheduling class. The tier 0 schedulers with higher scheduling classes are scheduled ahead of the lower scheduling classes and are capped by their rate. The scheduler rate can be defined as an absolute value (from 64Kb/s to 400Gb/s), or as a percentage value of the line rate.

The interface-level scheduling class schedulers provide further shaping.

Scheduling class scheduling policies manage the distribution of scheduling resources available to process traffic in scheduling classes. The following figure illustrates the default scheduling class scheduling policy.

Similar to queue scheduling policies, the scheduling class scheduling policies define the following hierarchy of scheduling tiers:

• Tier 0: Up to 8 schedulers, each of which can provide shaping for single or multiple scheduling classes exiting the queue schedulers. The scheduling classes are processed initially by tier 0 schedulers, which in turn feed into the tier 1 scheduler.
• Tier 1: One scheduler, which provides aggregate-level shaping for all scheduling classes.

A total of 9 tier 0 and tier 1 schedulers can be defined. Also similar to queue schedulers, shaper bucket thresholds determine how the scheduling resources are distributed by the scheduler within each scheduling class scheduler.

The scheduling class scheduling policies are applied at interface level.

The following diagram shows the flow of packet processing through the queue and scheduling class scheduler policies applied to a subinterface and to an interface.

When a packet arrives on a subinterface for queueing at egress, the system performs the following steps.

1. Compare the packet FC (derived from one of the ingress classification policies) against the subinterface queue policies.

   • If a match is found, assign a queue for the packet based on the output class map policy.
   • If no match is found, assign the packet to a queue based on the interface-level FC-to-queue mapping.

2. The queues are scheduled based on the configured queue and scheduling class policies. The tier-1 scheduler allocates available bandwidth to its children serving the higher scheduling classes first and allocating the remaining bandwidth until none remains. And within a scheduling class, the available bandwidth is allocated to children in a weighted fair manner.

The queue scheduling hierarchy consists of queues feeding multiple tier 0 schedulers which in turn feed into a single tier 1 scheduler that aggregates all queues from tier 0.

The following example shows the queue scheduling policy configuration for three queues, where scheduler 4 in tier 1 is configured with the inputs auto-input parameter, which indicates that all tier 0 schedulers are inputs to scheduler 4. (The auto-input option cannot be set for a tier 0 scheduler.)

--{ candidate shared default }--[  ]--
# info qos scheduler-policies queue-scheduling-policy test-sub-interface
    qos {
        scheduler-policies {
            queue-scheduling-policy test-sub-interface {
                queue af1-queue {
                    scheduling {
                        scheduling-class 4
                        weight 2
                        packet-length-adjustment {
                            add 0
                        }
                    }
                }
                queue af2-queue {
                    scheduling {
                        scheduling-class 4
                        weight 4
                        packet-length-adjustment {
                            add 0
                        }
                    }
                }
                queue be-queue {
                    scheduling {
                        scheduling-class 0
                        packet-length-adjustment {
                            add 0
                        }
                    }
                }
                queue ef-queue {
                    scheduling {
                        scheduling-class 6
                        packet-length-adjustment {
                            add 0
                        }
                    }
                }
                scheduler 0 {
                    tier 0
                    rate {
                        peak-rate-percentage 100
                    }
                    inputs {
                        queue [
                            be-queue
                        ]
                    }
                }
                scheduler 1 {
                    tier 0
                    rate {
                        peak-rate-percentage 80
                    }
                    inputs {
                        queue [
                            af1-queue
                            af2-queue
                        ]
                    }
                }
                scheduler 2 {
                    tier 0
                    rate {
                        peak-rate-percentage 20
                    }
                    inputs {
                        queue [
                            expedite-queue
                        ]
                    }
                }
                scheduler 4 {
                    tier 1
                    rate {
                        peak-rate-kbps 7000
                    }
                    inputs {
                        inputs auto-input
                    }
                }
            }
        }
    }

At interface-level, the scheduling hierarchy consists of scheduling classes feeding multiple tier 0 schedulers which in turn feed into a single tier 1 scheduler that aggregates all scheduling-classes from tier 0.

The following example shows the scheduling class scheduling policy configuration for three scheduling classes.

Similar to the queue policy, the tier 1 scheduler 2 is configured with the inputs auto-input parameter, which indicates that all tier 0 schedulers are inputs to this scheduler. (If the auto-input option is set for a tier 0 scheduler, all defined queues are inputs to this scheduler. In that case, none of other tier 0 schedulers can have queues defined as explicit inputs.)

--{ candidate shared default }--[  ]--
# info qos scheduler-policies sched-class-scheduling-policy sched-class-scheduling-policy-name
    qos {
        scheduler-policies {
            sched-class-scheduling-policy sched-class-scheduling-policy-name {
                scheduler 1 {
                    tier 0
                    rate {
                        peak-rate-kbps 10000
                        pir-adaptation-rule closest
                    }
                    inputs {
                        scheduling-class [
                            0
                            4
                        ]
                    }
                }
                scheduler 2 {
                    tier 1
                    rate {
                        peak-rate-kbps 10000
                        pir-adaptation-rule closest
                    }
                    inputs {
                        inputs auto-input
                    }
                }
                scheduler 3 {
                    tier 0
                    rate {
                        peak-rate-kbps 2000
                        pir-adaptation-rule closest
                    }
                    inputs {
                        scheduling-class [
                            6
                        ]
                    }
                }
            }
        }
    }

Default interface queues

The following table shows the default settings applied to the interface-level queues. At interface level, all 12 queues are created by default. The table lists default settings for all queues, including the scheduling-related parameters.

To change the queue scheduling parameters, assign a custom queue scheduling policy to the interface. Similarly, to modify default scheduling behavior between scheduling classes at the interface level, assign a custom scheduling class scheduling policy to an interface.

Default subinterface queues

At subinterface level, local queues are created only after an output class map is assigned to the subinterface. By default, the queue parameters are set as described in the interface table above, using the queue-index as a key. To change queue scheduling parameters, assign a custom queue scheduling policy to the subinterface.

By default, the system provides the following two non-configurable scheduling threshold policies:

• per-scheduling-class
• single

The following diagram shows the default scheduling threshold policies. Both tier 0 schedulers are assigned the default scheduling-threshold-policy single, while both tier 1 schedulers are assigned the default scheduling-threshold-policy per-scheduling-class.

Custom-defined scheduling threshold policies are not supported.

Scheduling threshold policy: per-scheduling-class

The per-scheduling-class policy ensures that each scheduling class is assigned a distinct priority level within a shaper bucket.

The shaping of scheduling classes occurs in relation to the shaper token level. This process can be illustrated by considering scheduling class 3, which is associated with threshold level 3. If the token level is below threshold level 3, but above threshold level 2, queues associated with scheduling class 3 are shaped to enforce the overall rate of the bucket. Queues associated with scheduling class 3 are not shaped by this bucket if the shaper token level is at or above threhold level 3, or if the token level drops below threshold level 2.

The per-scheduling-class policy is assigned to tier 1 schedulers by default, both in the queue scheduling policies and the scheduling class scheduling policies. These settings are non-configurable.

The default per-scheduling-class policy is as follows:

qos {
   scheduling-policies {
      scheduling-threshold-policy "per-scheduling-class" {
         threshold 0 {
            maximum-scheduling-class 0
         }
         threshold 2 {
            maximum-scheduling-class 2
         }
         threshold 4 {
            maximum-scheduling-class 4
         }
         threshold 6 {
            maximum-scheduling-class 6
         }
      }
   }
}

Scheduling threshold policy: single

The single scheduling threshold policy places all scheduling classes on the first threshold level, avoiding multiple priority levels and the corresponding increases in burst tolerance.

The single policy is assigned to tier 0 schedulers by default, in both the queue scheduling policy and scheduling class scheduling policy. This setting is non-configurable.

qos {
   scheduling-policies {
      scheduling-threshold-policy "single" {
         threshold 0 {
            maximum-scheduling-class 6
         }
      }
   }
}

Modifying threshold level bucket depths

The size of the shaper buckets for all threshold levels used in the default scheduling threshold policies are defined in relation to the burst-allowance and threshold-separation parameters. These parameters are defined for queues and scheduling classes using queue scheduling policies and scheduling class scheduler policies.