Attachment 188225 Details for Bug 223831 – release multiple blocks at a time

[patch] release multiple blocks at a time

swap-block-release.diff (text/plain), 3.48 KB, created by ota on 2017-11-23 21:41:46 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: ota

Created: 2017-11-23 21:41:46 UTC

Size: 3.48 KB

patch

obsolete

>This allows to release multiple swap blocks via swp_pager_freeswapspace().
>
>For each call, swp_pager_freeswapspace() locks.  Releasing multiple
>blocks helps to reduce number of locks.  If a swblk contains
>continuous blocks, it reduces up to SWAP_META_PAGES-1 locks.
>
>This patch covers 2 case: 1. when a process exits and all of its
>swap blocks are released and 2. when a process is paged in from
>swap space.
>  I'm looking at swapoff <dev> case but this requires more work.
>
>Index: sys/vm/swap_pager.c
>===================================================================
>--- sys/vm/swap_pager.c	(revision 325969)
>+++ sys/vm/swap_pager.c	(working copy)
>@@ -792,6 +879,43 @@
> }
> 
> /*
>+ * SWP_FIND_CONTINUOUS_REGION() - find a continuous region of swap blocks
>+ *
>+ *	Given the "start" entry is not SWAPBLK_NONE, it searches a range
>+ *      if SWAPBLK to be up to including "last" element.
>+ *
>+ *	The return value indicates the number of blocks freed.
>+ *
>+ *	An example of good case is when swblk holds [2, 3, 4, 5, 6, 7, 8, 9],
>+ *	caller passes (&d[0], and &[7]) as arguments and 8 is returned.
>+ *
>+ *	Another example is with [NONE, 3, NONE, 11, 12, 13, 4, NONE],
>+ *	caller wants to skip d[0] and passes (&d[1], &d[7]) which
>+ *	returns 1 block.  Then, caller skips d[2] and pass (&d[3], &d[7]) which
>+ *	returns 3 blocks as 4 is not a number fater 13 and not continous.
>+ *	Then callers get 1 block back for &d[6] and won't want to call
>+ *	for &d[7] as it is NONE.
>+ */
>+static int
>+swp_find_continuous_region(const daddr_t *start, const daddr_t *last)
>+{
>+	const daddr_t *next;
>+	daddr_t expected;
>+
>+	if (*start == SWAPBLK_NONE)
>+	    return 0;
>+
>+	next = start + 1;
>+	expected = *start + 1;
>+	while (next <= last && (expected == *next))
>+	{
>+		next++;
>+		expected++;
>+	}
>+	return npages = next - start;
>+}
>+
>+/*
>  * SYSCTL_SWAP_FRAGMENTATION() -	produce raw swap space stats
>  */
> static int
>@@ -1888,6 +2047,7 @@
> static void
> swp_pager_meta_free(vm_object_t object, vm_pindex_t pindex, vm_pindex_t count)
> {
>+	int offset, npages;
> 	struct swblk *sb;
> 	vm_pindex_t last;
> 	int i;
>@@ -1908,7 +2072,18 @@
> 			if (sb->d[i] == SWAPBLK_NONE)
> 				continue;
> 			if (pindex <= sb->p + i && sb->p + i <= last) {
>-				swp_pager_freeswapspace(sb->d[i], 1);
>+				offset = last - (sb->p + i);
>+				if (offset == 0) {
>+					npages = 1;
>+				} else {
>+					offset = min(offset, (SWAP_META_PAGES - 1 - i));
>+					npages = swp_find_continuous_region(&sb->d[i], &sb->d[i + offset]);
>+printf("swp_find_continuous_region:start %lld@d[%d] offset=%d %lld->%d\n",
>+	sb->d[i], i, offset, sb->d[i], npages);
>+				}
>+				swp_pager_freeswapspace(sb->d[i], npages);
>+				while( npages-- > 1 )
>+					sb->d[i++] = SWAPBLK_NONE;
> 				sb->d[i] = SWAPBLK_NONE;
> 			} else
> 				empty = false;
>@@ -1933,7 +2108,7 @@
> {
> 	struct swblk *sb;
> 	vm_pindex_t pindex;
>-	int i;
>+	int i, npages;
> 
> 	VM_OBJECT_ASSERT_WLOCKED(object);
> 	if (object->type != OBJT_SWAP)
>@@ -1942,9 +2117,14 @@
> 	for (pindex = 0; (sb = SWAP_PCTRIE_LOOKUP_GE(
> 	    &object->un_pager.swp.swp_blks, pindex)) != NULL;) {
> 		pindex = sb->p + SWAP_META_PAGES;
>-		for (i = 0; i < SWAP_META_PAGES; i++) {
>-			if (sb->d[i] != SWAPBLK_NONE)
>-				swp_pager_freeswapspace(sb->d[i], 1);
>+		for (i = 0; i < SWAP_META_PAGES;) {
>+			if (sb->d[i] != SWAPBLK_NONE) {
>+				npages = swp_find_continuous_region(&sb->d[i], &sb->d[SWAP_META_PAGES - 1]);
>+				swp_pager_freeswapspace(sb->d[i], npages);
>+				i += npages;
>+			} else
>+				i++;
>+
> 		}
> 		SWAP_PCTRIE_REMOVE(&object->un_pager.swp.swp_blks, sb->p);
> 		uma_zfree(swblk_zone, sb);

Actions: View | Diff

Attachments on bug 223831: 188225 | 188460 | 188607 | 188608