IO cost model based work-conserving porportional controller
Subsystems (6)
Tejun Heo
maintainerPATCH v2 1/1 IO cost model based work-conserving porportional controller
Hello,
Changes from v1[1]:
* Prerequisite patchsets had cosmetic changes and merged. Refreshed on top.
* Renamed from ioweight to iocost. All source code and tools are updated accordingly. Control knobs io.weight.qos and io.weight.cost_model are renamed to io.cost.qos and io.cost.model respectively. This is a more fitting name which won't become a misnomer when, for example, cost based io.max is added.
* Various bug fixes and improvements. A few bugs were discovered while testing against high-iops nvme device. Auto parameter selection improved and verified across different classes of SSDs.
* Dropped bpf iocost support for now.
* Added coef generation script.
* Verified on high-iops nvme device. Result is included below.
One challenge of controlling IO resources is the lack of trivially observable cost metric. This is distinguished from CPU and memory where wallclock time and the number of bytes can serve as accurate enough approximations.
Bandwidth and iops are the most commonly used metrics for IO devices but depending on the type and specifics of the device, different IO patterns easily lead to multiple orders of magnitude variations rendering them useless for the purpose of IO capacity distribution. While on-device time, with a lot of clutches, could serve as a useful approximation for non-queued rotational devices, this is no longer viable with modern devices, even the rotational ones.
While there is no cost metric we can trivially observe, it isn't a complete mystery. For example, on a rotational device, seek cost dominates while a contiguous transfer contributes a smaller amount proportional to the size. If we can characterize at least the relative costs of these different types of IOs, it should be possible to implement a reasonable work-conserving proportional IO resource distribution.
This patchset implements IO cost model based work-conserving proportional controller. It currently has a simple linear cost model builtin where each IO is classified as sequential or random and given a base cost accordingly and additional size-proportional cost is added on top. Each IO is given a cost based on the model and the controller issues IOs for each cgroup according to their hierarchical weight.
By default, the controller adapts its overall IO rate so that it doesn't build up buffer bloat in the request_queue layer, which guarantees that the controller doesn't lose significant amount of total work. However, this may not provide sufficient differentiation as the underlying device may have a deep queue and not be fair in how the queued IOs are serviced. The controller provides extra QoS control knobs which allow tightening control feedback loop as necessary.
For more details on the control mechanism, implementation and interface, please refer to the comment at the top of block/blk-iocost.c and Documentation/admin-guide/cgroup-v2.rst changes in the "blkcg: implement blk-iocost" patch.
Here are some test results. Each test run goes through the following combinations with each combination running for a minute. All tests are performed against regular files on btrfs w/ deadline as the IO scheduler. Random IOs are direct w/ queue depth of 64. Sequential are normal buffered IOs.
high priority (weight=500) low priority (weight=100)
Rand read None
ditto Rand read
ditto Seq read
ditto Rand write
ditto Seq write
Seq read None
ditto Rand read
ditto Seq read
ditto Rand write
ditto Seq write
Rand write None
ditto Rand read
ditto Seq read
ditto Rand write
ditto Seq write
Seq write None
ditto Rand read
ditto Seq read
ditto Rand write
ditto Seq write
* 7200RPM SATA hard disk
* No IO control
https://photos.app.goo.gl/1KBHn7ykpC1LXRkB8 * iocost, QoS: None https://photos.app.goo.gl/MLNQGxCtBQ8wAmjm7 * iocost, QoS: rpct=95.00 rlat=40000 wpct=95.00 wlat=40000 min=25.00 max=200.00 https://photos.app.goo.gl/XqXHm3Mkbm9w6Db46 * NCQ-blacklisted SATA SSD (QD==1) * No IO control https://photos.app.goo.gl/wCTXeu2uJ6LYL4pk8 * iocost, QoS: None https://photos.app.goo.gl/T2HedKD2sywQgj7R9
* iocost, QoS: rpct=95.00 rlat=20000 wpct=95.00 wlat=20000 min=50.00 max=200.00
https://photos.app.goo.gl/urBTV8XQc1UqPJJw7
* SATA SSD (QD==32)
* No IO control
https://photos.app.goo.gl/TjEVykuVudSQcryh6
* iocost, QoS: None
https://photos.app.goo.gl/iyQBsky7bmM54Xiq7
* iocost, QoS: rpct=95.00 rlat=10000 wpct=95.00 wlat=20000 min=50.00 max=400.00
https://photos.app.goo.gl/q1a6URLDxPLMrnHy5
* NVME SSD (ran with 8 concurrent fio jobs to achieve saturation)
* No IO control
https://photos.app.goo.gl/S6xjEVTJzcfb3w1j7
* iocost, QoS: None
https://photos.app.goo.gl/SjQUUotJBAGr7vqz7
* iocost, QoS: rpct=95.00 rlat=5000 wpct=95.00 wlat=5000 min=1.00 max=10000.00
https://photos.app.goo.gl/RsaYBd2muX7CegoN7
Even without explicit QoS configuration, read-heavy scenarios can obtain acceptable differentiation. However, when write-heavy, the deep buffering on the device side makes it difficult to maintain control. With QoS parameters set, the differentiation is acceptable across all combinations.
The implementation comes with default cost model parameters which are selected automatically which should provide acceptable behavior across most common devices. The parameters for hdd and consumer-grade SSDs seem pretty robust. The default parameter set and selection criteria for highend SSDs might need further adjustments.
It is fairly easy to configure the QoS parameters and, if needed, cost model coefficients. We'll follow up with tooling and further documentation. Also, the last RFC patch in the series implements support for bpf-based custom cost function. Originally we thought that we'd need per-device-type cost functions but the simple linear model now seem good enough to cover all common device classes. In case custom cost functions become necessary, we can fully develop the bpf based extension and also easily add different builtin cost models.
Andy Newell did the heavy lifting of analyzing IO workloads and device characteristics, exploring various cost models, determining the default model and parameters to use.
Josef Bacik implemented a prototype which explored the use of different types of cost metrics including on-device time and Andy's linear model.
This patchset is on top of block/for-linus 3a10f999ffd4 ("blk-throttle: fix zero wait time for iops throttled group") and contains the following ten patches.
0001-blkcg-pass-q-and-blkcg-into-blkcg_pol_alloc_pd_fn.patch 0002-blkcg-make-cpd_init_fn-optional.patch 0003-blkcg-separate-blkcg_conf_get_disk-out-of-blkg_conf_.patch 0004-block-rq_qos-add-rq_qos_merge.patch 0005-block-rq_qos-implement-rq_qos_ops-queue_depth_change.patch 0006-blkcg-s-RQ_QOS_CGROUP-RQ_QOS_LATENCY.patch 0007-blk-mq-add-optional-request-pre_start_time_ns.patch 0008-blkcg-implement-blk-iocost.patch 0009-blkcg-add-tools-cgroup-iocost_monitor.py.patch 0010-blkcg-add-tools-cgroup-iocost_coef_gen.py.patch
0001-0007 are prep patches. 0008 implements blk-iocost. 0009 adds monitoring script. 0010 adds linear model coef generation script.
The patchset is also available in the following git branch.
git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git review-iocost
diffstat follows, Thanks.
Documentation/admin-guide/cgroup-v2.rst | 97 + block/Kconfig | 9 block/Makefile | 1 block/bfq-cgroup.c | 5 block/blk-cgroup.c | 71 block/blk-core.c | 4 block/blk-iocost.c | 2394 ++++++++++++++++++++++++++++++++ block/blk-iolatency.c | 8 block/blk-mq.c | 11 block/blk-rq-qos.c | 18 block/blk-rq-qos.h | 28 block/blk-settings.c | 2 block/blk-throttle.c | 6 block/blk-wbt.c | 18 block/blk-wbt.h | 4 include/linux/blk-cgroup.h | 4 include/linux/blk_types.h | 3 include/linux/blkdev.h | 7 include/trace/events/iocost.h | 174 ++ tools/cgroup/iocost_coef_gen.py | 178 ++ tools/cgroup/iocost_monitor.py | 270 +++ 21 files changed, 3259 insertions(+), 53 deletions(-)
--
tejun
Tejun Heo
maintainerPATCH 1/10 blkcg: pass @q and @blkcg into blkcg_pol_alloc_pd_fn()
Instead of @node, pass in @q and @blkcg so that the alloc function has more context. This doesn't cause any behavior change and will be used by io.weight implementation.
--- block/bfq-cgroup.c | 5 +++-- block/blk-cgroup.c | 6 +++--- block/blk-iolatency.c | 6 ++++-- block/blk-throttle.c | 6 ++++-- include/linux/blk-cgroup.h | 3 ++- 5 files changed, 16 insertions(+), 10 deletions(-)
block/bfq-cgroup.c +3 -2
@@ -501,11 +501,12 @@ static void bfq_cpd_free(struct blkcg_policy_data *cpd)kfree (cpd_to_bfqgd (cpd)); } -static struct blkg_policy_data *bfq_pd_alloc (gfp_t gfp,int node) +static struct blkg_policy_data *bfq_pd_alloc (gfp_t gfp,struct request_queue *q, +struct blkcg *blkcg) {struct bfq_group *bfqg; - bfqg =kzalloc_node (sizeof (*bfqg), gfp, node); + bfqg =kzalloc_node (sizeof (*bfqg), gfp, q->node);if (!bfqg)return NULL ;
block/blk-cgroup.c +3 -3
@@ -175,7 +175,7 @@ static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q,continue ;/* alloc per-policy data and attach it to blkg */ - pd = pol->pd_alloc_fn (gfp_mask, q->node); + pd = pol->pd_alloc_fn (gfp_mask, q, blkcg);if (!pd) goto err_free;
@@ -1349,7 +1349,7 @@ int blkcg_activate_policy(struct request_queue *q,blk_mq_freeze_queue (q); pd_prealloc:if (!pd_prealloc) { - pd_prealloc = pol->pd_alloc_fn (GFP_KERNEL , q->node); + pd_prealloc = pol->pd_alloc_fn (GFP_KERNEL , q, &blkcg_root);if (!pd_prealloc) { ret = -ENOMEM ; goto out_bypass_end;
@@ -1365,7 +1365,7 @@ int blkcg_activate_policy(struct request_queue *q,if (blkg->pd[pol->plid])continue ; - pd = pol->pd_alloc_fn (GFP_NOWAIT | __GFP_NOWARN, q->node); + pd = pol->pd_alloc_fn (GFP_NOWAIT | __GFP_NOWARN, q, &blkcg_root);if (!pd)swap (pd, pd_prealloc);if (!pd) {
block/blk-iolatency.c +4 -2
@@ -931,11 +931,13 @@ static size_t iolatency_pd_stat(struct blkg_policy_data *pd, char *buf, } -static struct blkg_policy_data *iolatency_pd_alloc (gfp_t gfp,int node) +static struct blkg_policy_data *iolatency_pd_alloc (gfp_t gfp, +struct request_queue *q, +struct blkcg *blkcg) {struct iolatency_grp *iolat; - iolat =kzalloc_node (sizeof (*iolat), gfp, node); + iolat =kzalloc_node (sizeof (*iolat), gfp, q->node);if (!iolat)return NULL ; iolat->stats = __alloc_percpu_gfp(sizeof(struct latency_stat),
block/blk-throttle.c +4 -2
@@ -478,12 +478,14 @@ static void throtl_service_queue_init(struct throtl_service_queue *sq)timer_setup (&sq->pending_timer, throtl_pending_timer_fn,0 ); } -static struct blkg_policy_data *throtl_pd_alloc (gfp_t gfp,int node) +static struct blkg_policy_data *throtl_pd_alloc (gfp_t gfp, +struct request_queue *q, +struct blkcg *blkcg) {struct throtl_grp *tg;int rw; - tg =kzalloc_node (sizeof (*tg), gfp, node); + tg =kzalloc_node (sizeof (*tg), gfp, q->node);if (!tg)return NULL ;
include/linux/blk-cgroup.h +2 -1
@@ -149,7 +149,8 @@ typedef struct blkcg_policy_data *(blkcg_pol_alloc_cpd_fn)(gfp_t gfp);typedef void (blkcg_pol_init_cpd_fn )(struct blkcg_policy_data *cpd);typedef void (blkcg_pol_free_cpd_fn )(struct blkcg_policy_data *cpd);typedef void (blkcg_pol_bind_cpd_fn )(struct blkcg_policy_data *cpd); -typedef struct blkg_policy_data *(blkcg_pol_alloc_pd_fn )(gfp_t gfp,int node); +typedef struct blkg_policy_data *(blkcg_pol_alloc_pd_fn )(gfp_t gfp, +struct request_queue *q,struct blkcg *blkcg);typedef void (blkcg_pol_init_pd_fn )(struct blkg_policy_data *pd);typedef void (blkcg_pol_online_pd_fn )(struct blkg_policy_data *pd);typedef void (blkcg_pol_offline_pd_fn )(struct blkg_policy_data *pd);
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 2/10 blkcg: make ->cpd_init_fn() optional
In reply to Tejun HeoFor policies which can do enough initialization from ->cpd_alloc_fn(), make ->cpd_init_fn() optional.
--- block/blk-cgroup.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
block/blk-cgroup.c +2 -1
@@ -1478,7 +1478,8 @@ int blkcg_policy_register(struct blkcg_policy *pol) blkcg->cpd[pol->plid] = cpd; cpd->blkcg = blkcg; cpd->plid = pol->plid; - pol->cpd_init_fn (cpd); +if (pol->cpd_init_fn) + pol->cpd_init_fn (cpd); } }
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 3/10 blkcg: separate blkcg_conf_get_disk() out of blkg_conf_prep()
In reply to Tejun HeoSeparate out blkcg_conf_get_disk() so that it can be used by blkcg policy interface file input parsers before the policy is actually enabled. This doesn't introduce any functional changes.
--- block/blk-cgroup.c | 62 ++++++++++++++++++++++++++------------ include/linux/blk-cgroup.h | 1 + 2 files changed, 44 insertions(+), 19 deletions(-)
block/blk-cgroup.c +43 -19
@@ -753,6 +753,44 @@ static struct blkcg_gq *blkg_lookup_check(struct blkcg *blkcg,return __blkg_lookup (blkcg, q, true/* update_hint */ ); } +/** +* blkg_conf_prep - parse and prepare for per-blkg config update +* @inputp: input string pointer +* +* Parse the device node prefix part, MAJ:MIN, of per-blkg config update +* from @input and get and return the matching gendisk. *@inputp is +* updated to point past the device node prefix. Returns an ERR_PTR() +* value on error. +* +* Use this function iff blkg_conf_prep() can't be used for some reason. +*/ +struct gendisk *blkcg_conf_get_disk (char **inputp) +{ +char *input = *inputp; +unsigned int major, minor; +struct gendisk *disk; +int key_len, part; + +if (sscanf (input,"%u:%u%n" , &major, &minor, &key_len) !=2 ) +return ERR_PTR (-EINVAL ); + + input += key_len; +if (!isspace (*input)) +return ERR_PTR (-EINVAL ); + input =skip_spaces (input); + + disk =get_gendisk (MKDEV (major, minor), &part); +if (!disk) +return ERR_PTR (-ENODEV ); +if (part) { +put_disk_and_module (disk); +return ERR_PTR (-ENODEV ); + } + + *inputp = input; +return disk; +} +/** * blkg_conf_prep - parse and prepare for per-blkg config update * @blkcg: target block cgroup
@@ -772,25 +810,11 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,struct gendisk *disk;struct request_queue *q;struct blkcg_gq *blkg; -unsigned int major, minor; -int key_len, part, ret; -char *body; - -if (sscanf (input,"%u:%u%n" , &major, &minor, &key_len) !=2 ) -return -EINVAL ; - - body = input + key_len; -if (!isspace (*body)) -return -EINVAL ; - body =skip_spaces (body); +int ret; - disk =get_gendisk (MKDEV (major, minor), &part); -if (!disk) -return -ENODEV ; -if (part) { - ret = -ENODEV ; - goto fail; - } + disk =blkcg_conf_get_disk (&input); +if (IS_ERR (disk)) +return PTR_ERR (disk); q = disk->queue;
@@ -856,7 +880,7 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol, success: ctx->disk = disk; ctx->blkg = blkg; - ctx->body = body; + ctx->body = input;return 0 ; fail_unlock:
include/linux/blk-cgroup.h +1 -0
@@ -233,6 +233,7 @@ struct blkg_conf_ctx {char *body; }; +struct gendisk *blkcg_conf_get_disk (char **inputp);int blkg_conf_prep (struct blkcg *blkcg,const struct blkcg_policy *pol,char *input,struct blkg_conf_ctx *ctx);void blkg_conf_finish (struct blkg_conf_ctx *ctx);
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 4/10 block/rq_qos: add rq_qos_merge()
In reply to Tejun HeoAdd a merge hook for rq_qos. This will be used by io.weight.
--- block/blk-core.c | 4 ++++ block/blk-rq-qos.c | 9 +++++++++ block/blk-rq-qos.h | 9 +++++++++ 3 files changed, 22 insertions(+)
block/blk-core.c +4 -0
@@ -601,6 +601,7 @@ bool bio_attempt_back_merge(struct request *req, struct bio *bio,return false;trace_block_bio_backmerge (req->q, req, bio); +rq_qos_merge (req->q, req, bio);if ((req->cmd_flags &REQ_FAILFAST_MASK ) != ff)blk_rq_set_mixed_merge (req);
@@ -622,6 +623,7 @@ bool bio_attempt_front_merge(struct request *req, struct bio *bio,return false;trace_block_bio_frontmerge (req->q, req, bio); +rq_qos_merge (req->q, req, bio);if ((req->cmd_flags &REQ_FAILFAST_MASK ) != ff)blk_rq_set_mixed_merge (req);
@@ -647,6 +649,8 @@ bool bio_attempt_discard_merge(struct request_queue *q, struct request *req, blk_rq_get_max_sectors(req, blk_rq_pos(req))) goto no_merge; +rq_qos_merge (q, req, bio); + req->biotail->bi_next = bio; req->biotail = bio; req->__data_len += bio->bi_iter.bi_size;
block/blk-rq-qos.c +9 -0
@@ -83,6 +83,15 @@ void __rq_qos_track(struct rq_qos *rqos, struct request *rq, struct bio *bio) }while (rqos); } +void __rq_qos_merge (struct rq_qos *rqos,struct request *rq,struct bio *bio) +{ +do { +if (rqos->ops->merge) + rqos->ops->merge (rqos, rq, bio); + rqos = rqos->next; + }while (rqos); +} +void __rq_qos_done_bio (struct rq_qos *rqos,struct bio *bio) { do {
block/blk-rq-qos.h +9 -0
@@ -35,6 +35,7 @@ struct rq_qos {struct rq_qos_ops {void (*throttle)(struct rq_qos *,struct bio *);void (*track)(struct rq_qos *,struct request *,struct bio *); +void (*merge)(struct rq_qos *,struct request *,struct bio *);void (*issue)(struct rq_qos *,struct request *);void (*requeue)(struct rq_qos *,struct request *);void (*done)(struct rq_qos *,struct request *);
@@ -135,6 +136,7 @@ void __rq_qos_issue(struct rq_qos *rqos, struct request *rq);void __rq_qos_requeue (struct rq_qos *rqos,struct request *rq);void __rq_qos_throttle (struct rq_qos *rqos,struct bio *bio);void __rq_qos_track (struct rq_qos *rqos,struct request *rq,struct bio *bio); +void __rq_qos_merge (struct rq_qos *rqos,struct request *rq,struct bio *bio);void __rq_qos_done_bio (struct rq_qos *rqos,struct bio *bio);static inline void rq_qos_cleanup (struct request_queue *q,struct bio *bio)
@@ -185,6 +187,13 @@ static inline void rq_qos_track(struct request_queue *q, struct request *rq, __rq_qos_track(q->rq_qos, rq, bio); } +static inline void rq_qos_merge (struct request_queue *q,struct request *rq, +struct bio *bio) +{ +if (q->rq_qos) +__rq_qos_merge (q->rq_qos, rq, bio); +} +void rq_qos_exit (struct request_queue *);#endif
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 5/10 block/rq_qos: implement rq_qos_ops->queue_depth_changed()
In reply to Tejun Heowbt already gets queue depth changed notification through wbt_set_queue_depth(). Generalize it into rq_qos_ops->queue_depth_changed() so that other rq_qos policies can easily hook into the events too.
--- block/blk-rq-qos.c | 9 +++++++++ block/blk-rq-qos.h | 8 ++++++++ block/blk-settings.c | 2 +- block/blk-wbt.c | 18 ++++++++---------- block/blk-wbt.h | 4 ---- 5 files changed, 26 insertions(+), 15 deletions(-)
block/blk-rq-qos.c +9 -0
@@ -101,6 +101,15 @@ void __rq_qos_done_bio(struct rq_qos *rqos, struct bio *bio) }while (rqos); } +void __rq_qos_queue_depth_changed (struct rq_qos *rqos) +{ +do { +if (rqos->ops->queue_depth_changed) + rqos->ops->queue_depth_changed (rqos); + rqos = rqos->next; + }while (rqos); +} +/* * Return true, if we can't increase the depth further by scaling */
block/blk-rq-qos.h +8 -0
@@ -41,6 +41,7 @@ struct rq_qos_ops {void (*done)(struct rq_qos *,struct request *);void (*done_bio)(struct rq_qos *,struct bio *);void (*cleanup)(struct rq_qos *,struct bio *); +void (*queue_depth_changed)(struct rq_qos *);void (*exit)(struct rq_qos *);const struct blk_mq_debugfs_attr *debugfs_attrs; };
@@ -138,6 +139,7 @@ void __rq_qos_throttle(struct rq_qos *rqos, struct bio *bio);void __rq_qos_track (struct rq_qos *rqos,struct request *rq,struct bio *bio);void __rq_qos_merge (struct rq_qos *rqos,struct request *rq,struct bio *bio);void __rq_qos_done_bio (struct rq_qos *rqos,struct bio *bio); +void __rq_qos_queue_depth_changed (struct rq_qos *rqos);static inline void rq_qos_cleanup (struct request_queue *q,struct bio *bio) {
@@ -194,6 +196,12 @@ static inline void rq_qos_merge(struct request_queue *q, struct request *rq, __rq_qos_merge(q->rq_qos, rq, bio); } +static inline void rq_qos_queue_depth_changed (struct request_queue *q) +{ +if (q->rq_qos) +__rq_qos_queue_depth_changed (q->rq_qos); +} +void rq_qos_exit (struct request_queue *);#endif
block/blk-settings.c +1 -1
@@ -804,7 +804,7 @@ EXPORT_SYMBOL(blk_queue_update_dma_alignment);void blk_set_queue_depth (struct request_queue *q,unsigned int depth) { q->queue_depth = depth; -wbt_set_queue_depth (q, depth); +rq_qos_queue_depth_changed (q); }EXPORT_SYMBOL (blk_set_queue_depth);
block/blk-wbt.c +8 -10
@@ -629,15 +629,6 @@ static void wbt_requeue(struct rq_qos *rqos, struct request *rq) } } -void wbt_set_queue_depth (struct request_queue *q,unsigned int depth) -{ -struct rq_qos *rqos =wbt_rq_qos (q); -if (rqos) { -RQWB (rqos)->rq_depth.queue_depth = depth; -__wbt_update_limits (RQWB (rqos)); - } -} -void wbt_set_write_cache (struct request_queue *q,bool write_cache_on) {struct rq_qos *rqos =wbt_rq_qos (q);
@@ -689,6 +680,12 @@ static int wbt_data_dir(const struct request *rq)return -1 ; } +static void wbt_queue_depth_changed (struct rq_qos *rqos) +{ +RQWB (rqos)->rq_depth.queue_depth =blk_queue_depth (rqos->q); +__wbt_update_limits (RQWB (rqos)); +} +static void wbt_exit (struct rq_qos *rqos) {struct rq_wb *rwb =RQWB (rqos);
@@ -811,6 +808,7 @@ static struct rq_qos_ops wbt_rqos_ops = { .requeue = wbt_requeue, .done = wbt_done, .cleanup = wbt_cleanup, + .queue_depth_changed = wbt_queue_depth_changed, .exit = wbt_exit, #ifdef CONFIG_BLK_DEBUG_FS .debugfs_attrs = wbt_debugfs_attrs,
@@ -853,7 +851,7 @@ int wbt_init(struct request_queue *q) rwb->min_lat_nsec =wbt_default_latency_nsec (q); -wbt_set_queue_depth (q,blk_queue_depth (q)); +wbt_queue_depth_changed (&rwb->rqos);wbt_set_write_cache (q,test_bit (QUEUE_FLAG_WC , &q->queue_flags));return 0 ;
block/blk-wbt.h +0 -4
@@ -95,7 +95,6 @@ void wbt_enable_default(struct request_queue *);u64 wbt_get_min_lat (struct request_queue *q);void wbt_set_min_lat (struct request_queue *q,u64 val); -void wbt_set_queue_depth (struct request_queue *,unsigned int );void wbt_set_write_cache (struct request_queue *,bool );u64 wbt_default_latency_nsec (struct request_queue *);
@@ -118,9 +117,6 @@ static inline void wbt_disable_default(struct request_queue *q)static inline void wbt_enable_default (struct request_queue *q) { } -static inline void wbt_set_queue_depth (struct request_queue *q,unsigned int depth) -{ -}static inline void wbt_set_write_cache (struct request_queue *q,bool wc) { }
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 6/10 blkcg: s/RQ_QOS_CGROUP/RQ_QOS_LATENCY/
In reply to Tejun Heoio.weight is gonna be another rq_qos cgroup mechanism. Let's rename RQ_QOS_CGROUP which is being used by io.latency to RQ_QOS_LATENCY in preparation.
--- block/blk-iolatency.c | 2 +- block/blk-rq-qos.h | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-)
block/blk-iolatency.c +1 -1
@@ -725,7 +725,7 @@ int blk_iolatency_init(struct request_queue *q)return -ENOMEM ; rqos = &blkiolat->rqos; - rqos->id =RQ_QOS_CGROUP ; + rqos->id =RQ_QOS_LATENCY ; rqos->ops = &blkcg_iolatency_ops; rqos->q = q;
block/blk-rq-qos.h +4 -4
@@ -14,7 +14,7 @@ struct blk_mq_debugfs_attr;enum rq_qos_id {RQ_QOS_WBT , -RQ_QOS_CGROUP , +RQ_QOS_LATENCY , };struct rq_wait {
@@ -74,7 +74,7 @@ static inline struct rq_qos *wbt_rq_qos(struct request_queue *q)static inline struct rq_qos *blkcg_rq_qos (struct request_queue *q) { -return rq_qos_id (q,RQ_QOS_CGROUP ); +return rq_qos_id (q,RQ_QOS_LATENCY ); }static inline const char *rq_qos_id_to_name (enum rq_qos_id id)
@@ -82,8 +82,8 @@ static inline const char *rq_qos_id_to_name(enum rq_qos_id id)switch (id) {case RQ_QOS_WBT :return "wbt" ; -case RQ_QOS_CGROUP : -return "cgroup" ; +case RQ_QOS_LATENCY : +return "latency" ; }return "unknown" ; }
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 7/10 blk-mq: add optional request->pre_start_time_ns
In reply to Tejun HeoThere are currently two start time timestamps - start_time_ns and io_start_time_ns. The former marks the request allocation and and the second issue-to-device time. The planned io.weight controller needs to measure the total time bios take to execute after it leaves rq_qos including the time spent waiting for request to become available, which can easily dominate on saturated devices.
This patch adds request->pre_start_time_ns which records when the request allocation attempt started. As it isn't used for the usual stats, make it optional behind QUEUE_FLAG_REC_PRESTART.
--- block/blk-mq.c | 11 +++++++++-- include/linux/blkdev.h | 7 ++++++- 2 files changed, 15 insertions(+), 3 deletions(-)
block/blk-mq.c +9 -2
@@ -291,7 +291,7 @@ static inline bool blk_mq_need_time_stamp(struct request *rq) }static struct request *blk_mq_rq_ctx_init (struct blk_mq_alloc_data *data, -unsigned int tag,unsigned int op) +unsigned int tag,unsigned int op,u64 pre_start_time_ns) {struct blk_mq_tags *tags =blk_mq_tags_from_data (data);struct request *rq = tags->static_rqs[tag];
@@ -325,6 +325,7 @@ static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,RB_CLEAR_NODE (&rq->rb_node); rq->rq_disk =NULL ; rq->part =NULL ; + rq->pre_start_time_ns = pre_start_time_ns;if (blk_mq_need_time_stamp (rq)) rq->start_time_ns =ktime_get_ns ();else
@@ -356,8 +357,14 @@ static struct request *blk_mq_get_request(struct request_queue *q,struct request *rq;unsigned int tag;bool clear_ctx_on_error = false; +u64 pre_start_time_ns =0 ;blk_queue_enter_live (q); + +/* pre_start_time includes depth and tag waits */ +if (blk_queue_rec_prestart (q)) + pre_start_time_ns =ktime_get_ns (); + data->q = q;if (likely (!data->ctx)) { data->ctx =blk_mq_get_ctx (q);
@@ -393,7 +400,7 @@ static struct request *blk_mq_get_request(struct request_queue *q,return NULL ; } - rq =blk_mq_rq_ctx_init (data, tag, data->cmd_flags); + rq =blk_mq_rq_ctx_init (data, tag, data->cmd_flags, pre_start_time_ns);if (!op_is_flush (data->cmd_flags)) { rq->elv.icq =NULL ;if (e && e->type->ops.prepare_request) {
include/linux/blkdev.h +6 -1
@@ -194,7 +194,9 @@ struct request {struct gendisk *rq_disk;struct hd_struct *part; -/* Time that I/O was submitted to the kernel. */ +/* Time that the first bio started allocating this request. */ +u64 pre_start_time_ns; +/* Time that this request was allocated for this IO. */ u64 start_time_ns;/* Time that I/O was submitted to the device. */ u64 io_start_time_ns;
@@ -606,6 +608,7 @@ struct request_queue {#define QUEUE_FLAG_SCSI_PASSTHROUGH 23/* queue supports SCSI commands */ #define QUEUE_FLAG_QUIESCED 24/* queue has been quiesced */ #define QUEUE_FLAG_PCI_P2PDMA 25/* device supports PCI p2p requests */ +#define QUEUE_FLAG_REC_PRESTART 26/* record pre_start_time_ns */ #define QUEUE_FLAG_MQ_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \ (1 << QUEUE_FLAG_SAME_COMP))
@@ -632,6 +635,8 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); test_bit(QUEUE_FLAG_SCSI_PASSTHROUGH, &(q)->queue_flags)#define blk_queue_pci_p2pdma (q) \ test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags) +#define blk_queue_rec_prestart (q) \ + test_bit(QUEUE_FLAG_REC_PRESTART, &(q)->queue_flags)#define blk_noretry_request (rq) \ ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 8/10 blkcg: implement blk-iocost
In reply to Tejun HeoThis patchset implements IO cost model based work-conserving proportional controller.
While io.latency provides the capability to comprehensively prioritize and protect IOs depending on the cgroups, its protection is binary - the lowest latency target cgroup which is suffering is protected at the cost of all others. In many use cases including stacking multiple workload containers in a single system, it's necessary to distribute IO capacity with better granularity.
One challenge of controlling IO resources is the lack of trivially observable cost metric. The most common metrics - bandwidth and iops
- can be off by orders of magnitude depending on the device type and IO pattern. However, the cost isn't a complete mystery. Given several key attributes, we can make fairly reliable predictions on how expensive a given stream of IOs would be, at least compared to other IO patterns.
The function which determines the cost of a given IO is the IO cost model for the device. This controller distributes IO capacity based on the costs estimated by such model. The more accurate the cost model the better but the controller adapts based on IO completion latency and as long as the relative costs across differents IO patterns are consistent and sensible, it'll adapt to the actual performance of the device.
Currently, the only implemented cost model is a simple linear one with a few sets of default parameters for different classes of device. This covers most common devices reasonably well. All the infrastructure to tune and add different cost models is already in place and a later patch will also allow using bpf progs for cost models.
Please see the top comment in blk-iocost.c and documentation for more details.
--- Documentation/admin-guide/cgroup-v2.rst | 94 + block/Kconfig | 9 + block/Makefile | 1 + block/blk-iocost.c | 2370 +++++++++++++++++++++++ block/blk-rq-qos.h | 3 + include/linux/blk_types.h | 3 + include/trace/events/iocost.h | 174 ++ 7 files changed, 2654 insertions(+) create mode 100644 block/blk-iocost.c create mode 100644 include/trace/events/iocost.h
Documentation/admin-guide/cgroup-v2.rst +94 -0
@@ -1425,6 +1425,100 @@ IO Interface Files 8:16 rbytes=1459200 wbytes=314773504 rios=192 wios=353 dbytes=0 dios=0 8:0 rbytes=90430464 wbytes=299008000 rios=8950 wios=1252 dbytes=50331648 dios=3021 + io.cost.qos + A read-write nested-keyed file with exists only on the root + cgroup. + + This file configures the Quality of Service of the IO cost + model based controller (CONFIG_BLK_CGROUP_IOCOST) which + currently implements "io.weight" proportional control. Lines + are keyed by $MAJ:$MIN device numbers and not ordered. The + line for a given device is populated on the first write for + the device on "io.cost.qos" or "io.cost.model". The following + nested keys are defined. + + ====== ===================================== + enable Weight-based control enable + ctrl "auto" or "user" + rpct Read latency percentile [0, 100] + rlat Read latency threshold + wpct Write latency percentile [0, 100] + wlat Write latency threshold + min Minimum scaling percentage [1, 10000] + max Maximum scaling percentage [1, 10000] + ====== ===================================== + + The controller is disabled by default and can be enabled by + setting "enable" to 1. "rpct" and "wpct" parameters default + to zero and the controller uses internal device saturation + state to adjust the overall IO rate between "min" and "max". + + When a better control quality is needed, latency QoS + parameters can be configured. For example:: + + 8:16 enable=1 ctrl=auto rpct=95.00 rlat=75000 wpct=95.00 wlat=150000 min=50.00 max=150.0 + + shows that on sdb, the controller is enabled, will consider + the device saturated if the 95th percentile of read completion + latencies is above 75ms or write 150ms, and adjust the overall + IO issue rate between 50% and 150% accordingly. + + The lower the saturation point, the better the latency QoS at + the cost of aggregate bandwidth. The narrower the allowed + adjustment range between "min" and "max", the more conformant + to the cost model the IO behavior. Note that the IO issue + base rate may be far off from 100% and setting "min" and "max" + blindly can lead to a significant loss of device capacity or + control quality. "min" and "max" are useful for regulating + devices which show wide temporary behavior changes - e.g. a + ssd which accepts writes at the line speed for a while and + then completely stalls for multiple seconds. + + When "ctrl" is "auto", the parameters are controlled by the + kernel and may change automatically. Setting "ctrl" to "user" + or setting any of the percentile and latency parameters puts + it into "user" mode and disables the automatic changes. The + automatic mode can be restored by setting "ctrl" to "auto". + + io.cost.model + A read-write nested-keyed file with exists only on the root + cgroup. + + This file configures the cost model of the IO cost model based + controller (CONFIG_BLK_CGROUP_IOCOST) which currently + implements "io.weight" proportional control. Lines are keyed + by $MAJ:$MIN device numbers and not ordered. The line for a + given device is populated on the first write for the device on + "io.cost.qos" or "io.cost.model". The following nested keys + are defined. + + ===== ================================ + ctrl "auto" or "user" + model The cost model in use - "linear" + ===== ================================ + + When "ctrl" is "auto", the kernel may change all parameters + dynamically. When "ctrl" is set to "user" or any other + parameters are written to, "ctrl" become "user" and the + automatic changes are disabled. + + When "model" is "linear", the following model parameters are + defined. + + ============= ======================================== + [r|w]bps The maximum sequential IO throughput + [r|w]seqiops The maximum 4k sequential IOs per second + [r|w]randiops The maximum 4k random IOs per second + ============= ======================================== + + From the above, the builtin linear model determines the base + costs of a sequential and random IO and the cost coefficient + for the IO size. While simple, this model can cover most + common device classes acceptably. + + The IO cost model isn't expected to be accurate in absolute + sense and is scaled to the device behavior dynamically. + io.weight A read-write flat-keyed file which exists on non-root cgroups. The default is "default 100".
block/Kconfig +9 -0
@@ -132,6 +132,15 @@ config BLK_CGROUP_IOLATENCY Note, this is an experimental interface and could be changed someday. +config BLK_CGROUP_IOCOST + bool "Enable support for cost model based cgroup IO controller" + depends on BLK_CGROUP=y + ---help--- + Enabling this option enables the .weight interface for cost + model based proportional IO control. The IO controller + distributes IO capacity between different groups based on + their share of the overall weight distribution. + config BLK_WBT_MQ bool "Multiqueue writeback throttling" default y
block/Makefile +1 -0
@@ -18,6 +18,7 @@ obj-$(CONFIG_BLK_DEV_BSGLIB) += bsg-lib.o obj-$(CONFIG_BLK_CGROUP) += blk-cgroup.o obj-$(CONFIG_BLK_DEV_THROTTLING) += blk-throttle.o obj-$(CONFIG_BLK_CGROUP_IOLATENCY) += blk-iolatency.o +obj-$(CONFIG_BLK_CGROUP_IOCOST) += blk-iocost.o obj-$(CONFIG_MQ_IOSCHED_DEADLINE) += mq-deadline.o obj-$(CONFIG_MQ_IOSCHED_KYBER) += kyber-iosched.o bfq-y := bfq-iosched.o bfq-wf2q.o bfq-cgroup.o
block/blk-iocost.c new file +2370 -0
2,370 lines not on this page · raw message
block/blk-rq-qos.h +3 -0
@@ -15,6 +15,7 @@ struct blk_mq_debugfs_attr;enum rq_qos_id {RQ_QOS_WBT ,RQ_QOS_LATENCY , +RQ_QOS_COST , };struct rq_wait {
@@ -84,6 +85,8 @@ static inline const char *rq_qos_id_to_name(enum rq_qos_id id)return "wbt" ;case RQ_QOS_LATENCY :return "latency" ; +case RQ_QOS_COST : +return "cost" ; }return "unknown" ; }
include/linux/blk_types.h +3 -0
@@ -169,6 +169,9 @@ struct bio {*/ struct blkcg_gq *bi_blkg;struct bio_issue bi_issue; +#ifdef CONFIG_BLK_CGROUP_IOCOST +u64 bi_iocost_cost; +#endif #endif union {#if defined(CONFIG_BLK_DEV_INTEGRITY )
include/trace/events/iocost.h new file +174 -0
174 lines not on this page · raw message
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 9/10 blkcg: add tools/cgroup/iocost_monitor.py
In reply to Tejun HeoInstead of mucking with debugfs and ->pd_stat(), add drgn based monitoring script.
--- block/blk-iocost.c | 21 +++ tools/cgroup/iocost_monitor.py | 270 +++++++++++++++++++++++++++++++++ 2 files changed, 291 insertions(+) create mode 100644 tools/cgroup/iocost_monitor.py
block/blk-iocost.c +21 -0
@@ -149,6 +149,27 @@* donate and should take back how much requires hweight propagations * anyway making it easier to implement and understand as a separate * mechanism. +* +* 3. Monitoring +* +* Instead of debugfs or other clumsy monitoring mechanisms, this +* controller uses a drgn based monitoring script - +* tools/cgroup/iocost_monitor.py. For details on drgn, please see +* https://github.com/osandov/drgn. The ouput looks like the following. +* +* sdb RUN per=300ms cur_per=234.218:v203.695 busy= +1 vrate= 62.12% +* active weight hweight% inflt% del_ms usages% +* test/a * 50/ 50 33.33/ 33.33 27.65 0*041 033:033:033 +* test/b * 100/ 100 66.67/ 66.67 17.56 0*000 066:079:077 +* +* - per : Timer period +* - cur_per : Internal wall and device vtime clock +* - vrate : Device virtual time rate against wall clock +* - weight : Surplus-adjusted and configured weights +* - hweight : Surplus-adjusted and configured hierarchical weights +* - inflt : The percentage of in-flight IO cost at the end of last period +* - del_ms : Deferred issuer delay induction level and duration +* - usages : Usage history */ #include <linux/kernel.h>
tools/cgroup/iocost_monitor.py new file +270 -0
270 lines not on this page · raw message
Signature · 1 line
2.17.1
Tejun Heo
maintainerPATCH 10/10 blkcg: add tools/cgroup/iocost_coef_gen.py
In reply to Tejun HeoAdd a script which can be used to generate device-specific iocost linear model coefficients.
--- Documentation/admin-guide/cgroup-v2.rst | 3 + block/blk-iocost.c | 3 + tools/cgroup/iocost_coef_gen.py | 178 ++++++++++++++++++++++++ 3 files changed, 184 insertions(+) create mode 100644 tools/cgroup/iocost_coef_gen.py
Documentation/admin-guide/cgroup-v2.rst +3 -0
@@ -1519,6 +1519,9 @@ IO Interface Files The IO cost model isn't expected to be accurate in absolute sense and is scaled to the device behavior dynamically. + If needed, tools/cgroup/iocost_coef_gen.py can be used to + generate device-specific coefficients. + io.weight A read-write flat-keyed file which exists on non-root cgroups. The default is "default 100".
block/blk-iocost.c +3 -0
@@ -46,6 +46,9 @@* If needed, tools/cgroup/iocost_coef_gen.py can be used to generate * device-specific coefficients. * +* If needed, tools/cgroup/iocost_coef_gen.py can be used to generate +* device-specific coefficients. +* * 2. Control Strategy * * The device virtual time (vtime) is used as the primary control metric.
tools/cgroup/iocost_coef_gen.py new file +178 -0
178 lines not on this page · raw message
Signature · 1 line
2.17.1
Tejun Heo
maintainer[PATCH 11/10] block: omit request->pre_start_time_ns if !CONFIG_BLK_CGROUP_IOCOST work-conserving porportional controller
In reply to Tejun HeoFrom e2693136fa64d5c9dde73d2d663bde84f8326877 Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 10 Jul 2019 14:18:12 -0700
request->pre_start_time is currently only used by the iocost controller. Let's omit the field if disabled and avoid wasting space in struct request.
---
The git branch is updated accordingly.
Thanks.
block/blk-mq.c | 2 ++ include/linux/blkdev.h | 7 +++++++ 2 files changed, 9 insertions(+)
block/blk-mq.c +2 -0
@@ -325,7 +325,9 @@ static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data,RB_CLEAR_NODE (&rq->rb_node); rq->rq_disk =NULL ; rq->part =NULL ; +#ifdef CONFIG_BLK_CGROUP_IOCOST rq->pre_start_time_ns = pre_start_time_ns; +#endif if (blk_mq_need_time_stamp (rq)) rq->start_time_ns =ktime_get_ns ();else
include/linux/blkdev.h +7 -0
@@ -194,8 +194,10 @@ struct request {struct gendisk *rq_disk;struct hd_struct *part; +#ifdef CONFIG_BLK_CGROUP_IOCOST /* Time that the first bio started allocating this request. */ u64 pre_start_time_ns; +#endif /* Time that this request was allocated for this IO. */ u64 start_time_ns;/* Time that I/O was submitted to the device. */
@@ -635,8 +637,13 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); test_bit(QUEUE_FLAG_SCSI_PASSTHROUGH, &(q)->queue_flags)#define blk_queue_pci_p2pdma (q) \ test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags) + +#ifdef CONFIG_BLK_CGROUP_IOCOST #define blk_queue_rec_prestart (q) \ test_bit(QUEUE_FLAG_REC_PRESTART, &(q)->queue_flags) +#else +#define blk_queue_rec_prestart (q) false +#endif #define blk_noretry_request (rq) \ ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
Signature · 1 line
2.17.1