AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

per-zone and reclaim enhancements for memory controller: per zone lru for cgroup

Browse Source 
This patch implements per-zone lru for memory cgroup.
This patch makes use of mem_cgroup_per_zone struct for per zone lru.

LRU can be accessed by

   mz = mem_cgroup_zoneinfo(mem_cgroup, node, zone);
   &mz->active_list
   &mz->inactive_list

   or
   mz = page_cgroup_zoneinfo(page_cgroup);
   &mz->active_list
   &mz->inactive_list

Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Balbir Singh <balbir@linux.vnet.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Herbert Poetzl <herbert@13thfloor.at>
Cc: Kirill Korotaev <dev@sw.ru>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Cc: Paul Menage <menage@google.com>
Cc: Pavel Emelianov <xemul@openvz.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Vaidyanathan Srinivasan <svaidy@linux.vnet.ibm.com>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
KAMEZAWA Hiroyuki 2008-02-07 00:14:38 -08:00 committed by Linus Torvalds
parent 1cfb419b39
commit 1ecaab2bd2
1 changed files with 58 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
mm/memcontrol.c
View File

@ -89,6 +89,8 @@ enum mem_cgroup_zstat_index {
}; };
struct mem_cgroup_per_zone { struct mem_cgroup_per_zone {
struct list_head active_list;
struct list_head inactive_list;
unsigned long count[NR_MEM_CGROUP_ZSTAT]; unsigned long count[NR_MEM_CGROUP_ZSTAT];
}; };
/* Macro for accessing counter */ /* Macro for accessing counter */
@ -122,10 +124,7 @@ struct mem_cgroup {
/* /*
* Per cgroup active and inactive list, similar to the * Per cgroup active and inactive list, similar to the
* per zone LRU lists. * per zone LRU lists.
* TODO: Consider making these lists per zone
*/ */
struct list_head active_list;
struct list_head inactive_list;
struct mem_cgroup_lru_info info; struct mem_cgroup_lru_info info;
/* /*
* spin_lock to protect the per cgroup LRU * spin_lock to protect the per cgroup LRU
@ -366,10 +365,10 @@ static void __mem_cgroup_add_list(struct page_cgroup *pc)
if (!to) { if (!to) {
MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_INACTIVE) += 1; MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_INACTIVE) += 1;
list_add(&pc->lru, &pc->mem_cgroup->inactive_list); list_add(&pc->lru, &mz->inactive_list);
} else { } else {
MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_ACTIVE) += 1; MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_ACTIVE) += 1;
list_add(&pc->lru, &pc->mem_cgroup->active_list); list_add(&pc->lru, &mz->active_list);
} }
mem_cgroup_charge_statistics(pc->mem_cgroup, pc->flags, true); mem_cgroup_charge_statistics(pc->mem_cgroup, pc->flags, true);
} }
@ -387,11 +386,11 @@ static void __mem_cgroup_move_lists(struct page_cgroup *pc, bool active)
if (active) { if (active) {
MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_ACTIVE) += 1; MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_ACTIVE) += 1;
pc->flags |= PAGE_CGROUP_FLAG_ACTIVE; pc->flags |= PAGE_CGROUP_FLAG_ACTIVE;
list_move(&pc->lru, &pc->mem_cgroup->active_list); list_move(&pc->lru, &mz->active_list);
} else { } else {
MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_INACTIVE) += 1; MEM_CGROUP_ZSTAT(mz, MEM_CGROUP_ZSTAT_INACTIVE) += 1;
pc->flags &= ~PAGE_CGROUP_FLAG_ACTIVE; pc->flags &= ~PAGE_CGROUP_FLAG_ACTIVE;
list_move(&pc->lru, &pc->mem_cgroup->inactive_list); list_move(&pc->lru, &mz->inactive_list);
} }
} }
@ -517,11 +516,16 @@ unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
LIST_HEAD(pc_list); LIST_HEAD(pc_list);
struct list_head *src; struct list_head *src;
struct page_cgroup *pc, *tmp; struct page_cgroup *pc, *tmp;
int nid = z->zone_pgdat->node_id;
int zid = zone_idx(z);
struct mem_cgroup_per_zone *mz;
mz = mem_cgroup_zoneinfo(mem_cont, nid, zid);
if (active) if (active)
src = &mem_cont->active_list; src = &mz->active_list;
else else
src = &mem_cont->inactive_list; src = &mz->inactive_list;
spin_lock(&mem_cont->lru_lock); spin_lock(&mem_cont->lru_lock);
scan = 0; scan = 0;
@ -543,13 +547,6 @@ unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
continue; continue;
} }
/*
* Reclaim, per zone
* TODO: make the active/inactive lists per zone
*/
if (page_zone(page) != z)
continue;
scan++; scan++;
list_move(&pc->lru, &pc_list); list_move(&pc->lru, &pc_list);
@ -826,6 +823,8 @@ mem_cgroup_force_empty_list(struct mem_cgroup *mem, struct list_head *list)
int count; int count;
unsigned long flags; unsigned long flags;
if (list_empty(list))
return;
retry: retry:
count = FORCE_UNCHARGE_BATCH; count = FORCE_UNCHARGE_BATCH;
spin_lock_irqsave(&mem->lru_lock, flags); spin_lock_irqsave(&mem->lru_lock, flags);
@ -859,20 +858,27 @@ mem_cgroup_force_empty_list(struct mem_cgroup *mem, struct list_head *list)
int mem_cgroup_force_empty(struct mem_cgroup *mem) int mem_cgroup_force_empty(struct mem_cgroup *mem)
{ {
int ret = -EBUSY; int ret = -EBUSY;
int node, zid;
css_get(&mem->css); css_get(&mem->css);
/* /*
* page reclaim code (kswapd etc..) will move pages between * page reclaim code (kswapd etc..) will move pages between
` * active_list <-> inactive_list while we don't take a lock. ` * active_list <-> inactive_list while we don't take a lock.
* So, we have to do loop here until all lists are empty. * So, we have to do loop here until all lists are empty.
*/ */
while (!(list_empty(&mem->active_list) && while (mem->res.usage > 0) {
list_empty(&mem->inactive_list))) {
if (atomic_read(&mem->css.cgroup->count) > 0) if (atomic_read(&mem->css.cgroup->count) > 0)
goto out; goto out;
/* drop all page_cgroup in active_list */ for_each_node_state(node, N_POSSIBLE)
mem_cgroup_force_empty_list(mem, &mem->active_list); for (zid = 0; zid < MAX_NR_ZONES; zid++) {
/* drop all page_cgroup in inactive_list */ struct mem_cgroup_per_zone *mz;
mem_cgroup_force_empty_list(mem, &mem->inactive_list); mz = mem_cgroup_zoneinfo(mem, node, zid);
/* drop all page_cgroup in active_list */
mem_cgroup_force_empty_list(mem,
&mz->active_list);
/* drop all page_cgroup in inactive_list */
mem_cgroup_force_empty_list(mem,
&mz->inactive_list);
}
} }
ret = 0; ret = 0;
out: out:
@ -1084,15 +1090,40 @@ static struct cftype mem_cgroup_files[] = {
static int alloc_mem_cgroup_per_zone_info(struct mem_cgroup *mem, int node) static int alloc_mem_cgroup_per_zone_info(struct mem_cgroup *mem, int node)
{ {
struct mem_cgroup_per_node *pn; struct mem_cgroup_per_node *pn;
struct mem_cgroup_per_zone *mz;
pn = kmalloc_node(sizeof(*pn), GFP_KERNEL, node); int zone;
/*
* This routine is called against possible nodes.
* But it's BUG to call kmalloc() against offline node.
*
* TODO: this routine can waste much memory for nodes which will
* never be onlined. It's better to use memory hotplug callback
* function.
*/
if (node_state(node, N_HIGH_MEMORY))
pn = kmalloc_node(sizeof(*pn), GFP_KERNEL, node);
else
pn = kmalloc(sizeof(*pn), GFP_KERNEL);
if (!pn) if (!pn)
return 1; return 1;
mem->info.nodeinfo[node] = pn; mem->info.nodeinfo[node] = pn;
memset(pn, 0, sizeof(*pn)); memset(pn, 0, sizeof(*pn));
for (zone = 0; zone < MAX_NR_ZONES; zone++) {
mz = &pn->zoneinfo[zone];
INIT_LIST_HEAD(&mz->active_list);
INIT_LIST_HEAD(&mz->inactive_list);
}
return 0; return 0;
} }
static void free_mem_cgroup_per_zone_info(struct mem_cgroup *mem, int node)
{
kfree(mem->info.nodeinfo[node]);
}
static struct mem_cgroup init_mem_cgroup; static struct mem_cgroup init_mem_cgroup;
static struct cgroup_subsys_state * static struct cgroup_subsys_state *
@ -1111,8 +1142,7 @@ mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
return NULL; return NULL;
res_counter_init(&mem->res); res_counter_init(&mem->res);
INIT_LIST_HEAD(&mem->active_list);
INIT_LIST_HEAD(&mem->inactive_list);
spin_lock_init(&mem->lru_lock); spin_lock_init(&mem->lru_lock);
mem->control_type = MEM_CGROUP_TYPE_ALL; mem->control_type = MEM_CGROUP_TYPE_ALL;
memset(&mem->info, 0, sizeof(mem->info)); memset(&mem->info, 0, sizeof(mem->info));
@ -1124,7 +1154,7 @@ mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
return &mem->css; return &mem->css;
free_out: free_out:
for_each_node_state(node, N_POSSIBLE) for_each_node_state(node, N_POSSIBLE)
kfree(mem->info.nodeinfo[node]); free_mem_cgroup_per_zone_info(mem, node);
if (cont->parent != NULL) if (cont->parent != NULL)
kfree(mem); kfree(mem);
return NULL; return NULL;
@ -1144,7 +1174,7 @@ static void mem_cgroup_destroy(struct cgroup_subsys *ss,
struct mem_cgroup *mem = mem_cgroup_from_cont(cont); struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
for_each_node_state(node, N_POSSIBLE) for_each_node_state(node, N_POSSIBLE)
kfree(mem->info.nodeinfo[node]); free_mem_cgroup_per_zone_info(mem, node);
kfree(mem_cgroup_from_cont(cont)); kfree(mem_cgroup_from_cont(cont));
} }