kernel26-magellan/patches-2.6.16-r10/0026-2.6.16-sp-resume1.patch

---
 Documentation/sysctl/vm.txt |    9 +++
 mm/swap_prefetch.c          |  119 +++++++++++++++++++++++++++++---------------
 2 files changed, 90 insertions(+), 38 deletions(-)

Index: linux-2.6.16-ck1/mm/swap_prefetch.c
===================================================================
--- linux-2.6.16-ck1.orig/mm/swap_prefetch.c	2006-03-20 20:46:55.000000000 +1100
+++ linux-2.6.16-ck1/mm/swap_prefetch.c	2006-03-20 20:47:00.000000000 +1100
@@ -27,8 +27,18 @@
  */
 #define PREFETCH_DELAY	(HZ * 5)
 
-/* sysctl - enable/disable swap prefetching */
-int swap_prefetch __read_mostly = 1;
+#define PREFETCH_NORMAL		(1 << 0)
+#define PREFETCH_AGGRESSIVE 	(1 << 1)
+/*
+ * sysctl - enable/disable swap prefetching bits
+ * This is composed of the bitflags PREFETCH_NORMAL and PREFETCH_AGGRESSIVE.
+ * Once PREFETCH_AGGRESSIVE is set, swap prefetching will be peformed as much
+ * as possible irrespective of load conditions and then the
+ * PREFETCH_AGGRESSIVE bit will be unset.
+ */
+int swap_prefetch __read_mostly = PREFETCH_NORMAL;
+
+#define aggressive_prefetch	(unlikely(swap_prefetch & PREFETCH_AGGRESSIVE))
 
 struct swapped_root {
 	unsigned long		busy;		/* vm busy */
@@ -291,43 +301,17 @@ static void examine_free_limits(void)
 }
 
 /*
- * We want to be absolutely certain it's ok to start prefetching.
+ * Have some hysteresis between where page reclaiming and prefetching
+ * will occur to prevent ping-ponging between them.
  */
-static int prefetch_suitable(void)
+static void set_suitable_nodes(void)
 {
-	unsigned long limit;
 	struct zone *z;
-	int node, ret = 0, test_pagestate = 0;
-
-	/* Purposefully racy */
-	if (test_bit(0, &swapped.busy)) {
-		__clear_bit(0, &swapped.busy);
-		goto out;
-	}
-
-	/*
-	 * get_page_state and above_background_load are expensive so we only
-	 * perform them every SWAP_CLUSTER_MAX prefetched_pages.
-	 * We test to see if we're above_background_load as disk activity
-	 * even at low priority can cause interrupt induced scheduling
-	 * latencies.
-	 */
-	if (!(sp_stat.prefetched_pages % SWAP_CLUSTER_MAX)) {
-		if (above_background_load())
-			goto out;
-		test_pagestate = 1;
-	}
 
-	clear_current_prefetch_free();
-
-	/*
-	 * Have some hysteresis between where page reclaiming and prefetching
-	 * will occur to prevent ping-ponging between them.
-	 */
 	for_each_zone(z) {
 		struct node_stats *ns;
 		unsigned long free;
-		int idx;
+		int node, idx;
 
 		if (!populated_zone(z))
 			continue;
@@ -349,6 +333,45 @@ static int prefetch_suitable(void)
 		}
 		ns->current_free += free;
 	}
+}
+
+/*
+ * We want to be absolutely certain it's ok to start prefetching.
+ */
+static int prefetch_suitable(void)
+{
+	unsigned long limit;
+	int node, ret = 0, test_pagestate = 0;
+
+	if (aggressive_prefetch) {
+		clear_current_prefetch_free();
+		set_suitable_nodes();
+		if (!nodes_empty(sp_stat.prefetch_nodes))
+			ret = 1;
+		goto out;
+	}
+
+	/* Purposefully racy */
+	if (test_bit(0, &swapped.busy)) {
+		__clear_bit(0, &swapped.busy);
+		goto out;
+	}
+
+	/*
+	 * get_page_state and above_background_load are expensive so we only
+	 * perform them every SWAP_CLUSTER_MAX prefetched_pages.
+	 * We test to see if we're above_background_load as disk activity
+	 * even at low priority can cause interrupt induced scheduling
+	 * latencies.
+	 */
+	if (!(sp_stat.prefetched_pages % SWAP_CLUSTER_MAX)) {
+		if (above_background_load())
+			goto out;
+		test_pagestate = 1;
+	}
+
+	clear_current_prefetch_free();
+	set_suitable_nodes();
 
 	/*
 	 * We iterate over each node testing to see if it is suitable for
@@ -421,6 +444,17 @@ static inline struct swapped_entry *prev
 		struct swapped_entry, swapped_list);
 }
 
+static unsigned long pages_prefetched(void)
+{
+	unsigned long pages = sp_stat.prefetched_pages;
+
+	if (pages) {
+		lru_add_drain();
+		sp_stat.prefetched_pages = 0;
+	}
+	return pages;
+}
+
 /*
  * trickle_swap is the main function that initiates the swap prefetching. It
  * first checks to see if the busy flag is set, and does not prefetch if it
@@ -438,7 +472,7 @@ static enum trickle_return trickle_swap(
 	 * If laptop_mode is enabled don't prefetch to avoid hard drives
 	 * doing unnecessary spin-ups
 	 */
-	if (!swap_prefetch || laptop_mode)
+	if (!swap_prefetch || (laptop_mode && !aggressive_prefetch))
 		return ret;
 
 	examine_free_limits();
@@ -474,6 +508,14 @@ static enum trickle_return trickle_swap(
 			 * delay attempting further prefetching.
 			 */
 			spin_unlock(&swapped.lock);
+			if (aggressive_prefetch) {
+				/*
+				 * If we're prefetching aggressively and
+				 * making progress then don't give up.
+				 */
+				if (pages_prefetched())
+					continue;
+			}
 			break;
 		}
 
@@ -491,14 +533,15 @@ static enum trickle_return trickle_swap(
 		entry = prev_swapped_entry(entry);
 		spin_unlock(&swapped.lock);
 
-		if (trickle_swap_cache_async(swp_entry, node) == TRICKLE_DELAY)
+		if (trickle_swap_cache_async(swp_entry, node) == TRICKLE_DELAY &&
+		    !aggressive_prefetch)
 			break;
 	}
 
-	if (sp_stat.prefetched_pages) {
-		lru_add_drain();
-		sp_stat.prefetched_pages = 0;
-	}
+	/* Return value of pages_prefetched irrelevant here */
+	pages_prefetched();
+	if (aggressive_prefetch)
+		swap_prefetch &= ~PREFETCH_AGGRESSIVE;
 	return ret;
 }
 
Index: linux-2.6.16-ck1/Documentation/sysctl/vm.txt
===================================================================
--- linux-2.6.16-ck1.orig/Documentation/sysctl/vm.txt	2006-03-20 20:46:55.000000000 +1100
+++ linux-2.6.16-ck1/Documentation/sysctl/vm.txt	2006-03-20 20:47:00.000000000 +1100
@@ -188,4 +188,13 @@ memory subsystem has been extremely idle
 copying back pages from swap into the swapcache and keep a copy in swap. In
 practice it can take many minutes before the vm is idle enough.
 
+This is value ORed together of
+1	= Normal background swap prefetching when load is light
+2	= Aggressively swap prefetch as much as possible
+
+When 2 is set, after the maximum amount possible has been prefetched, this bit
+is unset. ie Setting the value to 3 will prefetch aggressively then drop to 1.
+This is useful for doing aggressive prefetching for short periods in scripts
+such as after resuming from software suspend.
+
 The default value is 1.
1	---
2	Documentation/sysctl/vm.txt \| 9 +++
3	mm/swap_prefetch.c \| 119 +++++++++++++++++++++++++++++---------------
4	2 files changed, 90 insertions(+), 38 deletions(-)
5
6	Index: linux-2.6.16-ck1/mm/swap_prefetch.c
7	===================================================================
8	--- linux-2.6.16-ck1.orig/mm/swap_prefetch.c 2006-03-20 20:46:55.000000000 +1100
9	+++ linux-2.6.16-ck1/mm/swap_prefetch.c 2006-03-20 20:47:00.000000000 +1100
10	@@ -27,8 +27,18 @@
11	*/
12	#define PREFETCH_DELAY (HZ * 5)
13
14	-/* sysctl - enable/disable swap prefetching */
15	-int swap_prefetch __read_mostly = 1;
16	+#define PREFETCH_NORMAL (1 << 0)
17	+#define PREFETCH_AGGRESSIVE (1 << 1)
18	+/*
19	+ * sysctl - enable/disable swap prefetching bits
20	+ * This is composed of the bitflags PREFETCH_NORMAL and PREFETCH_AGGRESSIVE.
21	+ * Once PREFETCH_AGGRESSIVE is set, swap prefetching will be peformed as much
22	+ * as possible irrespective of load conditions and then the
23	+ * PREFETCH_AGGRESSIVE bit will be unset.
24	+ */
25	+int swap_prefetch __read_mostly = PREFETCH_NORMAL;
26	+
27	+#define aggressive_prefetch (unlikely(swap_prefetch & PREFETCH_AGGRESSIVE))
28
29	struct swapped_root {
30	unsigned long busy; /* vm busy */
31	@@ -291,43 +301,17 @@ static void examine_free_limits(void)
32	}
33
34	/*
35	- * We want to be absolutely certain it's ok to start prefetching.
36	+ * Have some hysteresis between where page reclaiming and prefetching
37	+ * will occur to prevent ping-ponging between them.
38	*/
39	-static int prefetch_suitable(void)
40	+static void set_suitable_nodes(void)
41	{
42	- unsigned long limit;
43	struct zone *z;
44	- int node, ret = 0, test_pagestate = 0;
45	-
46	- /* Purposefully racy */
47	- if (test_bit(0, &swapped.busy)) {
48	- __clear_bit(0, &swapped.busy);
49	- goto out;
50	- }
51	-
52	- /*
53	- * get_page_state and above_background_load are expensive so we only
54	- * perform them every SWAP_CLUSTER_MAX prefetched_pages.
55	- * We test to see if we're above_background_load as disk activity
56	- * even at low priority can cause interrupt induced scheduling
57	- * latencies.
58	- */
59	- if (!(sp_stat.prefetched_pages % SWAP_CLUSTER_MAX)) {
60	- if (above_background_load())
61	- goto out;
62	- test_pagestate = 1;
63	- }
64
65	- clear_current_prefetch_free();
66	-
67	- /*
68	- * Have some hysteresis between where page reclaiming and prefetching
69	- * will occur to prevent ping-ponging between them.
70	- */
71	for_each_zone(z) {
72	struct node_stats *ns;
73	unsigned long free;
74	- int idx;
75	+ int node, idx;
76
77	if (!populated_zone(z))
78	continue;
79	@@ -349,6 +333,45 @@ static int prefetch_suitable(void)
80	}
81	ns->current_free += free;
82	}
83	+}
84	+
85	+/*
86	+ * We want to be absolutely certain it's ok to start prefetching.
87	+ */
88	+static int prefetch_suitable(void)
89	+{
90	+ unsigned long limit;
91	+ int node, ret = 0, test_pagestate = 0;
92	+
93	+ if (aggressive_prefetch) {
94	+ clear_current_prefetch_free();
95	+ set_suitable_nodes();
96	+ if (!nodes_empty(sp_stat.prefetch_nodes))
97	+ ret = 1;
98	+ goto out;
99	+ }
100	+
101	+ /* Purposefully racy */
102	+ if (test_bit(0, &swapped.busy)) {
103	+ __clear_bit(0, &swapped.busy);
104	+ goto out;
105	+ }
106	+
107	+ /*
108	+ * get_page_state and above_background_load are expensive so we only
109	+ * perform them every SWAP_CLUSTER_MAX prefetched_pages.
110	+ * We test to see if we're above_background_load as disk activity
111	+ * even at low priority can cause interrupt induced scheduling
112	+ * latencies.
113	+ */
114	+ if (!(sp_stat.prefetched_pages % SWAP_CLUSTER_MAX)) {
115	+ if (above_background_load())
116	+ goto out;
117	+ test_pagestate = 1;
118	+ }
119	+
120	+ clear_current_prefetch_free();
121	+ set_suitable_nodes();
122
123	/*
124	* We iterate over each node testing to see if it is suitable for
125	@@ -421,6 +444,17 @@ static inline struct swapped_entry *prev
126	struct swapped_entry, swapped_list);
127	}
128
129	+static unsigned long pages_prefetched(void)
130	+{
131	+ unsigned long pages = sp_stat.prefetched_pages;
132	+
133	+ if (pages) {
134	+ lru_add_drain();
135	+ sp_stat.prefetched_pages = 0;
136	+ }
137	+ return pages;
138	+}
139	+
140	/*
141	* trickle_swap is the main function that initiates the swap prefetching. It
142	* first checks to see if the busy flag is set, and does not prefetch if it
143	@@ -438,7 +472,7 @@ static enum trickle_return trickle_swap(
144	* If laptop_mode is enabled don't prefetch to avoid hard drives
145	* doing unnecessary spin-ups
146	*/
147	- if (!swap_prefetch \|\| laptop_mode)
148	+ if (!swap_prefetch \|\| (laptop_mode && !aggressive_prefetch))
149	return ret;
150
151	examine_free_limits();
152	@@ -474,6 +508,14 @@ static enum trickle_return trickle_swap(
153	* delay attempting further prefetching.
154	*/
155	spin_unlock(&swapped.lock);
156	+ if (aggressive_prefetch) {
157	+ /*
158	+ * If we're prefetching aggressively and
159	+ * making progress then don't give up.
160	+ */
161	+ if (pages_prefetched())
162	+ continue;
163	+ }
164	break;
165	}
166
167	@@ -491,14 +533,15 @@ static enum trickle_return trickle_swap(
168	entry = prev_swapped_entry(entry);
169	spin_unlock(&swapped.lock);
170
171	- if (trickle_swap_cache_async(swp_entry, node) == TRICKLE_DELAY)
172	+ if (trickle_swap_cache_async(swp_entry, node) == TRICKLE_DELAY &&
173	+ !aggressive_prefetch)
174	break;
175	}
176
177	- if (sp_stat.prefetched_pages) {
178	- lru_add_drain();
179	- sp_stat.prefetched_pages = 0;
180	- }
181	+ /* Return value of pages_prefetched irrelevant here */
182	+ pages_prefetched();
183	+ if (aggressive_prefetch)
184	+ swap_prefetch &= ~PREFETCH_AGGRESSIVE;
185	return ret;
186	}
187
188	Index: linux-2.6.16-ck1/Documentation/sysctl/vm.txt
189	===================================================================
190	--- linux-2.6.16-ck1.orig/Documentation/sysctl/vm.txt 2006-03-20 20:46:55.000000000 +1100
191	+++ linux-2.6.16-ck1/Documentation/sysctl/vm.txt 2006-03-20 20:47:00.000000000 +1100
192	@@ -188,4 +188,13 @@ memory subsystem has been extremely idle
193	copying back pages from swap into the swapcache and keep a copy in swap. In
194	practice it can take many minutes before the vm is idle enough.
195
196	+This is value ORed together of
197	+1 = Normal background swap prefetching when load is light
198	+2 = Aggressively swap prefetch as much as possible
199	+
200	+When 2 is set, after the maximum amount possible has been prefetched, this bit
201	+is unset. ie Setting the value to 3 will prefetch aggressively then drop to 1.
202	+This is useful for doing aggressive prefetching for short periods in scripts
203	+such as after resuming from software suspend.
204	+
205	The default value is 1.