[PATCH] zoned vm counters: conversion of nr_pagetables to per zone counter

[powerpc.git] / mm / vmscan.c

diff --git a/mm/vmscan.c b/mm/vmscan.c
index f03da33..d694243 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -47,8 +47,6 @@ struct scan_control {
        /* Incremented by the number of inactive pages that were scanned */
        unsigned long nr_scanned;
 
-       unsigned long nr_mapped;        /* From page_state */
-
        /* This context's GFP mask */
        gfp_t gfp_mask;
 
@@ -744,7 +742,9 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
                 * how much memory
                 * is mapped.
                 */
-               mapped_ratio = (sc->nr_mapped * 100) / vm_total_pages;
+               mapped_ratio = ((global_page_state(NR_FILE_MAPPED) +
+                               global_page_state(NR_ANON_PAGES)) * 100) /
+                                       vm_total_pages;
 
                /*
                 * Now decide how much we really want to unmap some pages.  The
@@ -990,7 +990,6 @@ unsigned long try_to_free_pages(struct zone **zones, gfp_t gfp_mask)
        }
 
        for (priority = DEF_PRIORITY; priority >= 0; priority--) {
-               sc.nr_mapped = read_page_state(nr_mapped);
                sc.nr_scanned = 0;
                if (!priority)
                        disable_swap_token();
@@ -1075,8 +1074,6 @@ loop_again:
        total_scanned = 0;
        nr_reclaimed = 0;
        sc.may_writepage = !laptop_mode;
-       sc.nr_mapped = read_page_state(nr_mapped);
-
        inc_page_state(pageoutrun);
 
        for (i = 0; i < pgdat->nr_zones; i++) {
@@ -1365,7 +1362,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
        for_each_zone(zone)
                lru_pages += zone->nr_active + zone->nr_inactive;
 
-       nr_slab = read_page_state(nr_slab);
+       nr_slab = global_page_state(NR_SLAB);
        /* If slab caches are huge, it's better to hit them first */
        while (nr_slab >= lru_pages) {
                reclaim_state.reclaimed_slab = 0;
@@ -1407,9 +1404,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
                for (prio = DEF_PRIORITY; prio >= 0; prio--) {
                        unsigned long nr_to_scan = nr_pages - ret;
 
-                       sc.nr_mapped = read_page_state(nr_mapped);
                        sc.nr_scanned = 0;
-
                        ret += shrink_all_zones(nr_to_scan, prio, pass, &sc);
                        if (ret >= nr_pages)
                                goto out;
@@ -1450,7 +1445,7 @@ out:
    not required for correctness.  So if the last cpu in a node goes
    away, we get changed to run anywhere: as the first one comes back,
    restore their cpu bindings. */
-static int cpu_callback(struct notifier_block *nfb,
+static int __devinit cpu_callback(struct notifier_block *nfb,
                                  unsigned long action, void *hcpu)
 {
        pg_data_t *pgdat;
@@ -1522,11 +1517,6 @@ int zone_reclaim_mode __read_mostly;
 #define RECLAIM_SWAP (1<<2)    /* Swap pages out during reclaim */
 #define RECLAIM_SLAB (1<<3)    /* Do a global slab shrink if the zone is out of memory */
 
-/*
- * Mininum time between zone reclaim scans
- */
-int zone_reclaim_interval __read_mostly = 30*HZ;
-
 /*
  * Priority for ZONE_RECLAIM. This determines the fraction of pages
  * of a node considered for each zone_reclaim. 4 scans 1/16th of
@@ -1548,7 +1538,6 @@ static int __zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
        struct scan_control sc = {
                .may_writepage = !!(zone_reclaim_mode & RECLAIM_WRITE),
                .may_swap = !!(zone_reclaim_mode & RECLAIM_SWAP),
-               .nr_mapped = read_page_state(nr_mapped),
                .swap_cluster_max = max_t(unsigned long, nr_pages,
                                        SWAP_CLUSTER_MAX),
                .gfp_mask = gfp_mask,
@@ -1593,16 +1582,6 @@ static int __zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
 
        p->reclaim_state = NULL;
        current->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE);
-
-       if (nr_reclaimed == 0) {
-               /*
-                * We were unable to reclaim enough pages to stay on node.  We
-                * now allow off node accesses for a certain time period before
-                * trying again to reclaim pages from the local zone.
-                */
-               zone->last_unsuccessful_zone_reclaim = jiffies;
-       }
-
        return nr_reclaimed >= nr_pages;
 }
 
@@ -1612,13 +1591,17 @@ int zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
        int node_id;
 
        /*
-        * Do not reclaim if there was a recent unsuccessful attempt at zone
-        * reclaim.  In that case we let allocations go off node for the
-        * zone_reclaim_interval.  Otherwise we would scan for each off-node
-        * page allocation.
+        * Do not reclaim if there are not enough reclaimable pages in this
+        * zone that would satify this allocations.
+        *
+        * All unmapped pagecache pages are reclaimable.
+        *
+        * Both counters may be temporarily off a bit so we use
+        * SWAP_CLUSTER_MAX as the boundary. It may also be good to
+        * leave a few frequently used unmapped pagecache pages around.
         */
-       if (time_before(jiffies,
-               zone->last_unsuccessful_zone_reclaim + zone_reclaim_interval))
+       if (zone_page_state(zone, NR_FILE_PAGES) -
+               zone_page_state(zone, NR_FILE_MAPPED) < SWAP_CLUSTER_MAX)
                        return 0;
 
        /*