1 files changed, 45 insertions, 71 deletions
diff --git a/mm/thrash.c b/mm/thrash.c
index f4c560b4a2b7..19e428ca8b03 100644
--- a/mm/thrash.c
+++ b/mm/thrash.c
@@ -7,100 +7,74 @@
 *
 * Simple token based thrashing protection, using the algorithm
 * described in:  http://www.cs.wm.edu/~sjiang/token.pdf
+ *
+ * Sep 2006, Ashwin Chaugule <ashwin.chaugule@celunite.com>
+ * Improved algorithm to pass token:
+ * Each task has a priority which is incremented if it contended
+ * for the token in an interval less than its previous attempt.
+ * If the token is acquired, that task's priority is boosted to prevent
+ * the token from bouncing around too often and to let the task make
+ * some progress in its execution.
 */
 #include <linux/jiffies.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/swap.h>
 static DEFINE_SPINLOCK(swap_token_lock);
-static unsigned long swap_token_timeout;
+struct mm_struct *swap_token_mm;
-static unsigned long swap_token_check;
+unsigned int global_faults;
-struct mm_struct * swap_token_mm = &init_mm;
-#define SWAP_TOKEN_CHECK_INTERVAL (HZ * 2)
-#define SWAP_TOKEN_TIMEOUT      (300 * HZ)
-/*
- * Currently disabled; Needs further code to work at HZ * 300.
- */
-unsigned long swap_token_default_timeout = SWAP_TOKEN_TIMEOUT;
-/*
- * Take the token away if the process had no page faults
- * in the last interval, or if it has held the token for
- * too long.
- */
-#define SWAP_TOKEN_ENOUGH_RSS 1
-#define SWAP_TOKEN_TIMED_OUT 2
-static int should_release_swap_token(struct mm_struct *mm)
-{
-        int ret = 0;
-        if (!mm->recent_pagein)
-                ret = SWAP_TOKEN_ENOUGH_RSS;
-        else if (time_after(jiffies, swap_token_timeout))
-                ret = SWAP_TOKEN_TIMED_OUT;
-        mm->recent_pagein = 0;
-        return ret;
-}
-/*
- * Try to grab the swapout protection token.  We only try to
- * grab it once every TOKEN_CHECK_INTERVAL, both to prevent
- * SMP lock contention and to check that the process that held
- * the token before is no longer thrashing.
- */
 void grab_swap_token(void)
 {
-        struct mm_struct *mm;
+        int current_interval;
-        int reason;
-        /* We have the token. Let others know we still need it. */
+        global_faults++;
-        if (has_swap_token(current->mm)) {
-                current->mm->recent_pagein = 1;
-                if (unlikely(!swap_token_default_timeout))
-                        disable_swap_token();
-                return;
-        }
-        if (time_after(jiffies, swap_token_check)) {
-                if (!swap_token_default_timeout) {
+        current_interval = global_faults - current->mm->faultstamp;
-                        swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
-                        return;
-                }
-                /* ... or if we recently held the token. */
-                if (time_before(jiffies, current->mm->swap_token_time))
-                        return;
-                if (!spin_trylock(&swap_token_lock))
+        if (!spin_trylock(&swap_token_lock))
-                        return;
+                return;
-                swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
+        /* First come first served */
+        if (swap_token_mm == NULL) {
+                current->mm->token_priority = current->mm->token_priority + 2;
+                swap_token_mm = current->mm;
+                goto out;
+        }
-                mm = swap_token_mm;
+        if (current->mm != swap_token_mm) {
-                if ((reason = should_release_swap_token(mm))) {
+                if (current_interval < current->mm->last_interval)
-                        unsigned long eligible = jiffies;
+                        current->mm->token_priority++;
-                        if (reason == SWAP_TOKEN_TIMED_OUT) {
+                else {
-                                eligible += swap_token_default_timeout;
+                        current->mm->token_priority--;
-                        }
+                        if (unlikely(current->mm->token_priority < 0))
-                        mm->swap_token_time = eligible;
+                                current->mm->token_priority = 0;
-                        swap_token_timeout = jiffies + swap_token_default_timeout;
+                }
+                /* Check if we deserve the token */
+                if (current->mm->token_priority >
+                                swap_token_mm->token_priority) {
+                        current->mm->token_priority += 2;
                        swap_token_mm = current->mm;
                }
-                spin_unlock(&swap_token_lock);
+        } else {
+                /* Token holder came in again! */
+                current->mm->token_priority += 2;
        }
-        return;
+out:
+        current->mm->faultstamp = global_faults;
+        current->mm->last_interval = current_interval;
+        spin_unlock(&swap_token_lock);
+return;
 }
 /* Called on process exit. */
 void __put_swap_token(struct mm_struct *mm)
 {
        spin_lock(&swap_token_lock);
-        if (likely(mm == swap_token_mm)) {
+        if (likely(mm == swap_token_mm))
-                mm->swap_token_time = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
+                swap_token_mm = NULL;
-                swap_token_mm = &init_mm;
-                swap_token_check = jiffies;
-        }
        spin_unlock(&swap_token_lock);
 }

diff --git a/mm/thrash.c b/mm/thrash.c index f4c560b4a2b7..19e428ca8b03 100644 --- a/mm/thrash.c +++ b/mm/thrash.c
@@ -7,100 +7,74 @@
7	*	7	*
8	* Simple token based thrashing protection, using the algorithm	8	* Simple token based thrashing protection, using the algorithm
9	* described in: http://www.cs.wm.edu/~sjiang/token.pdf	9	* described in: http://www.cs.wm.edu/~sjiang/token.pdf
		10	*
		11	* Sep 2006, Ashwin Chaugule <ashwin.chaugule@celunite.com>
		12	* Improved algorithm to pass token:
		13	* Each task has a priority which is incremented if it contended
		14	* for the token in an interval less than its previous attempt.
		15	* If the token is acquired, that task's priority is boosted to prevent
		16	* the token from bouncing around too often and to let the task make
		17	* some progress in its execution.
10	*/	18	*/
		19
11	#include <linux/jiffies.h>	20	#include <linux/jiffies.h>
12	#include <linux/mm.h>	21	#include <linux/mm.h>
13	#include <linux/sched.h>	22	#include <linux/sched.h>
14	#include <linux/swap.h>	23	#include <linux/swap.h>
15		24
16	static DEFINE_SPINLOCK(swap_token_lock);	25	static DEFINE_SPINLOCK(swap_token_lock);
17	static unsigned long swap_token_timeout;	26	struct mm_struct *swap_token_mm;
18	static unsigned long swap_token_check;	27	unsigned int global_faults;
19	struct mm_struct * swap_token_mm = &init_mm;
20
21	#define SWAP_TOKEN_CHECK_INTERVAL (HZ * 2)
22	#define SWAP_TOKEN_TIMEOUT (300 * HZ)
23	/*
24	* Currently disabled; Needs further code to work at HZ * 300.
25	*/
26	unsigned long swap_token_default_timeout = SWAP_TOKEN_TIMEOUT;
27
28	/*
29	* Take the token away if the process had no page faults
30	* in the last interval, or if it has held the token for
31	* too long.
32	*/
33	#define SWAP_TOKEN_ENOUGH_RSS 1
34	#define SWAP_TOKEN_TIMED_OUT 2
35	static int should_release_swap_token(struct mm_struct *mm)
36	{
37	int ret = 0;
38	if (!mm->recent_pagein)
39	ret = SWAP_TOKEN_ENOUGH_RSS;
40	else if (time_after(jiffies, swap_token_timeout))
41	ret = SWAP_TOKEN_TIMED_OUT;
42	mm->recent_pagein = 0;
43	return ret;
44	}
45		28
46	/*
47	* Try to grab the swapout protection token. We only try to
48	* grab it once every TOKEN_CHECK_INTERVAL, both to prevent
49	* SMP lock contention and to check that the process that held
50	* the token before is no longer thrashing.
51	*/
52	void grab_swap_token(void)	29	void grab_swap_token(void)
53	{	30	{
54	struct mm_struct *mm;	31	int current_interval;
55	int reason;
56		32
57	/* We have the token. Let others know we still need it. */	33	global_faults++;
58	if (has_swap_token(current->mm)) {
59	current->mm->recent_pagein = 1;
60	if (unlikely(!swap_token_default_timeout))
61	disable_swap_token();
62	return;
63	}
64
65	if (time_after(jiffies, swap_token_check)) {
66		34
67	if (!swap_token_default_timeout) {	35	current_interval = global_faults - current->mm->faultstamp;
68	swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
69	return;
70	}
71
72	/* ... or if we recently held the token. */
73	if (time_before(jiffies, current->mm->swap_token_time))
74	return;
75		36
76	if (!spin_trylock(&swap_token_lock))	37	if (!spin_trylock(&swap_token_lock))
77	return;	38	return;
78		39
79	swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;	40	/* First come first served */
		41	if (swap_token_mm == NULL) {
		42	current->mm->token_priority = current->mm->token_priority + 2;
		43	swap_token_mm = current->mm;
		44	goto out;
		45	}
80		46
81	mm = swap_token_mm;	47	if (current->mm != swap_token_mm) {
82	if ((reason = should_release_swap_token(mm))) {	48	if (current_interval < current->mm->last_interval)
83	unsigned long eligible = jiffies;	49	current->mm->token_priority++;
84	if (reason == SWAP_TOKEN_TIMED_OUT) {	50	else {
85	eligible += swap_token_default_timeout;	51	current->mm->token_priority--;
86	}	52	if (unlikely(current->mm->token_priority < 0))
87	mm->swap_token_time = eligible;	53	current->mm->token_priority = 0;
88	swap_token_timeout = jiffies + swap_token_default_timeout;	54	}
		55	/* Check if we deserve the token */
		56	if (current->mm->token_priority >
		57	swap_token_mm->token_priority) {
		58	current->mm->token_priority += 2;
89	swap_token_mm = current->mm;	59	swap_token_mm = current->mm;
90	}	60	}
91	spin_unlock(&swap_token_lock);	61	} else {
		62	/* Token holder came in again! */
		63	current->mm->token_priority += 2;
92	}	64	}
93	return;	65
		66	out:
		67	current->mm->faultstamp = global_faults;
		68	current->mm->last_interval = current_interval;
		69	spin_unlock(&swap_token_lock);
		70	return;
94	}	71	}
95		72
96	/* Called on process exit. */	73	/* Called on process exit. */
97	void __put_swap_token(struct mm_struct *mm)	74	void __put_swap_token(struct mm_struct *mm)
98	{	75	{
99	spin_lock(&swap_token_lock);	76	spin_lock(&swap_token_lock);
100	if (likely(mm == swap_token_mm)) {	77	if (likely(mm == swap_token_mm))
101	mm->swap_token_time = jiffies + SWAP_TOKEN_CHECK_INTERVAL;	78	swap_token_mm = NULL;
102	swap_token_mm = &init_mm;
103	swap_token_check = jiffies;
104	}
105	spin_unlock(&swap_token_lock);	79	spin_unlock(&swap_token_lock);
106	}	80	}