Index: src/backend/storage/buffer/bufmgr.c
===================================================================
--- src/backend/storage/buffer/bufmgr.c	(revision 1864)
+++ src/backend/storage/buffer/bufmgr.c	(working copy)
@@ -985,6 +985,30 @@
 	}
 }
 
+typedef struct BufAndTag
+{
+	int			buf_id;
+	BufferTag	tag;
+} BufAndTag;
+
+static int
+bufcmp(const void *a, const void *b)
+{
+	const BufAndTag *lhs = (const BufAndTag *) a;
+	const BufAndTag *rhs = (const BufAndTag *) b;
+	int		r;
+
+	r = memcmp(&lhs->tag.rnode, &rhs->tag.rnode, sizeof(lhs->tag.rnode));
+	if (r != 0)
+		return r;
+	if (lhs->tag.blockNum < rhs->tag.blockNum)
+		return -1;
+	else if (lhs->tag.blockNum > rhs->tag.blockNum)
+		return 1;
+	else
+		return 0;
+}
+
 /*
  * BufferSync -- Write out all dirty buffers in the pool.
  *
@@ -996,9 +1020,10 @@
 BufferSync(int flags)
 {
 	int			buf_id;
-	int			num_to_scan;
 	int			num_to_write;
 	int			num_written;
+	int			i;
+	BufAndTag  *buf_to_write;
 
 	/* Make sure we can handle the pin inside SyncOneBuffer */
 	ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
@@ -1019,6 +1044,7 @@
 	 * BM_CHECKPOINT_NEEDED still set.	This is OK since any such buffer would
 	 * certainly need to be written for the next checkpoint attempt, too.
 	 */
+	buf_to_write = (BufAndTag *) palloc(NBuffers * sizeof(BufAndTag));
 	num_to_write = 0;
 	for (buf_id = 0; buf_id < NBuffers; buf_id++)
 	{
@@ -1033,6 +1059,8 @@
 		if (bufHdr->flags & BM_DIRTY)
 		{
 			bufHdr->flags |= BM_CHECKPOINT_NEEDED;
+			buf_to_write[num_to_write].buf_id = buf_id;
+			buf_to_write[num_to_write].tag = bufHdr->tag;
 			num_to_write++;
 		}
 
@@ -1044,19 +1072,21 @@
 
 	/*
 	 * Loop over all buffers again, and write the ones (still) marked with
-	 * BM_CHECKPOINT_NEEDED.  In this loop, we start at the clock sweep point
-	 * since we might as well dump soon-to-be-recycled buffers first.
+	 * BM_CHECKPOINT_NEEDED.  In this loop, we write buffers in blockNum
+	 * order so that buffers are written sequentially.
 	 *
 	 * Note that we don't read the buffer alloc count here --- that should be
 	 * left untouched till the next BgBufferSync() call.
 	 */
-	buf_id = StrategySyncStart(NULL, NULL);
-	num_to_scan = NBuffers;
+	qsort(buf_to_write, num_to_write, sizeof(BufAndTag), bufcmp);
 	num_written = 0;
-	while (num_to_scan-- > 0)
+	for (i = 0; i < num_to_write; i++)
 	{
-		volatile BufferDesc *bufHdr = &BufferDescriptors[buf_id];
+		volatile BufferDesc *bufHdr;
 
+		buf_id = buf_to_write[i].buf_id;
+		bufHdr = &BufferDescriptors[buf_id];
+
 		/*
 		 * We don't need to acquire the lock here, because we're only looking
 		 * at a single bit. It's possible that someone else writes the buffer
@@ -1098,9 +1128,6 @@
 									 (double) num_written / num_to_write);
 			}
 		}
-
-		if (++buf_id >= NBuffers)
-			buf_id = 0;
 	}
 
 	/*
@@ -1108,6 +1135,7 @@
 	 * buffers written by other backends or bgwriter scan.
 	 */
 	CheckpointStats.ckpt_bufs_written += num_written;
+	pfree(buf_to_write);
 }
 
 /*