From: "Darrick J. Wong" <darrick.wong@oracle.com>
To: Dave Chinner <david@fromorbit.com>, Brian Foster <bfoster@redhat.com>
Cc: linux-xfs@vger.kernel.org
Subject: Re: [PATCH 2/8] xfs: Throttle commits on delayed background CIL push
Date: Wed, 25 Mar 2020 22:24:35 -0700 [thread overview]
Message-ID: <20200326052435.GK29351@magnolia> (raw)
In-Reply-To: <20200325014205.11843-3-david@fromorbit.com>
On Wed, Mar 25, 2020 at 12:41:59PM +1100, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
>
> In certain situations the background CIL push can be indefinitely
> delayed. While we have workarounds from the obvious cases now, it
> doesn't solve the underlying issue. This issue is that there is no
> upper limit on the CIL where we will either force or wait for
> a background push to start, hence allowing the CIL to grow without
> bound until it consumes all log space.
>
> To fix this, add a new wait queue to the CIL which allows background
> pushes to wait for the CIL context to be switched out. This happens
> when the push starts, so it will allow us to block incoming
> transaction commit completion until the push has started. This will
> only affect processes that are running modifications, and only when
> the CIL threshold has been significantly overrun.
>
> This has no apparent impact on performance, and doesn't even trigger
> until over 45 million inodes had been created in a 16-way fsmark
> test on a 2GB log. That was limiting at 64MB of log space used, so
> the active CIL size is only about 3% of the total log in that case.
> The concurrent removal of those files did not trigger the background
> sleep at all.
>
> Signed-off-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Brian Foster <bfoster@redhat.com>
This looks reasonable to me, though considering the big long thread that
erupted a few versions ago I'm seriously wondering what he thinks of all
this?
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/xfs_log_cil.c | 37 +++++++++++++++++++++++++++++++++----
> fs/xfs/xfs_log_priv.h | 24 ++++++++++++++++++++++++
> fs/xfs/xfs_trace.h | 1 +
> 3 files changed, 58 insertions(+), 4 deletions(-)
>
> diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
> index 27de462d2ba40..ac43301ae2f43 100644
> --- a/fs/xfs/xfs_log_cil.c
> +++ b/fs/xfs/xfs_log_cil.c
> @@ -668,6 +668,11 @@ xlog_cil_push_work(
> push_seq = cil->xc_push_seq;
> ASSERT(push_seq <= ctx->sequence);
>
> + /*
> + * Wake up any background push waiters now this context is being pushed.
> + */
> + wake_up_all(&ctx->push_wait);
> +
> /*
> * Check if we've anything to push. If there is nothing, then we don't
> * move on to a new sequence number and so we have to be able to push
> @@ -744,6 +749,7 @@ xlog_cil_push_work(
> */
> INIT_LIST_HEAD(&new_ctx->committing);
> INIT_LIST_HEAD(&new_ctx->busy_extents);
> + init_waitqueue_head(&new_ctx->push_wait);
> new_ctx->sequence = ctx->sequence + 1;
> new_ctx->cil = cil;
> cil->xc_ctx = new_ctx;
> @@ -891,7 +897,7 @@ xlog_cil_push_work(
> */
> static void
> xlog_cil_push_background(
> - struct xlog *log)
> + struct xlog *log) __releases(cil->xc_ctx_lock)
> {
> struct xfs_cil *cil = log->l_cilp;
>
> @@ -905,14 +911,36 @@ xlog_cil_push_background(
> * don't do a background push if we haven't used up all the
> * space available yet.
> */
> - if (cil->xc_ctx->space_used < XLOG_CIL_SPACE_LIMIT(log))
> + if (cil->xc_ctx->space_used < XLOG_CIL_SPACE_LIMIT(log)) {
> + up_read(&cil->xc_ctx_lock);
> return;
> + }
>
> spin_lock(&cil->xc_push_lock);
> if (cil->xc_push_seq < cil->xc_current_sequence) {
> cil->xc_push_seq = cil->xc_current_sequence;
> queue_work(log->l_mp->m_cil_workqueue, &cil->xc_push_work);
> }
> +
> + /*
> + * Drop the context lock now, we can't hold that if we need to sleep
> + * because we are over the blocking threshold. The push_lock is still
> + * held, so blocking threshold sleep/wakeup is still correctly
> + * serialised here.
> + */
> + up_read(&cil->xc_ctx_lock);
> +
> + /*
> + * If we are well over the space limit, throttle the work that is being
> + * done until the push work on this context has begun.
> + */
> + if (cil->xc_ctx->space_used >= XLOG_CIL_BLOCKING_SPACE_LIMIT(log)) {
> + trace_xfs_log_cil_wait(log, cil->xc_ctx->ticket);
> + ASSERT(cil->xc_ctx->space_used < log->l_logsize);
> + xlog_wait(&cil->xc_ctx->push_wait, &cil->xc_push_lock);
> + return;
> + }
> +
> spin_unlock(&cil->xc_push_lock);
>
> }
> @@ -1032,9 +1060,9 @@ xfs_log_commit_cil(
> if (lip->li_ops->iop_committing)
> lip->li_ops->iop_committing(lip, xc_commit_lsn);
> }
> - xlog_cil_push_background(log);
>
> - up_read(&cil->xc_ctx_lock);
> + /* xlog_cil_push_background() releases cil->xc_ctx_lock */
> + xlog_cil_push_background(log);
> }
>
> /*
> @@ -1193,6 +1221,7 @@ xlog_cil_init(
>
> INIT_LIST_HEAD(&ctx->committing);
> INIT_LIST_HEAD(&ctx->busy_extents);
> + init_waitqueue_head(&ctx->push_wait);
> ctx->sequence = 1;
> ctx->cil = cil;
> cil->xc_ctx = ctx;
> diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
> index 8c4be91f62d0d..dacab1817a1b0 100644
> --- a/fs/xfs/xfs_log_priv.h
> +++ b/fs/xfs/xfs_log_priv.h
> @@ -240,6 +240,7 @@ struct xfs_cil_ctx {
> struct xfs_log_vec *lv_chain; /* logvecs being pushed */
> struct list_head iclog_entry;
> struct list_head committing; /* ctx committing list */
> + wait_queue_head_t push_wait; /* background push throttle */
> struct work_struct discard_endio_work;
> };
>
> @@ -337,10 +338,33 @@ struct xfs_cil {
> * buffer window (32MB) as measurements have shown this to be roughly the
> * point of diminishing performance increases under highly concurrent
> * modification workloads.
> + *
> + * To prevent the CIL from overflowing upper commit size bounds, we introduce a
> + * new threshold at which we block committing transactions until the background
> + * CIL commit commences and switches to a new context. While this is not a hard
> + * limit, it forces the process committing a transaction to the CIL to block and
> + * yeild the CPU, giving the CIL push work a chance to be scheduled and start
> + * work. This prevents a process running lots of transactions from overfilling
> + * the CIL because it is not yielding the CPU. We set the blocking limit at
> + * twice the background push space threshold so we keep in line with the AIL
> + * push thresholds.
> + *
> + * Note: this is not a -hard- limit as blocking is applied after the transaction
> + * is inserted into the CIL and the push has been triggered. It is largely a
> + * throttling mechanism that allows the CIL push to be scheduled and run. A hard
> + * limit will be difficult to implement without introducing global serialisation
> + * in the CIL commit fast path, and it's not at all clear that we actually need
> + * such hard limits given the ~7 years we've run without a hard limit before
> + * finding the first situation where a checkpoint size overflow actually
> + * occurred. Hence the simple throttle, and an ASSERT check to tell us that
> + * we've overrun the max size.
> */
> #define XLOG_CIL_SPACE_LIMIT(log) \
> min_t(int, (log)->l_logsize >> 3, BBTOB(XLOG_TOTAL_REC_SHIFT(log)) << 4)
>
> +#define XLOG_CIL_BLOCKING_SPACE_LIMIT(log) \
> + (XLOG_CIL_SPACE_LIMIT(log) * 2)
> +
> /*
> * ticket grant locks, queues and accounting have their own cachlines
> * as these are quite hot and can be operated on concurrently.
> diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
> index fbfdd9cf160df..575ca74532f79 100644
> --- a/fs/xfs/xfs_trace.h
> +++ b/fs/xfs/xfs_trace.h
> @@ -1015,6 +1015,7 @@ DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_sub);
> DEFINE_LOGGRANT_EVENT(xfs_log_ticket_done);
> DEFINE_LOGGRANT_EVENT(xfs_log_ticket_done_sub);
> DEFINE_LOGGRANT_EVENT(xfs_log_ticket_done_exit);
> +DEFINE_LOGGRANT_EVENT(xfs_log_cil_wait);
>
> DECLARE_EVENT_CLASS(xfs_log_item_class,
> TP_PROTO(struct xfs_log_item *lip),
> --
> 2.26.0.rc2
>
next prev parent reply other threads:[~2020-03-26 5:26 UTC|newest]
Thread overview: 28+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-03-25 1:41 [PATCH 0/8] xfs: various fixes and cleanups Dave Chinner
2020-03-25 1:41 ` [PATCH 1/8] xfs: Lower CIL flush limit for large logs Dave Chinner
2020-03-25 4:42 ` Allison Collins
2020-03-25 1:41 ` [PATCH 2/8] xfs: Throttle commits on delayed background CIL push Dave Chinner
2020-03-25 4:42 ` Allison Collins
2020-03-25 5:07 ` Dave Chinner
2020-03-26 5:24 ` Darrick J. Wong [this message]
2020-03-26 11:33 ` Brian Foster
2020-03-27 0:40 ` Dave Chinner
2020-03-25 1:42 ` [PATCH 3/8] xfs: don't allow log IO to be throttled Dave Chinner
2020-03-25 4:42 ` Allison Collins
2020-03-25 1:42 ` [PATCH 4/8] xfs: Improve metadata buffer reclaim accountability Dave Chinner
2020-03-25 4:42 ` Allison Collins
2020-03-25 13:30 ` Brian Foster
2020-03-26 5:05 ` Darrick J. Wong
2020-03-25 1:42 ` [PATCH 5/8] xfs: correctly acount for reclaimable slabs Dave Chinner
2020-03-25 4:43 ` Allison Collins
2020-03-25 1:42 ` [PATCH 6/8] xfs: factor common AIL item deletion code Dave Chinner
2020-03-25 4:54 ` Allison Collins
2020-03-25 13:30 ` Brian Foster
2020-03-26 5:10 ` Darrick J. Wong
2020-03-27 0:50 ` Dave Chinner
2020-03-25 1:42 ` [PATCH 7/8] xfs: tail updates only need to occur when LSN changes Dave Chinner
2020-03-25 5:10 ` Allison Collins
2020-03-26 5:14 ` Darrick J. Wong
2020-03-25 1:42 ` [PATCH 8/8] xfs: factor inode lookup from xfs_ifree_cluster Dave Chinner
2020-03-25 13:30 ` Brian Foster
2020-03-25 1:51 ` [PATCH 0/8] xfs: various fixes and cleanups Dave Chinner
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200326052435.GK29351@magnolia \
--to=darrick.wong@oracle.com \
--cc=bfoster@redhat.com \
--cc=david@fromorbit.com \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).