net/sched/sch_qfq.c

41   classes. Each aggregate is timestamped with a virtual start time S
44   time function V. The classes within each aggregate are instead
97  * Shifts used for aggregate<->group mapping.  We allow class weights that are
98  * in the range [1, 2^MAX_WSHIFT], and we try to map each aggregate i to the
100  * for the classes in the aggregate.
118 #define QFQ_MAX_AGG_CLASSES	8 /* max num classes per aggregate allowed */
138 	struct qfq_aggregate *agg;	/* Parent aggregate. */
153 	u32	class_weight; /* Weight of each class in this aggregate. */
154 	/* Max pkt size for the classes in this aggregate, DRR quantum. */
158 	u32	budgetmax;  /* Max budget for this aggregate. */
184 	struct qfq_aggregate	*in_serv_agg;   /* Aggregate being served. */
197  * Possible reasons why the timestamps of an aggregate are updated
198  * enqueue: the aggregate switches from idle to active and must scheduled
200  * requeue: the aggregate finishes its budget, so it stops being served and
280 /* Update aggregate as a function of the new number of classes. */
314 /* Add class to aggregate. */
344 /* Deschedule class from within its parent aggregate. */
350 	list_del(&cl->alist); /* remove from RR queue of the aggregate */  in qfq_deactivate_class()
355 /* Remove class from its parent aggregate. */
368 /* Deschedule class and remove it from its parent aggregate. */
377 /* Move class to a new aggregate, matching the new class weight and/or lmax */
389 	if (new_agg == NULL) { /* create new aggregate */  in qfq_change_agg()
502 	if (new_agg == NULL) { /* create new aggregate */  in qfq_change_class()
825  * The index of the slot in which the input aggregate agg is to be
828  * backward by one slot after the aggregate has been inserted, and
835  * happens that the aggregate becomes backlogged and eligible, or just
836  * eligible, while an aggregate with a higher approximated finish time
864  * class is decreased, then a new aggregate with smaller slot size
865  * than the original parent aggregate of the class may happen to be
866  * activated. The activation of this aggregate should be properly
868  * system tracked by QFQ+. If the activation of the aggregate is not
869  * delayed to this reference time instant, then this aggregate may be
874  * Instead of delaying the activation of the new aggregate, which is
920  * Returns the first aggregate in the first non-empty bucket of the
976 /* Dequeue head packet of the head class in the DRR queue of the aggregate. */
1013 /* Update F according to the actual service received by the aggregate. */
1016 	/* Compute the service received by the aggregate, taking into  in charge_actual_service()
1027 /* Assign a reasonable start time for a new aggregate in group i.
1068  * value, i.e., the virtual finish time with which the aggregate
1101 	 * If there are no active classes in the in-service aggregate,  in qfq_dequeue()
1102 	 * or if the aggregate has not enough budget to serve its next  in qfq_dequeue()
1103 	 * class, then choose the next aggregate to serve.  in qfq_dequeue()
1108 		/* recharge the budget of the aggregate */  in qfq_dequeue()
1116 			 * aggregate is active, then there is no point  in qfq_dequeue()
1117 			 * in rescheduling this aggregate, and we can  in qfq_dequeue()
1125 		} else if (sch->q.qlen == 0) { /* no aggregate to serve */  in qfq_dequeue()
1132 		 * choose the new aggregate to serve.  in qfq_dequeue()
1268 	/* schedule class for service within the aggregate */  in qfq_enqueue()
1282  * Schedule aggregate according to its timestamps.
1338 		q->in_serv_agg = agg; /* start serving this aggregate */  in qfq_activate_agg()
1362  * Called to forcibly deschedule an aggregate.  If the aggregate is
1364  * the front bucket, we can simply remove the aggregate with no other