All of lore.kernel.org
 help / color / mirror / Atom feed
From: Oleg Nesterov <oleg@tv-sign.ru>
To: linux-kernel@vger.kernel.org
Cc: Andrew Morton <akpm@osdl.org>, Linus Torvalds <torvalds@osdl.org>
Subject: [PATCH] WAIT_BIT_QUEUE
Date: Mon, 10 May 2004 15:24:58 +0400	[thread overview]
Message-ID: <409F668A.CEFD60F6@tv-sign.ru> (raw)

Hello.

a better (imho) alternative to filtered wakeups.
see http://marc.theaimsgroup.com/?l=linux-kernel&m=108375670411475&w=2

process waiting in wait_on_page_bit() will be woken only after
the required bit is cleared.

so there is no need to recheck the bit in do/while loop, because
there is no false wakeups now.

yes, when process gets cpu, the page can be locked again, it's ok.

Oleg.

diff -urp 6.6-clean/fs/buffer.c 6.6-waitb/fs/buffer.c
--- 6.6-clean/fs/buffer.c	2004-05-10 12:50:53.000000000 +0400
+++ 6.6-waitb/fs/buffer.c	2004-05-10 14:13:40.000000000 +0400
@@ -93,20 +93,20 @@ void fastcall unlock_buffer(struct buffe
 void __wait_on_buffer(struct buffer_head * bh)
 {
 	wait_queue_head_t *wqh = bh_waitq_head(bh);
-	DEFINE_WAIT(wait);
+	DEFINE_WAIT_BIT(wait, &bh->b_state, BH_Lock);
 
-	do {
-		prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
-		if (buffer_locked(bh)) {
-			struct block_device *bd;
-			smp_mb();
-			bd = bh->b_bdev;
-			if (bd)
-				blk_run_address_space(bd->bd_inode->i_mapping);
-			io_schedule();
-		}
-	} while (buffer_locked(bh));
-	finish_wait(wqh, &wait);
+	prepare_to_wait(wqh, &wait.wait, TASK_UNINTERRUPTIBLE);
+
+	if (buffer_locked(bh)) {
+		struct block_device *bd;
+		smp_mb();
+		bd = bh->b_bdev;
+		if (bd)
+			blk_run_address_space(bd->bd_inode->i_mapping);
+		io_schedule();
+	}
+
+	finish_wait(wqh, &wait.wait);
 }
 
 static void
diff -urp 6.6-clean/include/linux/wait.h 6.6-waitb/include/linux/wait.h
--- 6.6-clean/include/linux/wait.h	2004-03-11 05:55:28.000000000 +0300
+++ 6.6-waitb/include/linux/wait.h	2004-05-10 14:14:17.000000000 +0400
@@ -257,7 +257,27 @@ int autoremove_wake_function(wait_queue_
 		wait->func = autoremove_wake_function;			\
 		INIT_LIST_HEAD(&wait->task_list);			\
 	} while (0)
-	
+
+
+struct wait_bit_queue {
+	unsigned long *flags;
+	int bit_nr;
+	wait_queue_t wait;
+};
+
+#define DEFINE_WAIT_BIT(name, _flags, _bit_nr)					\
+	struct wait_bit_queue name = {						\
+		.flags	= _flags,						\
+		.bit_nr	= _bit_nr,						\
+		.wait	= {							\
+			.task = current,					\
+			.func = wake_bit_function,				\
+			.task_list = LIST_HEAD_INIT(name.wait.task_list),	\
+		},								\
+	}
+
+int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync);
+
 #endif /* __KERNEL__ */
 
 #endif
diff -urp 6.6-clean/kernel/fork.c 6.6-waitb/kernel/fork.c
--- 6.6-clean/kernel/fork.c	2004-05-10 12:50:59.000000000 +0400
+++ 6.6-waitb/kernel/fork.c	2004-05-10 14:14:08.000000000 +0400
@@ -207,6 +207,17 @@ int autoremove_wake_function(wait_queue_
 
 EXPORT_SYMBOL(autoremove_wake_function);
 
+int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync)
+{
+	struct wait_bit_queue *wait_bit =
+		container_of(wait, struct wait_bit_queue, wait);
+
+	if (test_bit(wait_bit->bit_nr, wait_bit->flags))
+		return 0;
+
+	return autoremove_wake_function(wait, mode, sync);
+}
+
 void __init fork_init(unsigned long mempages)
 {
 #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
diff -urp 6.6-clean/mm/filemap.c 6.6-waitb/mm/filemap.c
--- 6.6-clean/mm/filemap.c	2004-05-10 12:50:59.000000000 +0400
+++ 6.6-waitb/mm/filemap.c	2004-05-10 14:13:52.000000000 +0400
@@ -301,16 +301,16 @@ static wait_queue_head_t *page_waitqueue
 void fastcall wait_on_page_bit(struct page *page, int bit_nr)
 {
 	wait_queue_head_t *waitqueue = page_waitqueue(page);
-	DEFINE_WAIT(wait);
+	DEFINE_WAIT_BIT(wait, &page->flags, bit_nr);
 
-	do {
-		prepare_to_wait(waitqueue, &wait, TASK_UNINTERRUPTIBLE);
-		if (test_bit(bit_nr, &page->flags)) {
-			sync_page(page);
-			io_schedule();
-		}
-	} while (test_bit(bit_nr, &page->flags));
-	finish_wait(waitqueue, &wait);
+	prepare_to_wait(waitqueue, &wait.wait, TASK_UNINTERRUPTIBLE);
+
+	if (test_bit(bit_nr, &page->flags)) {
+		sync_page(page);
+		io_schedule();
+	}
+
+	finish_wait(waitqueue, &wait.wait);
 }
 
 EXPORT_SYMBOL(wait_on_page_bit);
@@ -372,17 +372,8 @@ EXPORT_SYMBOL(end_page_writeback);
  */
 void fastcall __lock_page(struct page *page)
 {
-	wait_queue_head_t *wqh = page_waitqueue(page);
-	DEFINE_WAIT(wait);
-
-	while (TestSetPageLocked(page)) {
-		prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);
-		if (PageLocked(page)) {
-			sync_page(page);
-			io_schedule();
-		}
-	}
-	finish_wait(wqh, &wait);
+	while (TestSetPageLocked(page))
+		wait_on_page_bit(page, PG_locked);
 }
 
 EXPORT_SYMBOL(__lock_page);

             reply	other threads:[~2004-05-10 11:24 UTC|newest]

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2004-05-10 11:24 Oleg Nesterov [this message]
2004-05-10 11:30 ` [PATCH] WAIT_BIT_QUEUE Andrew Morton
2004-05-10 12:31   ` Oleg Nesterov
2004-05-10 14:55 ` Linus Torvalds

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=409F668A.CEFD60F6@tv-sign.ru \
    --to=oleg@tv-sign.ru \
    --cc=akpm@osdl.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=torvalds@osdl.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.