Signed-off-by: Andrew Morton <akpm@osdl.org>
---
25-akpm/mm/filemap.c | 9 +++-
25-akpm/mm/readahead.c | 102 ++++++++++++++++++++++---------------------------
2 files changed, 54 insertions(+), 57 deletions(-)
diff -puN mm/filemap.c~simplified-readahead-cleanups mm/filemap.c
--- 25/mm/filemap.c~simplified-readahead-cleanups 2004-12-04 00:07:07.466440304 -0800
+++ 25-akpm/mm/filemap.c 2004-12-04 00:07:07.473439240 -0800
@@ -689,14 +689,19 @@ void do_generic_mapping_read(struct addr
read_actor_t actor)
{
struct inode *inode = mapping->host;
- unsigned long index, end_index, offset, req_size, next_index;
+ unsigned long index;
+ unsigned long end_index;
+ unsigned long offset;
+ unsigned long req_size;
+ unsigned long next_index;
loff_t isize;
struct page *cached_page;
int error;
struct file_ra_state ra = *_ra;
cached_page = NULL;
- next_index = index = *ppos >> PAGE_CACHE_SHIFT;
+ index = *ppos >> PAGE_CACHE_SHIFT;
+ next_index = index;
req_size = (desc->count + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
offset = *ppos & ~PAGE_CACHE_MASK;
diff -puN mm/readahead.c~simplified-readahead-cleanups mm/readahead.c
--- 25/mm/readahead.c~simplified-readahead-cleanups 2004-12-04 00:07:07.468440000 -0800
+++ 25-akpm/mm/readahead.c 2004-12-04 00:07:20.022531488 -0800
@@ -54,7 +54,7 @@ static inline void ra_off(struct file_ra
{
ra->start = 0;
ra->flags = 0;
- ra->size = -1UL;
+ ra->size = -1;
ra->ahead_start = 0;
ra->ahead_size = 0;
return;
@@ -66,47 +66,40 @@ static inline void ra_off(struct file_ra
* for 128k (32 page) max ra
* 1-8 page = 32k initial, > 8 page = 128k initial
*/
-unsigned long get_init_ra_size(unsigned long size, unsigned long max)
+static unsigned long get_init_ra_size(unsigned long size, unsigned long max)
{
- unsigned long s_size=1, newsize;
+ unsigned long newsize = roundup_pow_of_two(size);
- do {
- s_size = s_size << 1;
- } while ((size = size >> 1));
- if (s_size <= max / 64) {
- newsize = s_size * s_size;
- } else if (s_size <= max/4) {
+ if (newsize <= max / 64)
+ newsize = newsize * newsize;
+ else if (newsize <= max / 4)
newsize = max / 4;
- } else {
+ else
newsize = max;
- }
return newsize;
}
/*
- * Set the new window size, this is called only when
- * I/O is to be submitted, not for each call to readahead
- * If cache miss occered, reduce next I/O size, else
- * increase depending on how close to max we are.
+ * Set the new window size, this is called only when I/O is to be submitted,
+ * not for each call to readahead. If a cache miss occured, reduce next I/O
+ * size, else increase depending on how close to max we are.
*/
-unsigned long get_next_ra_size(unsigned long cur, unsigned long max,
+static unsigned long get_next_ra_size(unsigned long cur, unsigned long max,
unsigned long min, unsigned long * flags)
{
unsigned long newsize;
if (*flags & RA_FLAG_MISS) {
- newsize = max((cur - 2),min);
+ newsize = max((cur - 2), min);
*flags &= ~RA_FLAG_MISS;
- } else if ( cur < max/16 ) {
+ } else if (cur < max / 16) {
newsize = 4 * cur;
} else {
newsize = 2 * cur;
}
- newsize = min(newsize, max);
- return newsize;
+ return min(newsize, max);
}
-
#define list_to_page(head) (list_entry((head)->prev, struct page, lru))
/**
@@ -207,9 +200,8 @@ out:
* ahead_size: Together, these form the "ahead window".
* ra_pages: The externally controlled max readahead for this fd.
*
- * When readahead is in the off state (size == -1UL),
- * readahead is disabled. In this state, prev_page is used
- * to detect the resumption of sequential I/O.
+ * When readahead is in the off state (size == -1UL), readahead is disabled.
+ * In this state, prev_page is used to detect the resumption of sequential I/O.
*
* The readahead code manages two windows - the "current" and the "ahead"
* windows. The intent is that while the application is walking the pages
@@ -376,9 +368,6 @@ int do_page_cache_readahead(struct addre
return __do_page_cache_readahead(mapping, filp, offset, nr_to_read);
}
-
-
-
/*
* page_cache_readahead is the main function. If performs the adaptive
* readahead window size management and submits the readahead I/O.
@@ -388,7 +377,8 @@ page_cache_readahead(struct address_spac
struct file *filp, unsigned long offset,
unsigned long req_size)
{
- unsigned long max, min, newsize=req_size;
+ unsigned long max, min;
+ unsigned long newsize = req_size;
unsigned long actual=0;
/*
@@ -397,37 +387,37 @@ page_cache_readahead(struct address_spac
* perturbing the readahead window expansion logic.
* If size is zero, there is no read ahead window so we need one
*/
- if (offset == ra->prev_page && req_size == 1 && ra->size != 0) {
+ if (offset == ra->prev_page && req_size == 1 && ra->size != 0)
goto out;
- }
max = get_max_readahead(ra);
min = get_min_readahead(ra);
// maxsane = max_sane_readahead(max);
newsize = min(req_size, max);
- if (newsize == 0 || (ra->flags & RA_FLAG_INCACHE)){
+ if (newsize == 0 || (ra->flags & RA_FLAG_INCACHE)) {
newsize = 1;
- goto out; /* No readahead or file already in cache*/
+ goto out; /* No readahead or file already in cache */
}
/*
- * Special case - first read.
- * We'll assume it's a whole-file read if at start of file, and
- * grow the window fast.
- * or detect first sequential access
+ * Special case - first read. We'll assume it's a whole-file read if
+ * at start of file, and grow the window fast. Or detect first
+ * sequential access
*/
- if ((ra->size == 0 && offset == 0) // first io and start of file
- || (ra->size == -1UL && ra->prev_page == offset-1)) { //1st seq
+ if ((ra->size == 0 && offset == 0) /* first io and start of file */
+ || (ra->size == -1 && ra->prev_page == offset - 1)) {
+ /* First sequential */
ra->prev_page = offset + newsize-1;
ra->size = get_init_ra_size(newsize, max);
ra->start = offset;
actual = do_page_cache_readahead(mapping, filp, offset,
- ra->size);
- if (!check_ra_success(ra, ra->size, actual)) {
+ ra->size);
+ if (!check_ra_success(ra, ra->size, actual))
goto out;
- }
- /* if the request size is larger than our max readahead, we
- * at least want to be sure that we get 2 IOs if flight and
+
+ /*
+ * If the request size is larger than our max readahead, we
+ * at least want to be sure that we get 2 IOs in flight and
* we know that we will definitly need the new I/O.
* once we do this, subsequent calls should be able to overlap
* IOs,* thus preventing stalls. so issue the ahead window
@@ -444,7 +434,8 @@ page_cache_readahead(struct address_spac
goto out;
}
- /* now handle the random case:
+ /*
+ * Now handle the random case:
* partial page reads and first access were handled above,
* so this must be the next page otherwise it is random
*/
@@ -457,8 +448,9 @@ page_cache_readahead(struct address_spac
goto out;
}
- /* If we get here we are doing sequential IO and this was
- * not the first occurence (ie we have an existing window)
+ /*
+ * If we get here we are doing sequential IO and this was not the first
+ * occurence (ie we have an existing window)
*/
if (ra->ahead_start == 0) { /* no ahead window yet */
@@ -468,16 +460,16 @@ page_cache_readahead(struct address_spac
newsize = min (newsize, ra->ahead_start - offset);
actual = do_page_cache_readahead(mapping, filp,
ra->ahead_start, ra->ahead_size);
- if (!check_ra_success(ra, ra->ahead_size, actual)) {
+ if (!check_ra_success(ra, ra->ahead_size, actual))
goto out;
- }
}
- /* already have an ahead window, check if we crossed into it
- if so, shift windows and issue a new ahead window.
- Only return the #pages that are in the current window, so that
- we get called back on the first page of the ahead window which
- will allow us to submit more IO.
- */
+ /*
+ * Already have an ahead window, check if we crossed into it if so,
+ * shift windows and issue a new ahead window.
+ * Only return the #pages that are in the current window, so that we
+ * get called back on the first page of the ahead window which will
+ * allow us to submit more IO.
+ */
if ((offset + newsize -1) >= ra->ahead_start) {
ra->start = ra->ahead_start;
ra->size = ra->ahead_size;
@@ -500,7 +492,7 @@ out:
* not found. This will happen if it was evicted by the VM (readahead
* thrashing)
*
- * turn on the cache miss flag in the RA struct, this will cause the RA code
+ * Turn on the cache miss flag in the RA struct, this will cause the RA code
* to reduce the RA size on the next read.
*/
void handle_ra_miss(struct address_space *mapping,
_