2008-06-12 03:50:36 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kthread.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2008-06-12 03:50:36 +07:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/spinlock.h>
|
2009-02-04 21:23:24 +07:00
|
|
|
#include <linux/freezer.h>
|
2008-06-12 03:50:36 +07:00
|
|
|
#include "async-thread.h"
|
|
|
|
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
#define WORK_QUEUED_BIT 0
|
|
|
|
#define WORK_DONE_BIT 1
|
|
|
|
#define WORK_ORDER_DONE_BIT 2
|
2009-04-21 02:50:09 +07:00
|
|
|
#define WORK_HIGH_PRIO_BIT 3
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/*
|
|
|
|
* container for the kthread task pointer and the list of pending work
|
|
|
|
* One of these is allocated per thread.
|
|
|
|
*/
|
|
|
|
struct btrfs_worker_thread {
|
2008-06-12 07:21:24 +07:00
|
|
|
/* pool we belong to */
|
|
|
|
struct btrfs_workers *workers;
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/* list of struct btrfs_work that are waiting for service */
|
|
|
|
struct list_head pending;
|
2009-04-21 02:50:09 +07:00
|
|
|
struct list_head prio_pending;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
/* list of worker threads from struct btrfs_workers */
|
|
|
|
struct list_head worker_list;
|
|
|
|
|
|
|
|
/* kthread */
|
|
|
|
struct task_struct *task;
|
|
|
|
|
|
|
|
/* number of things on the pending list */
|
|
|
|
atomic_t num_pending;
|
2008-08-16 02:34:18 +07:00
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
/* reference counter for this struct */
|
|
|
|
atomic_t refs;
|
|
|
|
|
2008-08-16 02:34:17 +07:00
|
|
|
unsigned long sequence;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
/* protects the pending list. */
|
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
/* set to non-zero when this thread is already awake and kicking */
|
|
|
|
int working;
|
2008-06-12 07:21:24 +07:00
|
|
|
|
|
|
|
/* are we currently idle */
|
|
|
|
int idle;
|
2008-06-12 03:50:36 +07:00
|
|
|
};
|
|
|
|
|
2009-10-03 06:11:56 +07:00
|
|
|
/*
|
|
|
|
* btrfs_start_workers uses kthread_run, which can block waiting for memory
|
|
|
|
* for a very long time. It will actually throttle on page writeback,
|
|
|
|
* and so it may not make progress until after our btrfs worker threads
|
|
|
|
* process all of the pending work structs in their queue
|
|
|
|
*
|
|
|
|
* This means we can't use btrfs_start_workers from inside a btrfs worker
|
|
|
|
* thread that is used as part of cleaning dirty memory, which pretty much
|
|
|
|
* involves all of the worker threads.
|
|
|
|
*
|
|
|
|
* Instead we have a helper queue who never has more than one thread
|
|
|
|
* where we scheduler thread start operations. This worker_start struct
|
|
|
|
* is used to contain the work and hold a pointer to the queue that needs
|
|
|
|
* another worker.
|
|
|
|
*/
|
|
|
|
struct worker_start {
|
|
|
|
struct btrfs_work work;
|
|
|
|
struct btrfs_workers *queue;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void start_new_worker_func(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct worker_start *start;
|
|
|
|
start = container_of(work, struct worker_start, work);
|
|
|
|
btrfs_start_workers(start->queue, 1);
|
|
|
|
kfree(start);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int start_new_worker(struct btrfs_workers *queue)
|
|
|
|
{
|
|
|
|
struct worker_start *start;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
start = kzalloc(sizeof(*start), GFP_NOFS);
|
|
|
|
if (!start)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
start->work.func = start_new_worker_func;
|
|
|
|
start->queue = queue;
|
|
|
|
ret = btrfs_queue_worker(queue->atomic_worker_start, &start->work);
|
|
|
|
if (ret)
|
|
|
|
kfree(start);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-12 07:21:24 +07:00
|
|
|
/*
|
|
|
|
* helper function to move a thread onto the idle list after it
|
|
|
|
* has finished some requests.
|
|
|
|
*/
|
|
|
|
static void check_idle_worker(struct btrfs_worker_thread *worker)
|
|
|
|
{
|
|
|
|
if (!worker->idle && atomic_read(&worker->num_pending) <
|
|
|
|
worker->workers->idle_thresh / 2) {
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&worker->workers->lock, flags);
|
|
|
|
worker->idle = 1;
|
2009-09-16 06:57:42 +07:00
|
|
|
|
|
|
|
/* the list may be empty if the worker is just starting */
|
|
|
|
if (!list_empty(&worker->worker_list)) {
|
|
|
|
list_move(&worker->worker_list,
|
|
|
|
&worker->workers->idle_list);
|
|
|
|
}
|
2008-06-12 07:21:24 +07:00
|
|
|
spin_unlock_irqrestore(&worker->workers->lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to move a thread off the idle list after new
|
|
|
|
* pending work is added.
|
|
|
|
*/
|
|
|
|
static void check_busy_worker(struct btrfs_worker_thread *worker)
|
|
|
|
{
|
|
|
|
if (worker->idle && atomic_read(&worker->num_pending) >=
|
|
|
|
worker->workers->idle_thresh) {
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&worker->workers->lock, flags);
|
|
|
|
worker->idle = 0;
|
2009-09-16 06:57:42 +07:00
|
|
|
|
|
|
|
if (!list_empty(&worker->worker_list)) {
|
|
|
|
list_move_tail(&worker->worker_list,
|
|
|
|
&worker->workers->worker_list);
|
|
|
|
}
|
2008-06-12 07:21:24 +07:00
|
|
|
spin_unlock_irqrestore(&worker->workers->lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
static void check_pending_worker_creates(struct btrfs_worker_thread *worker)
|
|
|
|
{
|
|
|
|
struct btrfs_workers *workers = worker->workers;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
rmb();
|
|
|
|
if (!workers->atomic_start_pending)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&workers->lock, flags);
|
|
|
|
if (!workers->atomic_start_pending)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
workers->atomic_start_pending = 0;
|
2009-10-03 06:11:56 +07:00
|
|
|
if (workers->num_workers + workers->num_workers_starting >=
|
|
|
|
workers->max_workers)
|
2009-08-05 03:56:34 +07:00
|
|
|
goto out;
|
|
|
|
|
2009-10-03 06:11:56 +07:00
|
|
|
workers->num_workers_starting += 1;
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irqrestore(&workers->lock, flags);
|
2009-10-03 06:11:56 +07:00
|
|
|
start_new_worker(workers);
|
2009-08-05 03:56:34 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&workers->lock, flags);
|
|
|
|
}
|
|
|
|
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
static noinline int run_ordered_completions(struct btrfs_workers *workers,
|
|
|
|
struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
if (!workers->ordered)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
set_bit(WORK_DONE_BIT, &work->flags);
|
|
|
|
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_lock(&workers->order_lock);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
|
2009-04-21 02:50:09 +07:00
|
|
|
while (1) {
|
|
|
|
if (!list_empty(&workers->prio_order_list)) {
|
|
|
|
work = list_entry(workers->prio_order_list.next,
|
|
|
|
struct btrfs_work, order_list);
|
|
|
|
} else if (!list_empty(&workers->order_list)) {
|
|
|
|
work = list_entry(workers->order_list.next,
|
|
|
|
struct btrfs_work, order_list);
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
if (!test_bit(WORK_DONE_BIT, &work->flags))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* we are going to call the ordered done function, but
|
|
|
|
* we leave the work item on the list as a barrier so
|
|
|
|
* that later work items that are done don't have their
|
|
|
|
* functions called before this one returns
|
|
|
|
*/
|
|
|
|
if (test_and_set_bit(WORK_ORDER_DONE_BIT, &work->flags))
|
|
|
|
break;
|
|
|
|
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_unlock(&workers->order_lock);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
|
|
|
|
work->ordered_func(work);
|
|
|
|
|
|
|
|
/* now take the lock again and call the freeing code */
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_lock(&workers->order_lock);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
list_del(&work->order_list);
|
|
|
|
work->ordered_free(work);
|
|
|
|
}
|
|
|
|
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_unlock(&workers->order_lock);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
static void put_worker(struct btrfs_worker_thread *worker)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&worker->refs))
|
|
|
|
kfree(worker);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int try_worker_shutdown(struct btrfs_worker_thread *worker)
|
|
|
|
{
|
|
|
|
int freeit = 0;
|
|
|
|
|
|
|
|
spin_lock_irq(&worker->lock);
|
2009-09-16 07:00:36 +07:00
|
|
|
spin_lock(&worker->workers->lock);
|
2009-08-05 03:56:34 +07:00
|
|
|
if (worker->workers->num_workers > 1 &&
|
|
|
|
worker->idle &&
|
|
|
|
!worker->working &&
|
|
|
|
!list_empty(&worker->worker_list) &&
|
|
|
|
list_empty(&worker->prio_pending) &&
|
2009-09-16 07:02:33 +07:00
|
|
|
list_empty(&worker->pending) &&
|
|
|
|
atomic_read(&worker->num_pending) == 0) {
|
2009-08-05 03:56:34 +07:00
|
|
|
freeit = 1;
|
|
|
|
list_del_init(&worker->worker_list);
|
|
|
|
worker->workers->num_workers--;
|
|
|
|
}
|
2009-09-16 07:00:36 +07:00
|
|
|
spin_unlock(&worker->workers->lock);
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irq(&worker->lock);
|
|
|
|
|
|
|
|
if (freeit)
|
|
|
|
put_worker(worker);
|
|
|
|
return freeit;
|
|
|
|
}
|
|
|
|
|
2009-08-07 20:27:38 +07:00
|
|
|
static struct btrfs_work *get_next_work(struct btrfs_worker_thread *worker,
|
|
|
|
struct list_head *prio_head,
|
|
|
|
struct list_head *head)
|
|
|
|
{
|
|
|
|
struct btrfs_work *work = NULL;
|
|
|
|
struct list_head *cur = NULL;
|
|
|
|
|
|
|
|
if(!list_empty(prio_head))
|
|
|
|
cur = prio_head->next;
|
|
|
|
|
|
|
|
smp_mb();
|
|
|
|
if (!list_empty(&worker->prio_pending))
|
|
|
|
goto refill;
|
|
|
|
|
|
|
|
if (!list_empty(head))
|
|
|
|
cur = head->next;
|
|
|
|
|
|
|
|
if (cur)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
refill:
|
|
|
|
spin_lock_irq(&worker->lock);
|
|
|
|
list_splice_tail_init(&worker->prio_pending, prio_head);
|
|
|
|
list_splice_tail_init(&worker->pending, head);
|
|
|
|
|
|
|
|
if (!list_empty(prio_head))
|
|
|
|
cur = prio_head->next;
|
|
|
|
else if (!list_empty(head))
|
|
|
|
cur = head->next;
|
|
|
|
spin_unlock_irq(&worker->lock);
|
|
|
|
|
|
|
|
if (!cur)
|
|
|
|
goto out_fail;
|
|
|
|
|
|
|
|
out:
|
|
|
|
work = list_entry(cur, struct btrfs_work, list);
|
|
|
|
|
|
|
|
out_fail:
|
|
|
|
return work;
|
|
|
|
}
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/*
|
|
|
|
* main loop for servicing work items
|
|
|
|
*/
|
|
|
|
static int worker_loop(void *arg)
|
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker = arg;
|
2009-08-07 20:27:38 +07:00
|
|
|
struct list_head head;
|
|
|
|
struct list_head prio_head;
|
2008-06-12 03:50:36 +07:00
|
|
|
struct btrfs_work *work;
|
2009-08-07 20:27:38 +07:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&head);
|
|
|
|
INIT_LIST_HEAD(&prio_head);
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
do {
|
2009-08-07 20:27:38 +07:00
|
|
|
again:
|
2009-04-21 02:50:09 +07:00
|
|
|
while (1) {
|
2009-08-07 20:27:38 +07:00
|
|
|
|
|
|
|
|
|
|
|
work = get_next_work(worker, &prio_head, &head);
|
|
|
|
if (!work)
|
2009-04-21 02:50:09 +07:00
|
|
|
break;
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
list_del(&work->list);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
clear_bit(WORK_QUEUED_BIT, &work->flags);
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
work->worker = worker;
|
|
|
|
|
|
|
|
work->func(work);
|
|
|
|
|
|
|
|
atomic_dec(&worker->num_pending);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
/*
|
|
|
|
* unless this is an ordered work queue,
|
|
|
|
* 'work' was probably freed by func above.
|
|
|
|
*/
|
|
|
|
run_ordered_completions(worker->workers, work);
|
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
check_pending_worker_creates(worker);
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
}
|
2009-08-07 20:27:38 +07:00
|
|
|
|
|
|
|
spin_lock_irq(&worker->lock);
|
|
|
|
check_idle_worker(worker);
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
if (freezing(current)) {
|
2009-02-04 21:23:24 +07:00
|
|
|
worker->working = 0;
|
|
|
|
spin_unlock_irq(&worker->lock);
|
2008-06-12 03:50:36 +07:00
|
|
|
refrigerator();
|
|
|
|
} else {
|
|
|
|
spin_unlock_irq(&worker->lock);
|
2009-02-04 21:23:24 +07:00
|
|
|
if (!kthread_should_stop()) {
|
|
|
|
cpu_relax();
|
|
|
|
/*
|
|
|
|
* we've dropped the lock, did someone else
|
|
|
|
* jump_in?
|
|
|
|
*/
|
|
|
|
smp_mb();
|
2009-04-21 02:50:09 +07:00
|
|
|
if (!list_empty(&worker->pending) ||
|
|
|
|
!list_empty(&worker->prio_pending))
|
2009-02-04 21:23:24 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this short schedule allows more work to
|
|
|
|
* come in without the queue functions
|
|
|
|
* needing to go through wake_up_process()
|
|
|
|
*
|
|
|
|
* worker->working is still 1, so nobody
|
|
|
|
* is going to try and wake us up
|
|
|
|
*/
|
|
|
|
schedule_timeout(1);
|
|
|
|
smp_mb();
|
2009-04-21 02:50:09 +07:00
|
|
|
if (!list_empty(&worker->pending) ||
|
|
|
|
!list_empty(&worker->prio_pending))
|
2009-02-04 21:23:24 +07:00
|
|
|
continue;
|
|
|
|
|
2009-04-03 04:01:27 +07:00
|
|
|
if (kthread_should_stop())
|
|
|
|
break;
|
|
|
|
|
2009-02-04 21:23:24 +07:00
|
|
|
/* still no more work?, sleep for real */
|
|
|
|
spin_lock_irq(&worker->lock);
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2009-04-21 02:50:09 +07:00
|
|
|
if (!list_empty(&worker->pending) ||
|
2009-08-07 20:27:38 +07:00
|
|
|
!list_empty(&worker->prio_pending)) {
|
|
|
|
spin_unlock_irq(&worker->lock);
|
|
|
|
goto again;
|
|
|
|
}
|
2009-02-04 21:23:24 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* this makes sure we get a wakeup when someone
|
|
|
|
* adds something new to the queue
|
|
|
|
*/
|
|
|
|
worker->working = 0;
|
|
|
|
spin_unlock_irq(&worker->lock);
|
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
if (!kthread_should_stop()) {
|
|
|
|
schedule_timeout(HZ * 120);
|
|
|
|
if (!worker->working &&
|
|
|
|
try_worker_shutdown(worker)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2009-02-04 21:23:24 +07:00
|
|
|
}
|
2008-06-12 03:50:36 +07:00
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
}
|
|
|
|
} while (!kthread_should_stop());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this will wait for all the worker threads to shutdown
|
|
|
|
*/
|
|
|
|
int btrfs_stop_workers(struct btrfs_workers *workers)
|
|
|
|
{
|
|
|
|
struct list_head *cur;
|
|
|
|
struct btrfs_worker_thread *worker;
|
2009-08-05 03:56:34 +07:00
|
|
|
int can_stop;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_lock_irq(&workers->lock);
|
2008-06-12 07:21:24 +07:00
|
|
|
list_splice_init(&workers->idle_list, &workers->worker_list);
|
2009-01-06 09:25:51 +07:00
|
|
|
while (!list_empty(&workers->worker_list)) {
|
2008-06-12 03:50:36 +07:00
|
|
|
cur = workers->worker_list.next;
|
|
|
|
worker = list_entry(cur, struct btrfs_worker_thread,
|
|
|
|
worker_list);
|
2009-08-05 03:56:34 +07:00
|
|
|
|
|
|
|
atomic_inc(&worker->refs);
|
|
|
|
workers->num_workers -= 1;
|
|
|
|
if (!list_empty(&worker->worker_list)) {
|
|
|
|
list_del_init(&worker->worker_list);
|
|
|
|
put_worker(worker);
|
|
|
|
can_stop = 1;
|
|
|
|
} else
|
|
|
|
can_stop = 0;
|
|
|
|
spin_unlock_irq(&workers->lock);
|
|
|
|
if (can_stop)
|
|
|
|
kthread_stop(worker->task);
|
|
|
|
spin_lock_irq(&workers->lock);
|
|
|
|
put_worker(worker);
|
2008-06-12 03:50:36 +07:00
|
|
|
}
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irq(&workers->lock);
|
2008-06-12 03:50:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* simple init on struct btrfs_workers
|
|
|
|
*/
|
2009-10-03 06:11:56 +07:00
|
|
|
void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,
|
|
|
|
struct btrfs_workers *async_helper)
|
2008-06-12 03:50:36 +07:00
|
|
|
{
|
|
|
|
workers->num_workers = 0;
|
2009-10-03 06:11:56 +07:00
|
|
|
workers->num_workers_starting = 0;
|
2008-06-12 03:50:36 +07:00
|
|
|
INIT_LIST_HEAD(&workers->worker_list);
|
2008-06-12 07:21:24 +07:00
|
|
|
INIT_LIST_HEAD(&workers->idle_list);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
INIT_LIST_HEAD(&workers->order_list);
|
2009-04-21 02:50:09 +07:00
|
|
|
INIT_LIST_HEAD(&workers->prio_order_list);
|
2008-06-12 03:50:36 +07:00
|
|
|
spin_lock_init(&workers->lock);
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_lock_init(&workers->order_lock);
|
2008-06-12 03:50:36 +07:00
|
|
|
workers->max_workers = max;
|
2008-08-01 02:42:53 +07:00
|
|
|
workers->idle_thresh = 32;
|
2008-08-16 02:34:16 +07:00
|
|
|
workers->name = name;
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
workers->ordered = 0;
|
2009-08-05 03:56:34 +07:00
|
|
|
workers->atomic_start_pending = 0;
|
2009-10-03 06:11:56 +07:00
|
|
|
workers->atomic_worker_start = async_helper;
|
2008-06-12 03:50:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* starts new worker threads. This does not enforce the max worker
|
|
|
|
* count in case you need to temporarily go past it.
|
|
|
|
*/
|
2009-10-03 06:11:56 +07:00
|
|
|
static int __btrfs_start_workers(struct btrfs_workers *workers,
|
|
|
|
int num_workers)
|
2008-06-12 03:50:36 +07:00
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker;
|
|
|
|
int ret = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_workers; i++) {
|
|
|
|
worker = kzalloc(sizeof(*worker), GFP_NOFS);
|
|
|
|
if (!worker) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&worker->pending);
|
2009-04-21 02:50:09 +07:00
|
|
|
INIT_LIST_HEAD(&worker->prio_pending);
|
2008-06-12 03:50:36 +07:00
|
|
|
INIT_LIST_HEAD(&worker->worker_list);
|
|
|
|
spin_lock_init(&worker->lock);
|
2009-08-06 03:36:45 +07:00
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
atomic_set(&worker->num_pending, 0);
|
2009-08-05 03:56:34 +07:00
|
|
|
atomic_set(&worker->refs, 1);
|
2009-06-11 07:11:29 +07:00
|
|
|
worker->workers = workers;
|
2008-08-16 02:34:16 +07:00
|
|
|
worker->task = kthread_run(worker_loop, worker,
|
|
|
|
"btrfs-%s-%d", workers->name,
|
|
|
|
workers->num_workers + i);
|
2008-06-12 03:50:36 +07:00
|
|
|
if (IS_ERR(worker->task)) {
|
|
|
|
ret = PTR_ERR(worker->task);
|
2009-07-03 00:50:58 +07:00
|
|
|
kfree(worker);
|
2008-06-12 03:50:36 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
spin_lock_irq(&workers->lock);
|
2008-06-12 07:21:24 +07:00
|
|
|
list_add_tail(&worker->worker_list, &workers->idle_list);
|
2008-08-16 02:34:17 +07:00
|
|
|
worker->idle = 1;
|
2008-06-12 03:50:36 +07:00
|
|
|
workers->num_workers++;
|
2009-10-03 06:11:56 +07:00
|
|
|
workers->num_workers_starting--;
|
|
|
|
WARN_ON(workers->num_workers_starting < 0);
|
2008-06-12 03:50:36 +07:00
|
|
|
spin_unlock_irq(&workers->lock);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
btrfs_stop_workers(workers);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-10-03 06:11:56 +07:00
|
|
|
int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&workers->lock);
|
|
|
|
workers->num_workers_starting += num_workers;
|
|
|
|
spin_unlock_irq(&workers->lock);
|
|
|
|
return __btrfs_start_workers(workers, num_workers);
|
|
|
|
}
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/*
|
|
|
|
* run through the list and find a worker thread that doesn't have a lot
|
|
|
|
* to do right now. This can return null if we aren't yet at the thread
|
|
|
|
* count limit and all of the threads are busy.
|
|
|
|
*/
|
|
|
|
static struct btrfs_worker_thread *next_worker(struct btrfs_workers *workers)
|
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker;
|
|
|
|
struct list_head *next;
|
2009-10-03 06:11:56 +07:00
|
|
|
int enforce_min;
|
|
|
|
|
|
|
|
enforce_min = (workers->num_workers + workers->num_workers_starting) <
|
|
|
|
workers->max_workers;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
/*
|
2008-06-12 07:21:24 +07:00
|
|
|
* if we find an idle thread, don't move it to the end of the
|
|
|
|
* idle list. This improves the chance that the next submission
|
|
|
|
* will reuse the same thread, and maybe catch it while it is still
|
|
|
|
* working
|
2008-06-12 03:50:36 +07:00
|
|
|
*/
|
2008-06-12 07:21:24 +07:00
|
|
|
if (!list_empty(&workers->idle_list)) {
|
|
|
|
next = workers->idle_list.next;
|
2008-06-12 03:50:36 +07:00
|
|
|
worker = list_entry(next, struct btrfs_worker_thread,
|
|
|
|
worker_list);
|
2008-06-12 07:21:24 +07:00
|
|
|
return worker;
|
2008-06-12 03:50:36 +07:00
|
|
|
}
|
2008-06-12 07:21:24 +07:00
|
|
|
if (enforce_min || list_empty(&workers->worker_list))
|
|
|
|
return NULL;
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/*
|
2008-06-12 07:21:24 +07:00
|
|
|
* if we pick a busy task, move the task to the end of the list.
|
2008-09-30 02:18:18 +07:00
|
|
|
* hopefully this will keep things somewhat evenly balanced.
|
|
|
|
* Do the move in batches based on the sequence number. This groups
|
|
|
|
* requests submitted at roughly the same time onto the same worker.
|
2008-06-12 03:50:36 +07:00
|
|
|
*/
|
2008-06-12 07:21:24 +07:00
|
|
|
next = workers->worker_list.next;
|
|
|
|
worker = list_entry(next, struct btrfs_worker_thread, worker_list);
|
2008-08-16 02:34:17 +07:00
|
|
|
worker->sequence++;
|
2008-09-30 02:18:18 +07:00
|
|
|
|
2008-08-16 02:34:18 +07:00
|
|
|
if (worker->sequence % workers->idle_thresh == 0)
|
2008-08-16 02:34:17 +07:00
|
|
|
list_move_tail(next, &workers->worker_list);
|
2008-06-12 03:50:36 +07:00
|
|
|
return worker;
|
|
|
|
}
|
|
|
|
|
2008-09-30 02:18:18 +07:00
|
|
|
/*
|
|
|
|
* selects a worker thread to take the next job. This will either find
|
|
|
|
* an idle worker, start a new worker up to the max count, or just return
|
|
|
|
* one of the existing busy workers.
|
|
|
|
*/
|
2008-06-12 03:50:36 +07:00
|
|
|
static struct btrfs_worker_thread *find_worker(struct btrfs_workers *workers)
|
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker;
|
|
|
|
unsigned long flags;
|
2009-08-05 03:56:34 +07:00
|
|
|
struct list_head *fallback;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
again:
|
|
|
|
spin_lock_irqsave(&workers->lock, flags);
|
|
|
|
worker = next_worker(workers);
|
|
|
|
|
|
|
|
if (!worker) {
|
2009-10-03 06:11:56 +07:00
|
|
|
if (workers->num_workers + workers->num_workers_starting >=
|
|
|
|
workers->max_workers) {
|
2009-08-05 03:56:34 +07:00
|
|
|
goto fallback;
|
|
|
|
} else if (workers->atomic_worker_start) {
|
|
|
|
workers->atomic_start_pending = 1;
|
|
|
|
goto fallback;
|
2008-06-12 03:50:36 +07:00
|
|
|
} else {
|
2009-10-03 06:11:56 +07:00
|
|
|
workers->num_workers_starting++;
|
2008-06-12 03:50:36 +07:00
|
|
|
spin_unlock_irqrestore(&workers->lock, flags);
|
|
|
|
/* we're below the limit, start another worker */
|
2009-10-03 06:11:56 +07:00
|
|
|
__btrfs_start_workers(workers, 1);
|
2008-06-12 03:50:36 +07:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
}
|
2009-09-16 07:02:33 +07:00
|
|
|
goto found;
|
2009-08-05 03:56:34 +07:00
|
|
|
|
|
|
|
fallback:
|
|
|
|
fallback = NULL;
|
|
|
|
/*
|
|
|
|
* we have failed to find any workers, just
|
|
|
|
* return the first one we can find.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&workers->worker_list))
|
|
|
|
fallback = workers->worker_list.next;
|
|
|
|
if (!list_empty(&workers->idle_list))
|
|
|
|
fallback = workers->idle_list.next;
|
|
|
|
BUG_ON(!fallback);
|
|
|
|
worker = list_entry(fallback,
|
|
|
|
struct btrfs_worker_thread, worker_list);
|
2009-09-16 07:02:33 +07:00
|
|
|
found:
|
|
|
|
/*
|
|
|
|
* this makes sure the worker doesn't exit before it is placed
|
|
|
|
* onto a busy/idle list
|
|
|
|
*/
|
|
|
|
atomic_inc(&worker->num_pending);
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irqrestore(&workers->lock, flags);
|
|
|
|
return worker;
|
2008-06-12 03:50:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* btrfs_requeue_work just puts the work item back on the tail of the list
|
|
|
|
* it was taken from. It is intended for use with long running work functions
|
|
|
|
* that make some progress and want to give the cpu up for others.
|
|
|
|
*/
|
|
|
|
int btrfs_requeue_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker = work->worker;
|
|
|
|
unsigned long flags;
|
2009-02-04 21:19:41 +07:00
|
|
|
int wake = 0;
|
2008-06-12 03:50:36 +07:00
|
|
|
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))
|
2008-06-12 03:50:36 +07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&worker->lock, flags);
|
2009-04-21 02:50:09 +07:00
|
|
|
if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags))
|
|
|
|
list_add_tail(&work->list, &worker->prio_pending);
|
|
|
|
else
|
|
|
|
list_add_tail(&work->list, &worker->pending);
|
2009-02-04 21:23:24 +07:00
|
|
|
atomic_inc(&worker->num_pending);
|
2008-10-01 06:24:06 +07:00
|
|
|
|
|
|
|
/* by definition we're busy, take ourselves off the idle
|
|
|
|
* list
|
|
|
|
*/
|
|
|
|
if (worker->idle) {
|
2009-07-23 03:49:00 +07:00
|
|
|
spin_lock(&worker->workers->lock);
|
2008-10-01 06:24:06 +07:00
|
|
|
worker->idle = 0;
|
|
|
|
list_move_tail(&worker->worker_list,
|
2009-09-16 07:02:33 +07:00
|
|
|
&worker->workers->worker_list);
|
2009-07-23 03:49:00 +07:00
|
|
|
spin_unlock(&worker->workers->lock);
|
2008-10-01 06:24:06 +07:00
|
|
|
}
|
2009-02-04 21:19:41 +07:00
|
|
|
if (!worker->working) {
|
|
|
|
wake = 1;
|
|
|
|
worker->working = 1;
|
|
|
|
}
|
2008-10-01 06:24:06 +07:00
|
|
|
|
2009-02-04 21:19:41 +07:00
|
|
|
if (wake)
|
|
|
|
wake_up_process(worker->task);
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irqrestore(&worker->lock, flags);
|
2008-06-12 03:50:36 +07:00
|
|
|
out:
|
2009-02-04 21:19:41 +07:00
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-21 02:50:09 +07:00
|
|
|
void btrfs_set_work_high_prio(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
set_bit(WORK_HIGH_PRIO_BIT, &work->flags);
|
|
|
|
}
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
/*
|
|
|
|
* places a struct btrfs_work into the pending queue of one of the kthreads
|
|
|
|
*/
|
|
|
|
int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_worker_thread *worker;
|
|
|
|
unsigned long flags;
|
|
|
|
int wake = 0;
|
|
|
|
|
|
|
|
/* don't requeue something already on a list */
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))
|
2008-06-12 03:50:36 +07:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
worker = find_worker(workers);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
if (workers->ordered) {
|
2009-08-06 03:36:45 +07:00
|
|
|
/*
|
|
|
|
* you're not allowed to do ordered queues from an
|
|
|
|
* interrupt handler
|
|
|
|
*/
|
|
|
|
spin_lock(&workers->order_lock);
|
2009-04-21 02:50:09 +07:00
|
|
|
if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags)) {
|
|
|
|
list_add_tail(&work->order_list,
|
|
|
|
&workers->prio_order_list);
|
|
|
|
} else {
|
|
|
|
list_add_tail(&work->order_list, &workers->order_list);
|
|
|
|
}
|
2009-08-06 03:36:45 +07:00
|
|
|
spin_unlock(&workers->order_lock);
|
Btrfs: Add ordered async work queues
Btrfs uses kernel threads to create async work queues for cpu intensive
operations such as checksumming and decompression. These work well,
but they make it difficult to keep IO order intact.
A single writepages call from pdflush or fsync will turn into a number
of bios, and each bio is checksummed in parallel. Once the checksum is
computed, the bio is sent down to the disk, and since we don't control
the order in which the parallel operations happen, they might go down to
the disk in almost any order.
The code deals with this somewhat by having deep work queues for a single
kernel thread, making it very likely that a single thread will process all
the bios for a single inode.
This patch introduces an explicitly ordered work queue. As work structs
are placed into the queue they are put onto the tail of a list. They have
three callbacks:
->func (cpu intensive processing here)
->ordered_func (order sensitive processing here)
->ordered_free (free the work struct, all processing is done)
The work struct has three callbacks. The func callback does the cpu intensive
work, and when it completes the work struct is marked as done.
Every time a work struct completes, the list is checked to see if the head
is marked as done. If so the ordered_func callback is used to do the
order sensitive processing and the ordered_free callback is used to do
any cleanup. Then we loop back and check the head of the list again.
This patch also changes the checksumming code to use the ordered workqueues.
One a 4 drive array, it increases streaming writes from 280MB/s to 350MB/s.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-11-07 10:03:00 +07:00
|
|
|
} else {
|
|
|
|
INIT_LIST_HEAD(&work->order_list);
|
|
|
|
}
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&worker->lock, flags);
|
2009-02-04 21:19:41 +07:00
|
|
|
|
2009-04-21 02:50:09 +07:00
|
|
|
if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags))
|
|
|
|
list_add_tail(&work->list, &worker->prio_pending);
|
|
|
|
else
|
|
|
|
list_add_tail(&work->list, &worker->pending);
|
2008-06-12 07:21:24 +07:00
|
|
|
check_busy_worker(worker);
|
2008-06-12 03:50:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* avoid calling into wake_up_process if this thread has already
|
|
|
|
* been kicked
|
|
|
|
*/
|
|
|
|
if (!worker->working)
|
|
|
|
wake = 1;
|
|
|
|
worker->working = 1;
|
|
|
|
|
|
|
|
if (wake)
|
|
|
|
wake_up_process(worker->task);
|
2009-08-05 03:56:34 +07:00
|
|
|
spin_unlock_irqrestore(&worker->lock, flags);
|
|
|
|
|
2008-06-12 03:50:36 +07:00
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|