[VM anon-lru 1/1]: Introduce /proc/sys/vm/vm_anon_lru # vm_anon_lru: select if to immdiatly insert anon pages in the # lru. Immediatly means as soon as they're allocated during the # page faults. # # If this is set to 0, they're inserted only after the first # swapout. # # Having anon pages immediatly inserted in the lru allows the # VM to know better when it's worthwhile to start swapping # anonymous ram, it will start to swap earlier and it should # swap smoother and faster, but it will decrease scalability # on the >16-ways of an order of magnitude. Big SMP/NUMA # definitely can't take an hit on a global spinlock at # every anon page allocation. So this is off by default. # # Side effects: # Fix 'swapping all the time instead releasing pagecache' # Signed-off-by: Marc-Christian Petersen diff -Naurp a/include/linub/swap.h b/include/linub/swap.h --- a/include/linub/swap.h 2003-10-10 08:08:29.000000000 +0200 +++ b/include/linub/swap.h 2003-10-17 21:18:14.000000000 +0200 @@ -115,7 +115,7 @@ extern void swap_setup(void); extern wait_queue_head_t kswapd_wait; extern int FASTCALL(try_to_free_pages_zone(zone_t *, unsigned int)); extern int FASTCALL(try_to_free_pages(unsigned int)); -extern int vm_vfs_scan_ratio, vm_cache_scan_ratio, vm_lru_balance_ratio, vm_passes, vm_gfp_debug, vm_mapped_ratio; +extern int vm_vfs_scan_ratio, vm_cache_scan_ratio, vm_lru_balance_ratio, vm_passes, vm_gfp_debug, vm_mapped_ratio, vm_anon_lru; /* linub/mm/page_io.c */ extern void rw_swap_page(int, struct page *); diff -Naurp a/include/linub/sysctl.h b/include/linub/sysctl.h --- a/include/linub/sysctl.h 2003-10-17 21:18:12.000000000 +0200 +++ b/include/linub/sysctl.h 2003-10-17 21:18:46.000000000 +0200 @@ -154,9 +154,10 @@ enum VM_PAGEBUF=17, /* struct: Control pagebuf parameters */ VM_GFP_DEBUG=18, /* debug GFP failures */ VM_CACHE_SCAN_RATIO=19, /* part of the inactive cache list to scan */ - VM_MAPPED_RATIO=20, /* amount of unfreeable pages that triggers swapout */ + VM_MAPPED_RATIO=20, /* amount of unfreeable pages that triggers swapout */ VM_LAPTOP_MODE=21, /* kernel in laptop flush mode */ VM_BLOCK_DUMP=22, /* dump fs activity to log */ + VM_ANON_LRU=23, /* immediatly insert anon pages in the vm page lru */ }; diff -Naurp a/kernel/sysctl.c b/kernel/sysctl.c --- a/kernel/sysctl.c 2003-10-17 21:18:12.000000000 +0200 +++ b/kernel/sysctl.c 2003-10-17 21:18:14.000000000 +0200 @@ -287,6 +287,8 @@ static ctl_table vm_table[] = { &vm_cache_scan_ratio, sizeof(int), 0644, NULL, &proc_dointvec}, {VM_MAPPED_RATIO, "vm_mapped_ratio", &vm_mapped_ratio, sizeof(int), 0644, NULL, &proc_dointvec}, + {VM_ANON_LRU, "vm_anon_lru", + &vm_anon_lru, sizeof(int), 0644, NULL, &proc_dointvec}, {VM_LRU_BALANCE_RATIO, "vm_lru_balance_ratio", &vm_lru_balance_ratio, sizeof(int), 0644, NULL, &proc_dointvec}, {VM_PASSES, "vm_passes", diff -Naurp a/mm/memory.c b/mm/memory.c --- a/mm/memory.c 2003-10-17 21:18:09.000000000 +0200 +++ b/mm/memory.c 2003-10-17 21:18:14.000000000 +0200 @@ -997,7 +997,8 @@ static int do_wp_page(struct mm_struct * if (PageReserved(old_page)) ++mm->rss; break_cow(vma, new_page, address, page_table); - lru_cache_add(new_page); + if (vm_anon_lru) + lru_cache_add(new_page); /* Free the old page.. */ new_page = old_page; @@ -1228,7 +1229,8 @@ static int do_anonymous_page(struct mm_s mm->rss++; flush_page_to_ram(page); entry = pte_mkwrite(pte_mkdirty(mk_pte(page, vma->vm_page_prot))); - lru_cache_add(page); + if (vm_anon_lru) + lru_cache_add(page); mark_page_accessed(page); } @@ -1283,7 +1285,8 @@ static int do_no_page(struct mm_struct * } copy_user_highpage(page, new_page, address); page_cache_release(new_page); - lru_cache_add(page); + if (vm_anon_lru) + lru_cache_add(page); new_page = page; } diff -Naurp a/mm/vmscan.c b/mm/vmscan.c --- a/mm/vmscan.c 2003-10-17 21:18:13.000000000 +0200 +++ b/mm/vmscan.c 2003-10-17 21:18:14.000000000 +0200 @@ -65,6 +65,25 @@ int vm_lru_balance_ratio = 2; int vm_vfs_scan_ratio = 6; /* + * "vm_anon_lru" select if to immdiatly insert anon pages in the + * lru. Immediatly means as soon as they're allocated during the + * page faults. + * + * If this is set to 0, they're inserted only after the first + * swapout. + * + * Having anon pages immediatly inserted in the lru allows the + * VM to know better when it's worthwhile to start swapping + * anonymous ram, it will start to swap earlier and it should + * swap smoother and faster, but it will decrease scalability + * on the >16-ways of an order of magnitude. Big SMP/NUMA + * definitely can't take an hit on a global spinlock at + * every anon page allocation. So this is off by default. + * + */ +int vm_anon_lru = 0; + +/* * The swap-out function returns 1 if it successfully * scanned all the pages it was asked to (`count'). * It returns zero if it couldn't do anything,