> But try 2.4.1 before worrying too much. That fixed a lot of the
> block performance problems I was seeing (2.4.1 ruins the VM
> performance under paging loads but the I/O speed is fixed ;))
The patch below should fix the paging performance.
I haven't had a whole lot of time to test this (and I won't
have much time due to yet another LVM bug making my workstation
unusable under 2.4 ;(), but it seems to curb worst-case behaviour
during heavy swapping and IO load very fine.
On my home machine (64MB K6-2 500) I didn't manage to make my
mp3 skip while under both heavy paging load and heavy IO load
(using a few of the "standard" benchmark programs).
regards,
Rik
-- Linux MM bugzilla: http://linux-mm.org/bugzilla.shtmlVirtual memory is like a game you can't win; However, without VM there's truly nothing to lose...
http://www.surriel.com/ http://www.conectiva.com/ http://distro.conectiva.com/
--- linux-2.4.1/fs/buffer.c.orig Tue Jan 30 18:13:19 2001 +++ linux-2.4.1/fs/buffer.c Mon Feb 5 09:59:37 2001 @@ -1052,16 +1052,6 @@ return 0; } - /* - * If we are about to get low on free pages and - * cleaning the inactive_dirty pages would help - * fix this, wake up bdflush. - */ - shortage = free_shortage(); - if (shortage && nr_inactive_dirty_pages > shortage && - nr_inactive_dirty_pages > freepages.high) - return 0; - return -1; } --- linux-2.4.1/mm/filemap.c.orig Tue Jan 30 17:02:23 2001 +++ linux-2.4.1/mm/filemap.c Tue Jan 30 17:25:29 2001 @@ -286,6 +286,34 @@ spin_unlock(&pagecache_lock); } +/* + * This function is pretty much like __find_page_nolock(), but it only + * requires 2 arguments and doesn't mark the page as touched, making it + * ideal for ->writepage() clustering and other places where you don't + * want to mark the page referenced. + * + * The caller needs to hold the pagecache_lock. + */ +struct page * __find_page_simple(struct address_space *mapping, unsigned long index) +{ + struct page * page = *page_hash(mapping, index); + goto inside; + + for (;;) { + page = page->next_hash; +inside: + if (!page) + goto not_found; + if (page->mapping != mapping) + continue; + if (page->index == index) + break; + } + +not_found: + return page; +} + static inline struct page * __find_page_nolock(struct address_space *mapping, unsigned long offset, struct page *page) { goto inside; @@ -301,13 +329,14 @@ break; } /* - * Touching the page may move it to the active list. - * If we end up with too few inactive pages, we wake - * up kswapd. + * Mark the page referenced, moving inactive pages to the + * active list. */ - age_page_up(page); - if (inactive_shortage() > inactive_target / 2 && free_shortage()) - wakeup_kswapd(); + if (!PageActive(page)) + activate_page(page); + else + SetPageReferenced(page); + not_found: return page; } @@ -735,7 +764,6 @@ { struct inode *inode = file->f_dentry->d_inode; struct address_space *mapping = inode->i_mapping; - struct page **hash; struct page *page; unsigned long start; @@ -756,8 +784,7 @@ */ spin_lock(&pagecache_lock); while (--index >= start) { - hash = page_hash(mapping, index); - page = __find_page_nolock(mapping, index, *hash); + page = __find_page_simple(mapping, index); if (!page) break; deactivate_page(page); --- linux-2.4.1/mm/page_alloc.c.orig Tue Jan 30 17:02:23 2001 +++ linux-2.4.1/mm/page_alloc.c Tue Jan 30 17:54:10 2001 @@ -299,21 +299,6 @@ !(current->flags & PF_MEMALLOC)) direct_reclaim = 1; - /* - * If we are about to get low on free pages and we also have - * an inactive page shortage, wake up kswapd. - */ - if (inactive_shortage() > inactive_target / 2 && free_shortage()) - wakeup_kswapd(); - /* - * If we are about to get low on free pages and cleaning - * the inactive_dirty pages would fix the situation, - * wake up bdflush. - */ - else if (free_shortage() && nr_inactive_dirty_pages > free_shortage() - && nr_inactive_dirty_pages >= freepages.high) - wakeup_bdflush(0); - try_again: /* * First, see if we have any zones with lots of free memory. --- linux-2.4.1/mm/page_io.c.orig Tue Jan 30 17:02:23 2001 +++ linux-2.4.1/mm/page_io.c Tue Jan 30 18:44:11 2001 @@ -42,11 +42,6 @@ int block_size; struct inode *swapf = 0; - /* Don't allow too many pending pages in flight.. */ - if ((rw == WRITE) && atomic_read(&nr_async_pages) > - pager_daemon.swap_cluster * (1 << page_cluster)) - wait = 1; - if (rw == READ) { ClearPageUptodate(page); kstat.pswpin++; --- linux-2.4.1/mm/vmscan.c.orig Tue Jan 30 17:02:23 2001 +++ linux-2.4.1/mm/vmscan.c Mon Feb 5 12:20:12 2001 @@ -280,7 +280,7 @@ retval = swap_out_mm(mm, swap_amount(mm)); /* Then, look at the other mm's */ - counter = mmlist_nr >> priority; + counter = (mmlist_nr << SWAP_SHIFT) >> priority; do { struct list_head *p; @@ -412,14 +412,17 @@ * * This code is heavily inspired by the FreeBSD source code. Thanks * go out to Matthew Dillon. + * + * XXX: restrict number of pageouts in flight... */ -#define MAX_LAUNDER (4 * (1 << page_cluster)) -int page_launder(int gfp_mask, int sync) +#define MAX_LAUNDER (1 << page_cluster) +int page_launder(int gfp_mask, int user) { - int launder_loop, maxscan, cleaned_pages, maxlaunder; - int can_get_io_locks; + int launder_loop, maxscan, flushed_pages, freed_pages, maxlaunder; + int can_get_io_locks, sync, target, shortage; struct list_head * page_lru; struct page * page; + struct zone_struct * zone; /* * We can only grab the IO locks (eg. for flushing dirty @@ -427,9 +430,13 @@ */ can_get_io_locks = gfp_mask & __GFP_IO; + target = free_shortage(); + + sync = 0; launder_loop = 0; maxlaunder = 0; - cleaned_pages = 0; + flushed_pages = 0; + freed_pages = 0; dirty_page_rescan: spin_lock(&pagemap_lru_lock); @@ -437,13 +444,14 @@ while ((page_lru = inactive_dirty_list.prev) != &inactive_dirty_list && maxscan-- > 0) { page = list_entry(page_lru, struct page, lru); + zone = page->zone; /* Wrong page on list?! (list corruption, should not happen) */ if (!PageInactiveDirty(page)) { printk("VM: page_launder, wrong page on list.\n"); list_del(page_lru); nr_inactive_dirty_pages--; - page->zone->inactive_dirty_pages--; + zone->inactive_dirty_pages--; continue; } @@ -457,10 +465,26 @@ } /* + * Disk IO is really expensive, so we make sure we + * don't do more work than needed. + * Note that clean pages from zones with enough free + * pages still get recycled and dirty pages from these + * zones can get flushed due to IO clustering. + */ + if (freed_pages + flushed_pages > target && !free_shortage()) + break; + if (launder_loop && !maxlaunder) + break; + if (launder_loop && zone->inactive_clean_pages + + zone->free_pages > zone->pages_high) + goto skip_page; + + /* * The page is locked. IO in progress? * Move it to the back of the list. */ if (TryLockPage(page)) { +skip_page: list_del(page_lru); list_add(page_lru, &inactive_dirty_list); continue; @@ -490,6 +514,7 @@ spin_unlock(&pagemap_lru_lock); writepage(page); + flushed_pages++; page_cache_release(page); /* And re-start the thing.. */ @@ -508,7 +533,6 @@ */ if (page->buffers) { int wait, clearedbuf; - int freed_page = 0; /* * Since we might be doing disk IO, we have to * drop the spinlock and take an extra reference @@ -539,12 +563,12 @@ /* The buffers were not freed. */ if (!clearedbuf) { add_page_to_inactive_dirty_list(page); + flushed_pages++; /* The page was only in the buffer cache. */ } else if (!page->mapping) { atomic_dec(&buffermem_pages); - freed_page = 1; - cleaned_pages++; + freed_pages++; /* The page has more users besides the cache and us. */ } else if (page_count(page) > 2) { @@ -553,7 +577,7 @@ /* OK, we "created" a freeable page. */ } else /* page->mapping && page_count(page) == 2 */ { add_page_to_inactive_clean_list(page); - cleaned_pages++; + freed_pages++; } /* @@ -564,13 +588,6 @@ UnlockPage(page); page_cache_release(page); - /* - * If we're freeing buffer cache pages, stop when - * we've got enough free memory. - */ - if (freed_page && !free_shortage()) - break; - continue; } else if (page->mapping && !PageDirty(page)) { /* * If a page had an extra reference in @@ -581,7 +598,8 @@ del_page_from_inactive_dirty_list(page); add_page_to_inactive_clean_list(page); UnlockPage(page); - cleaned_pages++; + freed_pages++; + } else { page_active: /* @@ -607,20 +625,49 @@ * loads, flush out the dirty pages before we have to wait on * IO. */ - if (can_get_io_locks && !launder_loop && free_shortage()) { + shortage = free_shortage(); + if (can_get_io_locks && !launder_loop && shortage) { launder_loop = 1; - /* If we cleaned pages, never do synchronous IO. */ - if (cleaned_pages) - sync = 0; - /* We only do a few "out of order" flushes. */ - maxlaunder = MAX_LAUNDER; - /* Kflushd takes care of the rest. */ - wakeup_bdflush(0); + + /* + * User programs can run page_launder() in parallel so + * we only flush a few pages at a time to avoid big IO + * storms. Kswapd, OTOH, is expected usually keep up + * with the paging load in the system and doesn't have + * the IO storm problem, so it just flushes all pages + * needed to fix the free shortage. + * + * XXX: keep track of nr_async_pages like the old swap + * code did? + */ + if (user) + maxlaunder = MAX_LAUNDER; + else + maxlaunder = shortage; + + /* + * If we are called by a user program, we need to free + * some pages. If we couldn't, we'll do the last page IO + * synchronously to be sure + */ + if (user && !freed_pages) + sync = 1; + goto dirty_page_rescan; } - /* Return the number of pages moved to the inactive_clean list. */ - return cleaned_pages; + /* + * We have to make sure the data is actually written to + * the disk now, otherwise we'll never get enough clean + * pages and the system will keep queueing dirty pages + * for flushing. + */ + run_task_queue(&tq_disk); + + /* + * Return the amount of pages we freed or made freeable. + */ + return freed_pages + flushed_pages; } /** @@ -631,12 +678,12 @@ * This function will scan a portion of the active list to find * unused pages, those pages will then be moved to the inactive list. */ -int refill_inactive_scan(unsigned int priority, int oneshot) +int refill_inactive_scan(int priority, int target) { struct list_head * page_lru; struct page * page; int maxscan, page_active = 0; - int ret = 0; + int nr_deactivated = 0; /* Take the lock while messing with the list... */ spin_lock(&pagemap_lru_lock); @@ -668,31 +715,38 @@ * * SUBTLE: we can have buffer pages with count 1. */ - if (page->age == 0 && page_count(page) <= - (page->buffers ? 2 : 1)) { - deactivate_page_nolock(page); - page_active = 0; + if (page->age == 0) { + int maxcount = (page->buffers ? 2 : 1); + if (page_count(page) <= maxcount) { + deactivate_page_nolock(page); + page_active = 0; + } else { + /* Page still in somebody's RSS? */ + page_active = 1; + /* XXX: should we call swap_out() if + * this happens too often ? */ + } } else { page_active = 1; } } /* * If the page is still on the active list, move it - * to the other end of the list. Otherwise it was - * deactivated by age_page_down and we exit successfully. + * to the end of the list. Otherwise we successfully + * deactivated a page. */ if (page_active || PageActive(page)) { list_del(page_lru); list_add(page_lru, &active_list); } else { - ret = 1; - if (oneshot) + nr_deactivated++; + if (nr_deactivated >= target) break; } } spin_unlock(&pagemap_lru_lock); - return ret; + return nr_deactivated; } /* @@ -704,7 +758,7 @@ pg_data_t *pgdat = pgdat_list; int sum = 0; int freeable = nr_free_pages() + nr_inactive_clean_pages(); - int freetarget = freepages.high + inactive_target / 3; + int freetarget = freepages.high; /* Are we low on free pages globally? */ if (freeable < freetarget) @@ -772,38 +826,46 @@ } /* - * We need to make the locks finer granularity, but right - * now we need this so that we can do page allocations - * without holding the kernel lock etc. + * Refill_inactive is the function used to scan and age the pages in + * the processes and the active pages, and to move little-used pages + * to the inactive list. * - * We want to try to free "count" pages, and we want to - * cluster them so that we get good swap-out behaviour. + * When called by kswapd, we try to just deactivate as many pages as + * needed. This makes it easy for kswapd to keep up with memory + * demand. * - * OTOH, if we're a user process (and not kswapd), we - * really care about latency. In that case we don't try - * to free too many pages. + * However, when we are called by a user process we have to limit the + * amount of work done. This way the process can do its allocation and + * continue with its real work sooner. It also helps balancing when we + * have multiple processes in try_to_free_pages simultaneously. */ #define DEF_PRIORITY (6) static int refill_inactive(unsigned int gfp_mask, int user) { int count, start_count, maxtry; - count = inactive_shortage() + free_shortage(); - if (user) + if (user) { + /* user process */ count = (1 << page_cluster); - start_count = count; + maxtry = 6; + } else { + /* kswapd */ + count = inactive_shortage() + free_shortage(); + maxtry = 1 << DEF_PRIORITY; + } - maxtry = 6; + start_count = count; do { if (current->need_resched) { __set_current_state(TASK_RUNNING); schedule(); + if (!inactive_shortage()) + return 1; } - while (refill_inactive_scan(DEF_PRIORITY, 1)) { - if (--count <= 0) - goto done; - } + count -= refill_inactive_scan(DEF_PRIORITY, count); + if (--count <= 0) + goto done; /* If refill_inactive_scan failed, try to page stuff out.. */ swap_out(DEF_PRIORITY, gfp_mask);
- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org Please read the FAQ at http://www.tux.org/lkml/