2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
|
2008-10-30 00:39:23 -06:00
|
|
|
* Copyright (c) 2008 Dave Chinner
|
2005-11-01 20:58:39 -07:00
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_fs.h"
|
2014-11-27 20:25:04 -07:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_trans_priv.h"
|
2011-10-11 09:14:11 -06:00
|
|
|
#include "xfs_trace.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_error.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* Check that the list is sorted as it should be.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_ail_check(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
xfs_log_item_t *lip)
|
|
|
|
{
|
|
|
|
xfs_log_item_t *prev_lip;
|
|
|
|
|
|
|
|
if (list_empty(&ailp->xa_ail))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the next and previous entries are valid.
|
|
|
|
*/
|
|
|
|
ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0);
|
|
|
|
prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail);
|
|
|
|
if (&prev_lip->li_ail != &ailp->xa_ail)
|
|
|
|
ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0);
|
|
|
|
|
|
|
|
prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail);
|
|
|
|
if (&prev_lip->li_ail != &ailp->xa_ail)
|
|
|
|
ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0);
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
#else /* !DEBUG */
|
2008-02-04 18:13:38 -07:00
|
|
|
#define xfs_ail_check(a,l)
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* DEBUG */
|
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
2011-04-07 20:45:07 -06:00
|
|
|
* Return a pointer to the last item in the AIL. If the AIL is empty, then
|
|
|
|
* return NULL.
|
|
|
|
*/
|
|
|
|
static xfs_log_item_t *
|
|
|
|
xfs_ail_max(
|
|
|
|
struct xfs_ail *ailp)
|
|
|
|
{
|
|
|
|
if (list_empty(&ailp->xa_ail))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail);
|
|
|
|
}
|
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* Return a pointer to the item which follows the given item in the AIL. If
|
|
|
|
* the given item is the last item in the list, then return NULL.
|
|
|
|
*/
|
|
|
|
static xfs_log_item_t *
|
|
|
|
xfs_ail_next(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
xfs_log_item_t *lip)
|
|
|
|
{
|
|
|
|
if (lip->li_ail.next == &ailp->xa_ail)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2011-04-07 20:45:07 -06:00
|
|
|
* This is called by the log manager code to determine the LSN of the tail of
|
|
|
|
* the log. This is exactly the LSN of the first item in the AIL. If the AIL
|
|
|
|
* is empty, then this function returns 0.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2011-04-07 20:45:07 -06:00
|
|
|
* We need the AIL lock in order to get a coherent read of the lsn of the last
|
|
|
|
* item in the AIL.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
xfs_lsn_t
|
2011-04-07 20:45:07 -06:00
|
|
|
xfs_ail_min_lsn(
|
2008-10-30 00:39:00 -06:00
|
|
|
struct xfs_ail *ailp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-04-07 20:45:07 -06:00
|
|
|
xfs_lsn_t lsn = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_log_item_t *lip;
|
|
|
|
|
2008-10-30 00:39:23 -06:00
|
|
|
spin_lock(&ailp->xa_lock);
|
2008-10-30 00:39:00 -06:00
|
|
|
lip = xfs_ail_min(ailp);
|
2011-04-07 20:45:07 -06:00
|
|
|
if (lip)
|
2005-04-16 16:20:36 -06:00
|
|
|
lsn = lip->li_lsn;
|
2008-10-30 00:39:23 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return lsn;
|
|
|
|
}
|
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* Return the maximum lsn held in the AIL, or zero if the AIL is empty.
|
|
|
|
*/
|
|
|
|
static xfs_lsn_t
|
|
|
|
xfs_ail_max_lsn(
|
|
|
|
struct xfs_ail *ailp)
|
|
|
|
{
|
|
|
|
xfs_lsn_t lsn = 0;
|
|
|
|
xfs_log_item_t *lip;
|
|
|
|
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_ail_max(ailp);
|
|
|
|
if (lip)
|
|
|
|
lsn = lip->li_lsn;
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return lsn;
|
|
|
|
}
|
|
|
|
|
2008-10-30 00:38:39 -06:00
|
|
|
/*
|
2011-07-17 21:40:18 -06:00
|
|
|
* The cursor keeps track of where our current traversal is up to by tracking
|
|
|
|
* the next item in the list for us. However, for this to be safe, removing an
|
|
|
|
* object from the AIL needs to invalidate any cursor that points to it. hence
|
|
|
|
* the traversal cursor needs to be linked to the struct xfs_ail so that
|
|
|
|
* deletion can search all the active cursors for invalidation.
|
2008-10-30 00:38:39 -06:00
|
|
|
*/
|
2008-10-30 00:39:00 -06:00
|
|
|
STATIC void
|
2008-10-30 00:38:39 -06:00
|
|
|
xfs_trans_ail_cursor_init(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_ail_cursor *cur)
|
|
|
|
{
|
|
|
|
cur->item = NULL;
|
2011-07-17 21:40:18 -06:00
|
|
|
list_add_tail(&cur->list, &ailp->xa_cursors);
|
2008-10-30 00:38:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-17 21:40:18 -06:00
|
|
|
* Get the next item in the traversal and advance the cursor. If the cursor
|
|
|
|
* was invalidated (indicated by a lip of 1), restart the traversal.
|
2008-10-30 00:38:39 -06:00
|
|
|
*/
|
2008-10-30 00:39:00 -06:00
|
|
|
struct xfs_log_item *
|
2008-10-30 00:38:39 -06:00
|
|
|
xfs_trans_ail_cursor_next(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_ail_cursor *cur)
|
|
|
|
{
|
|
|
|
struct xfs_log_item *lip = cur->item;
|
|
|
|
|
2015-06-21 17:43:32 -06:00
|
|
|
if ((uintptr_t)lip & 1)
|
2008-10-30 00:38:39 -06:00
|
|
|
lip = xfs_ail_min(ailp);
|
2011-07-17 21:40:17 -06:00
|
|
|
if (lip)
|
|
|
|
cur->item = xfs_ail_next(ailp, lip);
|
2008-10-30 00:38:39 -06:00
|
|
|
return lip;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-17 21:40:18 -06:00
|
|
|
* When the traversal is complete, we need to remove the cursor from the list
|
|
|
|
* of traversing cursors.
|
2008-10-30 00:38:39 -06:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_ail_cursor_done(
|
2011-07-17 21:40:18 -06:00
|
|
|
struct xfs_ail_cursor *cur)
|
2008-10-30 00:38:39 -06:00
|
|
|
{
|
2011-07-17 21:40:18 -06:00
|
|
|
cur->item = NULL;
|
|
|
|
list_del_init(&cur->list);
|
2008-10-30 00:38:39 -06:00
|
|
|
}
|
|
|
|
|
2008-10-30 00:39:00 -06:00
|
|
|
/*
|
2011-07-17 21:40:18 -06:00
|
|
|
* Invalidate any cursor that is pointing to this item. This is called when an
|
|
|
|
* item is removed from the AIL. Any cursor pointing to this object is now
|
|
|
|
* invalid and the traversal needs to be terminated so it doesn't reference a
|
|
|
|
* freed object. We set the low bit of the cursor item pointer so we can
|
|
|
|
* distinguish between an invalidation and the end of the list when getting the
|
|
|
|
* next item from the cursor.
|
2008-10-30 00:39:00 -06:00
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_ail_cursor_clear(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_ail_cursor *cur;
|
|
|
|
|
2011-07-17 21:40:18 -06:00
|
|
|
list_for_each_entry(cur, &ailp->xa_cursors, list) {
|
2008-10-30 00:39:00 -06:00
|
|
|
if (cur->item == lip)
|
|
|
|
cur->item = (struct xfs_log_item *)
|
2015-06-21 17:43:32 -06:00
|
|
|
((uintptr_t)cur->item | 1);
|
2008-10-30 00:39:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
/*
|
2011-07-17 21:40:17 -06:00
|
|
|
* Find the first item in the AIL with the given @lsn by searching in ascending
|
|
|
|
* LSN order and initialise the cursor to point to the next item for a
|
|
|
|
* ascending traversal. Pass a @lsn of zero to initialise the cursor to the
|
|
|
|
* first item in the AIL. Returns NULL if the list is empty.
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
*/
|
2008-10-30 00:39:00 -06:00
|
|
|
xfs_log_item_t *
|
|
|
|
xfs_trans_ail_cursor_first(
|
2008-10-30 00:38:39 -06:00
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_ail_cursor *cur,
|
|
|
|
xfs_lsn_t lsn)
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
{
|
2008-10-30 00:38:39 -06:00
|
|
|
xfs_log_item_t *lip;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
|
2008-10-30 00:39:00 -06:00
|
|
|
xfs_trans_ail_cursor_init(ailp, cur);
|
2011-07-17 21:40:17 -06:00
|
|
|
|
|
|
|
if (lsn == 0) {
|
|
|
|
lip = xfs_ail_min(ailp);
|
2008-10-30 00:39:00 -06:00
|
|
|
goto out;
|
2011-07-17 21:40:17 -06:00
|
|
|
}
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
|
2008-10-30 00:38:39 -06:00
|
|
|
list_for_each_entry(lip, &ailp->xa_ail, li_ail) {
|
2008-10-30 00:39:00 -06:00
|
|
|
if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0)
|
2008-10-30 01:26:51 -06:00
|
|
|
goto out;
|
2008-03-27 00:58:27 -06:00
|
|
|
}
|
2011-07-17 21:40:17 -06:00
|
|
|
return NULL;
|
|
|
|
|
2008-10-30 00:39:00 -06:00
|
|
|
out:
|
2011-07-17 21:40:17 -06:00
|
|
|
if (lip)
|
|
|
|
cur->item = xfs_ail_next(ailp, lip);
|
2008-10-30 00:39:00 -06:00
|
|
|
return lip;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
}
|
|
|
|
|
2011-07-17 21:40:16 -06:00
|
|
|
static struct xfs_log_item *
|
|
|
|
__xfs_trans_ail_cursor_last(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
xfs_log_item_t *lip;
|
|
|
|
|
|
|
|
list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) {
|
|
|
|
if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0)
|
|
|
|
return lip;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-17 21:40:17 -06:00
|
|
|
* Find the last item in the AIL with the given @lsn by searching in descending
|
|
|
|
* LSN order and initialise the cursor to point to that item. If there is no
|
|
|
|
* item with the value of @lsn, then it sets the cursor to the last item with an
|
|
|
|
* LSN lower than @lsn. Returns NULL if the list is empty.
|
2011-07-17 21:40:16 -06:00
|
|
|
*/
|
|
|
|
struct xfs_log_item *
|
|
|
|
xfs_trans_ail_cursor_last(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_ail_cursor *cur,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
xfs_trans_ail_cursor_init(ailp, cur);
|
|
|
|
cur->item = __xfs_trans_ail_cursor_last(ailp, lsn);
|
|
|
|
return cur->item;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-17 21:40:17 -06:00
|
|
|
* Splice the log item list into the AIL at the given LSN. We splice to the
|
2011-07-17 21:40:16 -06:00
|
|
|
* tail of the given LSN to maintain insert order for push traversals. The
|
|
|
|
* cursor is optional, allowing repeated updates to the same LSN to avoid
|
2011-07-22 10:04:41 -06:00
|
|
|
* repeated traversals. This should not be called with an empty list.
|
2011-04-07 20:45:07 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_ail_splice(
|
2011-07-17 21:40:16 -06:00
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_ail_cursor *cur,
|
|
|
|
struct list_head *list,
|
|
|
|
xfs_lsn_t lsn)
|
2011-04-07 20:45:07 -06:00
|
|
|
{
|
2011-07-22 10:04:41 -06:00
|
|
|
struct xfs_log_item *lip;
|
|
|
|
|
|
|
|
ASSERT(!list_empty(list));
|
2011-04-07 20:45:07 -06:00
|
|
|
|
2011-07-17 21:40:16 -06:00
|
|
|
/*
|
2011-07-22 10:04:41 -06:00
|
|
|
* Use the cursor to determine the insertion point if one is
|
|
|
|
* provided. If not, or if the one we got is not valid,
|
|
|
|
* find the place in the AIL where the items belong.
|
2011-07-17 21:40:16 -06:00
|
|
|
*/
|
2011-07-22 10:04:41 -06:00
|
|
|
lip = cur ? cur->item : NULL;
|
2015-06-21 17:43:32 -06:00
|
|
|
if (!lip || (uintptr_t)lip & 1)
|
2011-07-17 21:40:16 -06:00
|
|
|
lip = __xfs_trans_ail_cursor_last(ailp, lsn);
|
|
|
|
|
2011-07-22 10:04:41 -06:00
|
|
|
/*
|
|
|
|
* If a cursor is provided, we know we're processing the AIL
|
|
|
|
* in lsn order, and future items to be spliced in will
|
|
|
|
* follow the last one being inserted now. Update the
|
|
|
|
* cursor to point to that last item, now while we have a
|
|
|
|
* reliable pointer to it.
|
|
|
|
*/
|
|
|
|
if (cur)
|
|
|
|
cur->item = list_entry(list->prev, struct xfs_log_item, li_ail);
|
2011-04-07 20:45:07 -06:00
|
|
|
|
2011-07-17 21:40:16 -06:00
|
|
|
/*
|
2011-07-22 10:04:41 -06:00
|
|
|
* Finally perform the splice. Unless the AIL was empty,
|
|
|
|
* lip points to the item in the AIL _after_ which the new
|
|
|
|
* items should go. If lip is null the AIL was empty, so
|
|
|
|
* the new items go at the head of the AIL.
|
2011-07-17 21:40:16 -06:00
|
|
|
*/
|
2011-07-22 10:04:41 -06:00
|
|
|
if (lip)
|
|
|
|
list_splice(list, &lip->li_ail);
|
|
|
|
else
|
|
|
|
list_splice(list, &ailp->xa_ail);
|
2011-04-07 20:45:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete the given item from the AIL. Return a pointer to the item.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_ail_delete(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
xfs_log_item_t *lip)
|
|
|
|
{
|
|
|
|
xfs_ail_check(ailp, lip);
|
|
|
|
list_del(&lip->li_ail);
|
|
|
|
xfs_trans_ail_cursor_clear(ailp, lip);
|
|
|
|
}
|
|
|
|
|
2011-10-11 09:14:10 -06:00
|
|
|
static long
|
|
|
|
xfsaild_push(
|
|
|
|
struct xfs_ail *ailp)
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
{
|
2011-05-05 20:54:05 -06:00
|
|
|
xfs_mount_t *mp = ailp->xa_mount;
|
2011-07-17 21:40:18 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
2011-05-05 20:54:05 -06:00
|
|
|
xfs_log_item_t *lip;
|
|
|
|
xfs_lsn_t lsn;
|
2011-05-05 20:54:07 -06:00
|
|
|
xfs_lsn_t target;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
long tout;
|
2011-05-05 20:54:05 -06:00
|
|
|
int stuck = 0;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
int flushing = 0;
|
2011-05-05 20:54:05 -06:00
|
|
|
int count = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-09-29 22:45:03 -06:00
|
|
|
/*
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* If we encountered pinned items or did not finish writing out all
|
|
|
|
* buffers the last time we ran, force the log first and wait for it
|
|
|
|
* before pushing again.
|
2011-09-29 22:45:03 -06:00
|
|
|
*/
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 &&
|
|
|
|
(!list_empty_careful(&ailp->xa_buf_list) ||
|
|
|
|
xfs_ail_min_lsn(ailp))) {
|
2011-09-29 22:45:03 -06:00
|
|
|
ailp->xa_log_flush = 0;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail_flush);
|
2011-09-29 22:45:03 -06:00
|
|
|
xfs_log_force(mp, XFS_LOG_SYNC);
|
|
|
|
}
|
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
spin_lock(&ailp->xa_lock);
|
2012-06-28 04:52:56 -06:00
|
|
|
|
|
|
|
/* barrier matches the xa_target update in xfs_ail_push() */
|
|
|
|
smp_rmb();
|
|
|
|
target = ailp->xa_target;
|
|
|
|
ailp->xa_target_prev = target;
|
|
|
|
|
2011-07-17 21:40:18 -06:00
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn);
|
2012-04-22 23:58:34 -06:00
|
|
|
if (!lip) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* If the AIL is empty or our push has reached the end we are
|
|
|
|
* done now.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2014-04-14 03:06:05 -06:00
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
2008-10-30 00:39:23 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
2011-05-05 20:54:05 -06:00
|
|
|
goto out_done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
lsn = lip->li_lsn;
|
2011-05-05 20:54:06 -06:00
|
|
|
while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) {
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
int lock_result;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2013-08-28 05:12:03 -06:00
|
|
|
* Note that iop_push may unlock and reacquire the AIL lock. We
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* rely on the AIL cursor implementation to be able to deal with
|
|
|
|
* the dropped lock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-08-28 05:12:03 -06:00
|
|
|
lock_result = lip->li_ops->iop_push(lip, &ailp->xa_buf_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (lock_result) {
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
case XFS_ITEM_SUCCESS:
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail_success);
|
2011-10-11 09:14:11 -06:00
|
|
|
trace_xfs_ail_push(lip);
|
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
ailp->xa_last_pushed_lsn = lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
case XFS_ITEM_FLUSHING:
|
|
|
|
/*
|
|
|
|
* The item or its backing buffer is already beeing
|
|
|
|
* flushed. The typical reason for that is that an
|
|
|
|
* inode buffer is locked because we already pushed the
|
|
|
|
* updates to it as part of inode clustering.
|
|
|
|
*
|
|
|
|
* We do not want to to stop flushing just because lots
|
|
|
|
* of items are already beeing flushed, but we need to
|
|
|
|
* re-try the flushing relatively soon if most of the
|
|
|
|
* AIL is beeing flushed.
|
|
|
|
*/
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail_flushing);
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
trace_xfs_ail_flushing(lip);
|
|
|
|
|
|
|
|
flushing++;
|
|
|
|
ailp->xa_last_pushed_lsn = lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
case XFS_ITEM_PINNED:
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail_pinned);
|
2011-10-11 09:14:11 -06:00
|
|
|
trace_xfs_ail_pinned(lip);
|
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
stuck++;
|
2011-09-29 22:45:03 -06:00
|
|
|
ailp->xa_log_flush++;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
case XFS_ITEM_LOCKED:
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_push_ail_locked);
|
2011-10-11 09:14:11 -06:00
|
|
|
trace_xfs_ail_locked(lip);
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
stuck++;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
default:
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
count++;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
/*
|
|
|
|
* Are there too many items we can't do anything with?
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
*
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
* If we we are skipping too many items because we can't flush
|
|
|
|
* them or they are already being flushed, we back off and
|
|
|
|
* given them time to complete whatever operation is being
|
|
|
|
* done. i.e. remove pressure from the AIL while we can't make
|
|
|
|
* progress so traversals don't slow down further inserts and
|
|
|
|
* removals to/from the AIL.
|
|
|
|
*
|
|
|
|
* The value of 100 is an arbitrary magic number based on
|
|
|
|
* observation.
|
|
|
|
*/
|
|
|
|
if (stuck > 100)
|
|
|
|
break;
|
|
|
|
|
2011-07-17 21:40:18 -06:00
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
if (lip == NULL)
|
|
|
|
break;
|
|
|
|
lsn = lip->li_lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-04-14 03:06:05 -06:00
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
2008-10-30 00:39:23 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list))
|
|
|
|
ailp->xa_log_flush++;
|
2010-02-01 16:13:42 -07:00
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
if (!count || XFS_LSN_CMP(lsn, target) >= 0) {
|
2011-05-05 20:54:05 -06:00
|
|
|
out_done:
|
2008-03-05 19:45:10 -07:00
|
|
|
/*
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* We reached the target or the AIL is empty, so wait a bit
|
|
|
|
* longer for I/O to complete and remove pushed items from the
|
|
|
|
* AIL before we start the next scan from the start of the AIL.
|
2008-03-05 19:45:10 -07:00
|
|
|
*/
|
2010-01-11 04:49:58 -07:00
|
|
|
tout = 50;
|
2011-04-07 20:45:07 -06:00
|
|
|
ailp->xa_last_pushed_lsn = 0;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
} else if (((stuck + flushing) * 100) / count > 90) {
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
/*
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* Either there is a lot of contention on the AIL or we are
|
|
|
|
* stuck due to operations in progress. "Stuck" in this case
|
|
|
|
* is defined as >90% of the items we tried to push were stuck.
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
*
|
|
|
|
* Backoff a bit more to allow some I/O to complete before
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
* restarting from the start of the AIL. This prevents us from
|
|
|
|
* spinning on the same items, and if they are pinned will all
|
|
|
|
* the restart to issue a log force to unpin the stuck items.
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
*/
|
2010-01-11 04:49:58 -07:00
|
|
|
tout = 20;
|
2011-09-29 22:45:03 -06:00
|
|
|
ailp->xa_last_pushed_lsn = 0;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Assume we have more work to do in a short while.
|
|
|
|
*/
|
|
|
|
tout = 10;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-04-07 20:45:07 -06:00
|
|
|
|
2011-10-11 09:14:10 -06:00
|
|
|
return tout;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xfsaild(
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct xfs_ail *ailp = data;
|
|
|
|
long tout = 0; /* milliseconds */
|
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
current->flags |= PF_MEMALLOC;
|
2016-02-07 20:59:07 -07:00
|
|
|
set_freezable();
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
|
2011-10-11 09:14:10 -06:00
|
|
|
while (!kthread_should_stop()) {
|
|
|
|
if (tout && tout <= 20)
|
|
|
|
__set_current_state(TASK_KILLABLE);
|
|
|
|
else
|
|
|
|
__set_current_state(TASK_INTERRUPTIBLE);
|
2012-06-28 04:52:56 -06:00
|
|
|
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Idle if the AIL is empty and we are not racing with a target
|
|
|
|
* update. We check the AIL after we set the task to a sleep
|
|
|
|
* state to guarantee that we either catch an xa_target update
|
|
|
|
* or that a wake_up resets the state to TASK_RUNNING.
|
|
|
|
* Otherwise, we run the risk of sleeping indefinitely.
|
|
|
|
*
|
|
|
|
* The barrier matches the xa_target update in xfs_ail_push().
|
|
|
|
*/
|
|
|
|
smp_rmb();
|
|
|
|
if (!xfs_ail_min(ailp) &&
|
|
|
|
ailp->xa_target == ailp->xa_target_prev) {
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
2016-02-07 20:59:07 -07:00
|
|
|
freezable_schedule();
|
2012-06-28 04:52:56 -06:00
|
|
|
tout = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
if (tout)
|
2016-02-07 20:59:07 -07:00
|
|
|
freezable_schedule_timeout(msecs_to_jiffies(tout));
|
2012-06-28 04:52:56 -06:00
|
|
|
|
|
|
|
__set_current_state(TASK_RUNNING);
|
2011-10-11 09:14:10 -06:00
|
|
|
|
|
|
|
try_to_freeze();
|
|
|
|
|
|
|
|
tout = xfsaild_push(ailp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2010-01-11 04:49:58 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* This routine is called to move the tail of the AIL forward. It does this by
|
|
|
|
* trying to flush items in the AIL whose lsns are below the given
|
|
|
|
* threshold_lsn.
|
|
|
|
*
|
|
|
|
* The push is run asynchronously in a workqueue, which means the caller needs
|
|
|
|
* to handle waiting on the async flush for space to become available.
|
|
|
|
* We don't want to interrupt any push that is in progress, hence we only queue
|
|
|
|
* work if we set the pushing bit approriately.
|
|
|
|
*
|
|
|
|
* We do this unlocked - we only need to know whether there is anything in the
|
|
|
|
* AIL at the time we are called. We don't need to access the contents of
|
|
|
|
* any of the objects, so the lock is not needed.
|
|
|
|
*/
|
|
|
|
void
|
2011-04-07 20:45:07 -06:00
|
|
|
xfs_ail_push(
|
2011-04-07 20:45:07 -06:00
|
|
|
struct xfs_ail *ailp,
|
|
|
|
xfs_lsn_t threshold_lsn)
|
|
|
|
{
|
|
|
|
xfs_log_item_t *lip;
|
|
|
|
|
|
|
|
lip = xfs_ail_min(ailp);
|
|
|
|
if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) ||
|
|
|
|
XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that the new target is noticed in push code before it clears
|
|
|
|
* the XFS_AIL_PUSHING_BIT.
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
2011-05-05 20:54:07 -06:00
|
|
|
xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn);
|
2011-10-11 09:14:10 -06:00
|
|
|
smp_wmb();
|
|
|
|
|
|
|
|
wake_up_process(ailp->xa_task);
|
2011-04-07 20:45:07 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* Push out all items in the AIL immediately
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_ail_push_all(
|
|
|
|
struct xfs_ail *ailp)
|
|
|
|
{
|
|
|
|
xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp);
|
|
|
|
|
|
|
|
if (threshold_lsn)
|
|
|
|
xfs_ail_push(ailp, threshold_lsn);
|
|
|
|
}
|
|
|
|
|
2012-04-22 23:58:34 -06:00
|
|
|
/*
|
|
|
|
* Push out all items in the AIL immediately and wait until the AIL is empty.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_ail_push_all_sync(
|
|
|
|
struct xfs_ail *ailp)
|
|
|
|
{
|
|
|
|
struct xfs_log_item *lip;
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
while ((lip = xfs_ail_max(ailp)) != NULL) {
|
|
|
|
prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE);
|
|
|
|
ailp->xa_target = lip->li_lsn;
|
|
|
|
wake_up_process(ailp->xa_task);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
schedule();
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
finish_wait(&ailp->xa_empty, &wait);
|
|
|
|
}
|
|
|
|
|
2010-12-19 18:02:19 -07:00
|
|
|
/*
|
|
|
|
* xfs_trans_ail_update - bulk AIL insertion operation.
|
|
|
|
*
|
|
|
|
* @xfs_trans_ail_update takes an array of log items that all need to be
|
|
|
|
* positioned at the same LSN in the AIL. If an item is not in the AIL, it will
|
|
|
|
* be added. Otherwise, it will be repositioned by removing it and re-adding
|
|
|
|
* it to the AIL. If we move the first item in the AIL, update the log tail to
|
|
|
|
* match the new minimum LSN in the AIL.
|
|
|
|
*
|
|
|
|
* This function takes the AIL lock once to execute the update operations on
|
|
|
|
* all the items in the array, and as such should not be called with the AIL
|
|
|
|
* lock held. As a result, once we have the AIL lock, we need to check each log
|
|
|
|
* item LSN to confirm it needs to be moved forward in the AIL.
|
|
|
|
*
|
|
|
|
* To optimise the insert operation, we delete all the items from the AIL in
|
|
|
|
* the first pass, moving them into a temporary list, then splice the temporary
|
|
|
|
* list into the correct position in the AIL. This avoids needing to do an
|
|
|
|
* insert operation on every item.
|
|
|
|
*
|
|
|
|
* This function must be called with the AIL lock held. The lock is dropped
|
|
|
|
* before returning.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_ail_update_bulk(
|
|
|
|
struct xfs_ail *ailp,
|
2011-07-17 21:40:16 -06:00
|
|
|
struct xfs_ail_cursor *cur,
|
2010-12-19 18:02:19 -07:00
|
|
|
struct xfs_log_item **log_items,
|
|
|
|
int nr_items,
|
|
|
|
xfs_lsn_t lsn) __releases(ailp->xa_lock)
|
|
|
|
{
|
|
|
|
xfs_log_item_t *mlip;
|
|
|
|
int mlip_changed = 0;
|
|
|
|
int i;
|
|
|
|
LIST_HEAD(tmp);
|
|
|
|
|
2011-07-22 10:04:41 -06:00
|
|
|
ASSERT(nr_items > 0); /* Not required, but true. */
|
2010-12-19 18:02:19 -07:00
|
|
|
mlip = xfs_ail_min(ailp);
|
|
|
|
|
|
|
|
for (i = 0; i < nr_items; i++) {
|
|
|
|
struct xfs_log_item *lip = log_items[i];
|
|
|
|
if (lip->li_flags & XFS_LI_IN_AIL) {
|
|
|
|
/* check if we really need to move the item */
|
|
|
|
if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0)
|
|
|
|
continue;
|
|
|
|
|
2013-10-31 22:27:18 -06:00
|
|
|
trace_xfs_ail_move(lip, lip->li_lsn, lsn);
|
2010-12-19 18:02:19 -07:00
|
|
|
xfs_ail_delete(ailp, lip);
|
|
|
|
if (mlip == lip)
|
|
|
|
mlip_changed = 1;
|
|
|
|
} else {
|
|
|
|
lip->li_flags |= XFS_LI_IN_AIL;
|
2013-10-31 22:27:18 -06:00
|
|
|
trace_xfs_ail_insert(lip, 0, lsn);
|
2010-12-19 18:02:19 -07:00
|
|
|
}
|
|
|
|
lip->li_lsn = lsn;
|
|
|
|
list_add(&lip->li_ail, &tmp);
|
|
|
|
}
|
|
|
|
|
2011-07-22 10:04:41 -06:00
|
|
|
if (!list_empty(&tmp))
|
|
|
|
xfs_ail_splice(ailp, cur, &tmp, lsn);
|
2010-12-19 18:02:19 -07:00
|
|
|
|
2012-04-22 23:58:33 -06:00
|
|
|
if (mlip_changed) {
|
|
|
|
if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount))
|
|
|
|
xlog_assign_tail_lsn_locked(ailp->xa_mount);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
2012-02-19 19:31:23 -07:00
|
|
|
xfs_log_space_wake(ailp->xa_mount);
|
2012-04-22 23:58:33 -06:00
|
|
|
} else {
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
2010-12-19 18:02:19 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-19 18:03:17 -07:00
|
|
|
/*
|
|
|
|
* xfs_trans_ail_delete_bulk - remove multiple log items from the AIL
|
|
|
|
*
|
|
|
|
* @xfs_trans_ail_delete_bulk takes an array of log items that all need to
|
|
|
|
* removed from the AIL. The caller is already holding the AIL lock, and done
|
|
|
|
* all the checks necessary to ensure the items passed in via @log_items are
|
|
|
|
* ready for deletion. This includes checking that the items are in the AIL.
|
|
|
|
*
|
|
|
|
* For each log item to be removed, unlink it from the AIL, clear the IN_AIL
|
|
|
|
* flag from the item and reset the item's lsn to 0. If we remove the first
|
|
|
|
* item in the AIL, update the log tail to match the new minimum LSN in the
|
|
|
|
* AIL.
|
|
|
|
*
|
|
|
|
* This function will not drop the AIL lock until all items are removed from
|
|
|
|
* the AIL to minimise the amount of lock traffic on the AIL. This does not
|
|
|
|
* greatly increase the AIL hold time, but does significantly reduce the amount
|
|
|
|
* of traffic on the lock, especially during IO completion.
|
|
|
|
*
|
|
|
|
* This function must be called with the AIL lock held. The lock is dropped
|
|
|
|
* before returning.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_ail_delete_bulk(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item **log_items,
|
2012-04-22 23:58:41 -06:00
|
|
|
int nr_items,
|
|
|
|
int shutdown_type) __releases(ailp->xa_lock)
|
2010-12-19 18:03:17 -07:00
|
|
|
{
|
|
|
|
xfs_log_item_t *mlip;
|
|
|
|
int mlip_changed = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mlip = xfs_ail_min(ailp);
|
|
|
|
|
|
|
|
for (i = 0; i < nr_items; i++) {
|
|
|
|
struct xfs_log_item *lip = log_items[i];
|
|
|
|
if (!(lip->li_flags & XFS_LI_IN_AIL)) {
|
|
|
|
struct xfs_mount *mp = ailp->xa_mount;
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
if (!XFS_FORCED_SHUTDOWN(mp)) {
|
2011-03-06 16:02:35 -07:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_AILDELETE,
|
2010-12-19 18:03:17 -07:00
|
|
|
"%s: attempting to delete a log item that is not in the AIL",
|
|
|
|
__func__);
|
2012-04-22 23:58:41 -06:00
|
|
|
xfs_force_shutdown(mp, shutdown_type);
|
2010-12-19 18:03:17 -07:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-31 22:27:18 -06:00
|
|
|
trace_xfs_ail_delete(lip, mlip->li_lsn, lip->li_lsn);
|
2010-12-19 18:03:17 -07:00
|
|
|
xfs_ail_delete(ailp, lip);
|
|
|
|
lip->li_flags &= ~XFS_LI_IN_AIL;
|
|
|
|
lip->li_lsn = 0;
|
|
|
|
if (mlip == lip)
|
|
|
|
mlip_changed = 1;
|
|
|
|
}
|
|
|
|
|
2012-04-22 23:58:33 -06:00
|
|
|
if (mlip_changed) {
|
|
|
|
if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount))
|
|
|
|
xlog_assign_tail_lsn_locked(ailp->xa_mount);
|
2012-04-22 23:58:34 -06:00
|
|
|
if (list_empty(&ailp->xa_ail))
|
|
|
|
wake_up_all(&ailp->xa_empty);
|
2012-04-22 23:58:33 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
2012-02-19 19:31:23 -07:00
|
|
|
xfs_log_space_wake(ailp->xa_mount);
|
2012-04-22 23:58:33 -06:00
|
|
|
} else {
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
2010-12-19 18:03:17 -07:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
int
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_trans_ail_init(
|
|
|
|
xfs_mount_t *mp)
|
|
|
|
{
|
2008-10-30 00:38:26 -06:00
|
|
|
struct xfs_ail *ailp;
|
|
|
|
|
|
|
|
ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL);
|
|
|
|
if (!ailp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2008-10-30 00:38:26 -06:00
|
|
|
|
|
|
|
ailp->xa_mount = mp;
|
|
|
|
INIT_LIST_HEAD(&ailp->xa_ail);
|
2011-07-17 21:40:18 -06:00
|
|
|
INIT_LIST_HEAD(&ailp->xa_cursors);
|
2008-10-30 00:39:23 -06:00
|
|
|
spin_lock_init(&ailp->xa_lock);
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
INIT_LIST_HEAD(&ailp->xa_buf_list);
|
2012-04-22 23:58:34 -06:00
|
|
|
init_waitqueue_head(&ailp->xa_empty);
|
2011-10-11 09:14:10 -06:00
|
|
|
|
|
|
|
ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s",
|
|
|
|
ailp->xa_mount->m_fsname);
|
|
|
|
if (IS_ERR(ailp->xa_task))
|
|
|
|
goto out_free_ailp;
|
|
|
|
|
2008-10-30 00:38:39 -06:00
|
|
|
mp->m_ail = ailp;
|
|
|
|
return 0;
|
2011-10-11 09:14:10 -06:00
|
|
|
|
|
|
|
out_free_ailp:
|
|
|
|
kmem_free(ailp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_trans_ail_destroy(
|
|
|
|
xfs_mount_t *mp)
|
|
|
|
{
|
2008-10-30 00:38:26 -06:00
|
|
|
struct xfs_ail *ailp = mp->m_ail;
|
|
|
|
|
2011-10-11 09:14:10 -06:00
|
|
|
kthread_stop(ailp->xa_task);
|
2008-10-30 00:38:26 -06:00
|
|
|
kmem_free(ailp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|