Swap token re-tuned

New scheme to preempt token.

index 34ed0d9..417bbe4 100644
@@ -342,9 +342,15 @@ struct mm_struct {
   /* Architecture-specific MM context */
   mm_context_t context;
 
-    /* Token based thrashing protection. */
-    unsigned long swap_token_time;
-    char recent_pagein;
+    /* Swap token stuff */
+    /* Last value of global fault stamp as seen by this process.
+     * In other words, this value gives an indication of how long
+     * it has been since this task got the token */
+    unsigned int faultstamp;
+
+       /* Deciding factor ! Increment if (global_faults - faultstamp < 5)
+        * else decrement. High priority wins the token.*/
+    int token_priority;
 
   /* coredumping support */
   int core_waiters;

index e7c36ba..89f8a39 100644
@@ -259,7 +259,6 @@ extern spinlock_t swap_lock;
 

/* linux/mm/thrash.c */
extern struct mm_struct * swap_token_mm;
-extern unsigned long swap_token_default_timeout;
extern void grab_swap_token(void);
extern void __put_swap_token(struct mm_struct *);

index fd43c3e..60e6445 100644
@@ -910,6 +910,7 @@ #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
       .extra1        = &zero,
   },

#endif
+#if 0 /* Not needed anymore */
#ifdef CONFIG_SWAP
{
.ctl_name = VM_SWAP_TOKEN_TIMEOUT,
@@ -921,6 +922,7 @@ #ifdef CONFIG_SWAP
.strategy = &sysctl_jiffies,
},
#endif
+#endif
#ifdef CONFIG_NUMA
{
.ctl_name = VM_ZONE_RECLAIM_MODE,

index f4c560b..21d29f2 100644
@@ -14,83 +14,73 @@ #include <linux/sched.h>

#include <linux/swap.h>

static DEFINE_SPINLOCK(swap_token_lock);
-static unsigned long swap_token_timeout;
-static unsigned long swap_token_check;
-struct mm_struct * swap_token_mm = &init_mm;
+struct mm_struct * swap_token_mm = NULL;
+unsigned long global_faults = 0;

-#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; +#define SWAP_TOKEN_PREEMPT 1
+#define FAULTSTAMP_DIFF 5

-/*
- * 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;
+    if ( current->mm->token_priority > mm->token_priority )

+ return ret = SWAP_TOKEN_PREEMPT;
+ else
+ 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;
+ struct mm_struct *mm_temp;
int reason;

- /* We have the token. Let others know we still need it. */
- if (has_swap_token(current->mm)) {
- current->mm->recent_pagein = 1;
- if (unlikely(!swap_token_default_timeout))
- disable_swap_token();
+ /* This gives an indication of the number of processes contending for the token.*/
+ global_faults++;
+
+ if (!spin_trylock(&swap_token_lock))

       return;

- }

-    if (time_after(jiffies, swap_token_check)) {
+    /* First come first served. If a process holding the token exits, its up for grabs immediately */
+    if ( swap_token_mm == NULL ) {
+        swap_token_mm = current->mm;
+        swap_token_mm->faultstamp = global_faults;
+        goto out;

+ }

- if (!swap_token_default_timeout) {
- swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
- return;
- }
+ if ((global_faults - current->mm->faultstamp) < FAULTSTAMP_DIFF ) {

- /* ... or if we recently held the token. */
- if (time_before(jiffies, current->mm->swap_token_time))
- return;

+    /*  This would mean that too many of the current tasks pages
+     *  have been evicted and therefore it's calling swap-in or no-page
+     *  too frequently. */

- if (!spin_trylock(&swap_token_lock))
- return;

+        current->mm->faultstamp = global_faults;
+        current->mm->token_priority++;
+        mm_temp = swap_token_mm;
+    }
+    else {
+    /* Decrement priority to ensure that the token holder doesnt

+ * hold on to it for too long. */

- swap_token_check = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
+ if (current->mm->token_priority > 0)
+ current->mm->token_priority--;
+ else {
+ /* After this, the process will be able to contend for the token
+ * again.*/

- mm = swap_token_mm;
- if ((reason = should_release_swap_token(mm))) {
- unsigned long eligible = jiffies;
- if (reason == SWAP_TOKEN_TIMED_OUT) {
- eligible += swap_token_default_timeout;

-            }
-            mm->swap_token_time = eligible;
-            swap_token_timeout = jiffies + swap_token_default_timeout;
-            swap_token_mm = current->mm;
+            current->mm->token_priority = 0;
+            current->mm->faultstamp = global_faults;
       }

- spin_unlock(&swap_token_lock);
+ goto out;
}
- return;
+
+ if ((reason = should_release_swap_token(mm_temp))) {
+ current->mm->faultstamp = global_faults;
+ swap_token_mm = current->mm;
+ }
+
+out:
+ spin_unlock(&swap_token_lock);
+return;
}

/* Called on process exit. */
@@ -98,9 +88,7 @@ void __put_swap_token(struct mm_struct * {
spin_lock(&swap_token_lock);
if (likely(mm == swap_token_mm)) {

-        mm->swap_token_time = jiffies + SWAP_TOKEN_CHECK_INTERVAL;
-        swap_token_mm = &init_mm;
-        swap_token_check = jiffies;
+        swap_token_mm = NULL;

}
spin_unlock(&swap_token_lock);
}

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>