Re: [patch 03/18] sched: introduce primitives to account for CFS bandwidth tracking

[Kamalesh Babulal <kamalesh@linux.vnet.ibm.com>]

* Paul Turner <pjt@google.com> [2011-07-21 09:43:28]:

> In this patch we introduce the notion of CFS bandwidth, partitioned into
> globally unassigned bandwidth, and locally claimed bandwidth.
> 
> - The global bandwidth is per task_group, it represents a pool of unclaimed
>   bandwidth that cfs_rqs can allocate from.  
> - The local bandwidth is tracked per-cfs_rq, this represents allotments from
>   the global pool bandwidth assigned to a specific cpu.
> 
> Bandwidth is managed via cgroupfs, adding two new interfaces to the cpu subsystem:
> - cpu.cfs_period_us : the bandwidth period in usecs
> - cpu.cfs_quota_us : the cpu bandwidth (in usecs) that this tg will be allowed
>   to consume over period above.
> 
> Signed-off-by: Paul Turner <pjt@google.com>
> Signed-off-by: Nikhil Rao <ncrao@google.com>
> Signed-off-by: Bharata B Rao <bharata@linux.vnet.ibm.com>
> Reviewed-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
> 
> ---
>  init/Kconfig        |   12 +++
>  kernel/sched.c      |  196 ++++++++++++++++++++++++++++++++++++++++++++++++++--
>  kernel/sched_fair.c |   16 ++++
>  3 files changed, 220 insertions(+), 4 deletions(-)
> 
> Index: tip/init/Kconfig
> ===================================================================
> --- tip.orig/init/Kconfig
> +++ tip/init/Kconfig
> @@ -715,6 +715,18 @@ config FAIR_GROUP_SCHED
>  	depends on CGROUP_SCHED
>  	default CGROUP_SCHED
> 
> +config CFS_BANDWIDTH
> +	bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
> +	depends on EXPERIMENTAL
> +	depends on FAIR_GROUP_SCHED
> +	default n
> +	help
> +	  This option allows users to define CPU bandwidth rates (limits) for
> +	  tasks running within the fair group scheduler.  Groups with no limit
> +	  set are considered to be unconstrained and will run with no
> +	  restriction.
> +	  See tip/Documentation/scheduler/sched-bwc.txt for more information.
> +
>  config RT_GROUP_SCHED
>  	bool "Group scheduling for SCHED_RR/FIFO"
>  	depends on EXPERIMENTAL
> Index: tip/kernel/sched.c
> ===================================================================
> --- tip.orig/kernel/sched.c
> +++ tip/kernel/sched.c
> @@ -244,6 +244,14 @@ struct cfs_rq;
> 
>  static LIST_HEAD(task_groups);
> 
> +struct cfs_bandwidth {
> +#ifdef CONFIG_CFS_BANDWIDTH
> +	raw_spinlock_t lock;
> +	ktime_t period;
> +	u64 quota;
> +#endif
> +};
> +
>  /* task group related information */
>  struct task_group {
>  	struct cgroup_subsys_state css;
> @@ -275,6 +283,8 @@ struct task_group {
>  #ifdef CONFIG_SCHED_AUTOGROUP
>  	struct autogroup *autogroup;
>  #endif
> +
> +	struct cfs_bandwidth cfs_bandwidth;
>  };
> 
>  /* task_group_lock serializes the addition/removal of task groups */
> @@ -374,9 +384,48 @@ struct cfs_rq {
> 
>  	unsigned long load_contribution;
>  #endif
> +#ifdef CONFIG_CFS_BANDWIDTH
> +	int runtime_enabled;
> +	s64 runtime_remaining;
> +#endif
>  #endif
>  };
> 
> +#ifdef CONFIG_FAIR_GROUP_SCHED
> +#ifdef CONFIG_CFS_BANDWIDTH
> +static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
> +{
> +	return &tg->cfs_bandwidth;
> +}
> +
> +static inline u64 default_cfs_period(void);
> +
> +static void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
> +{
> +	raw_spin_lock_init(&cfs_b->lock);
> +	cfs_b->quota = RUNTIME_INF;
> +	cfs_b->period = ns_to_ktime(default_cfs_period());
> +}
> +
> +static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq)
> +{
> +	cfs_rq->runtime_enabled = 0;
> +}
> +
> +static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
> +{}
> +#else
> +static void init_cfs_rq_runtime(struct cfs_rq *cfs_rq) {}
> +static void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
> +static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b) {}
> +
> +static inline struct cfs_bandwidth *tg_cfs_bandwidth(struct task_group *tg)
> +{
> +	return NULL;
> +}
> +#endif /* CONFIG_CFS_BANDWIDTH */
> +#endif /* CONFIG_FAIR_GROUP_SCHED */
> +
>  /* Real-Time classes' related field in a runqueue: */
>  struct rt_rq {
>  	struct rt_prio_array active;
> @@ -7795,6 +7844,7 @@ static void init_tg_cfs_entry(struct tas
>  	tg->cfs_rq[cpu] = cfs_rq;
>  	init_cfs_rq(cfs_rq, rq);
>  	cfs_rq->tg = tg;
> +	init_cfs_rq_runtime(cfs_rq);

this hunk fails to apply, due to the changes introduced by
acb5a9ba3bd7 in the tip tree.
> 
>  	tg->se[cpu] = se;
>  	/* se could be NULL for root_task_group */
> @@ -7930,6 +7980,7 @@ void __init sched_init(void)
>  		 * We achieve this by letting root_task_group's tasks sit
>  		 * directly in rq->cfs (i.e root_task_group->se[] = NULL).
>  		 */
> +		init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
>  		init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
>  #endif /* CONFIG_FAIR_GROUP_SCHED */
> 
> @@ -8171,6 +8222,8 @@ static void free_fair_sched_group(struct
>  {
>  	int i;
> 
> +	destroy_cfs_bandwidth(tg_cfs_bandwidth(tg));
> +
>  	for_each_possible_cpu(i) {
>  		if (tg->cfs_rq)
>  			kfree(tg->cfs_rq[i]);
> @@ -8198,6 +8251,8 @@ int alloc_fair_sched_group(struct task_g
> 
>  	tg->shares = NICE_0_LOAD;
> 
> +	init_cfs_bandwidth(tg_cfs_bandwidth(tg));
> +
>  	for_each_possible_cpu(i) {
>  		cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
>  				      GFP_KERNEL, cpu_to_node(i));
> @@ -8569,7 +8624,7 @@ static int __rt_schedulable(struct task_
>  	return walk_tg_tree(tg_schedulable, tg_nop, &data);
>  }
> 
> -static int tg_set_bandwidth(struct task_group *tg,
> +static int tg_set_rt_bandwidth(struct task_group *tg,
>  		u64 rt_period, u64 rt_runtime)
>  {
>  	int i, err = 0;
> @@ -8608,7 +8663,7 @@ int sched_group_set_rt_runtime(struct ta
>  	if (rt_runtime_us < 0)
>  		rt_runtime = RUNTIME_INF;
> 
> -	return tg_set_bandwidth(tg, rt_period, rt_runtime);
> +	return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
>  }
> 
>  long sched_group_rt_runtime(struct task_group *tg)
> @@ -8633,7 +8688,7 @@ int sched_group_set_rt_period(struct tas
>  	if (rt_period == 0)
>  		return -EINVAL;
> 
> -	return tg_set_bandwidth(tg, rt_period, rt_runtime);
> +	return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
>  }
> 
>  long sched_group_rt_period(struct task_group *tg)
> @@ -8823,6 +8878,128 @@ static u64 cpu_shares_read_u64(struct cg
> 
>  	return (u64) scale_load_down(tg->shares);
>  }
> +
> +#ifdef CONFIG_CFS_BANDWIDTH
> +const u64 max_cfs_quota_period = 1 * NSEC_PER_SEC; /* 1s */
> +const u64 min_cfs_quota_period = 1 * NSEC_PER_MSEC; /* 1ms */
> +
> +static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)
> +{
> +	int i;
> +	struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg);
> +	static DEFINE_MUTEX(mutex);
> +
> +	if (tg == &root_task_group)
> +		return -EINVAL;
> +
> +	/*
> +	 * Ensure we have at some amount of bandwidth every period.  This is
> +	 * to prevent reaching a state of large arrears when throttled via
> +	 * entity_tick() resulting in prolonged exit starvation.
> +	 */
> +	if (quota < min_cfs_quota_period || period < min_cfs_quota_period)
> +		return -EINVAL;
> +
> +	/*
> +	 * Likewise, bound things on the otherside by preventing insane quota
> +	 * periods.  This also allows us to normalize in computing quota
> +	 * feasibility.
> +	 */
> +	if (period > max_cfs_quota_period)
> +		return -EINVAL;
> +
> +	mutex_lock(&mutex);
> +	raw_spin_lock_irq(&cfs_b->lock);
> +	cfs_b->period = ns_to_ktime(period);
> +	cfs_b->quota = quota;
> +	raw_spin_unlock_irq(&cfs_b->lock);
> +
> +	for_each_possible_cpu(i) {
> +		struct cfs_rq *cfs_rq = tg->cfs_rq[i];
> +		struct rq *rq = rq_of(cfs_rq);
> +
> +		raw_spin_lock_irq(&rq->lock);
> +		cfs_rq->runtime_enabled = quota != RUNTIME_INF;
> +		cfs_rq->runtime_remaining = 0;
> +		raw_spin_unlock_irq(&rq->lock);
> +	}
> +	mutex_unlock(&mutex);
> +
> +	return 0;
> +}
> +
> +int tg_set_cfs_quota(struct task_group *tg, long cfs_quota_us)
> +{
> +	u64 quota, period;
> +
> +	period = ktime_to_ns(tg_cfs_bandwidth(tg)->period);
> +	if (cfs_quota_us < 0)
> +		quota = RUNTIME_INF;
> +	else
> +		quota = (u64)cfs_quota_us * NSEC_PER_USEC;
> +
> +	return tg_set_cfs_bandwidth(tg, period, quota);
> +}
> +
> +long tg_get_cfs_quota(struct task_group *tg)
> +{
> +	u64 quota_us;
> +
> +	if (tg_cfs_bandwidth(tg)->quota == RUNTIME_INF)
> +		return -1;
> +
> +	quota_us = tg_cfs_bandwidth(tg)->quota;
> +	do_div(quota_us, NSEC_PER_USEC);
> +
> +	return quota_us;
> +}
> +
> +int tg_set_cfs_period(struct task_group *tg, long cfs_period_us)
> +{
> +	u64 quota, period;
> +
> +	period = (u64)cfs_period_us * NSEC_PER_USEC;
> +	quota = tg_cfs_bandwidth(tg)->quota;
> +
> +	if (period <= 0)
> +		return -EINVAL;
> +
> +	return tg_set_cfs_bandwidth(tg, period, quota);
> +}
> +
> +long tg_get_cfs_period(struct task_group *tg)
> +{
> +	u64 cfs_period_us;
> +
> +	cfs_period_us = ktime_to_ns(tg_cfs_bandwidth(tg)->period);
> +	do_div(cfs_period_us, NSEC_PER_USEC);
> +
> +	return cfs_period_us;
> +}
> +
> +static s64 cpu_cfs_quota_read_s64(struct cgroup *cgrp, struct cftype *cft)
> +{
> +	return tg_get_cfs_quota(cgroup_tg(cgrp));
> +}
> +
> +static int cpu_cfs_quota_write_s64(struct cgroup *cgrp, struct cftype *cftype,
> +				s64 cfs_quota_us)
> +{
> +	return tg_set_cfs_quota(cgroup_tg(cgrp), cfs_quota_us);
> +}
> +
> +static u64 cpu_cfs_period_read_u64(struct cgroup *cgrp, struct cftype *cft)
> +{
> +	return tg_get_cfs_period(cgroup_tg(cgrp));
> +}
> +
> +static int cpu_cfs_period_write_u64(struct cgroup *cgrp, struct cftype *cftype,
> +				u64 cfs_period_us)
> +{
> +	return tg_set_cfs_period(cgroup_tg(cgrp), cfs_period_us);
> +}
> +
> +#endif /* CONFIG_CFS_BANDWIDTH */
>  #endif /* CONFIG_FAIR_GROUP_SCHED */
> 
>  #ifdef CONFIG_RT_GROUP_SCHED
> @@ -8857,6 +9034,18 @@ static struct cftype cpu_files[] = {
>  		.write_u64 = cpu_shares_write_u64,
>  	},
>  #endif
> +#ifdef CONFIG_CFS_BANDWIDTH
> +	{
> +		.name = "cfs_quota_us",
> +		.read_s64 = cpu_cfs_quota_read_s64,
> +		.write_s64 = cpu_cfs_quota_write_s64,
> +	},
> +	{
> +		.name = "cfs_period_us",
> +		.read_u64 = cpu_cfs_period_read_u64,
> +		.write_u64 = cpu_cfs_period_write_u64,
> +	},
> +#endif
>  #ifdef CONFIG_RT_GROUP_SCHED
>  	{
>  		.name = "rt_runtime_us",
> @@ -9166,4 +9355,3 @@ struct cgroup_subsys cpuacct_subsys = {
>  	.subsys_id = cpuacct_subsys_id,
>  };
>  #endif	/* CONFIG_CGROUP_CPUACCT */
> -
> Index: tip/kernel/sched_fair.c
> ===================================================================
> --- tip.orig/kernel/sched_fair.c
> +++ tip/kernel/sched_fair.c
> @@ -1256,6 +1256,22 @@ entity_tick(struct cfs_rq *cfs_rq, struc
>  		check_preempt_tick(cfs_rq, curr);
>  }
> 
> +
> +/**************************************************
> + * CFS bandwidth control machinery
> + */
> +
> +#ifdef CONFIG_CFS_BANDWIDTH
> +/*
> + * default period for cfs group bandwidth.
> + * default: 0.1s, units: nanoseconds
> + */
> +static inline u64 default_cfs_period(void)
> +{
> +	return 100000000ULL;
> +}
> +#endif
> +
>  /**************************************************
>   * CFS operations on tasks:
>   */
> 
>