CKRM: Add config support for mem controller

Patch 5 of 6 patches to support memory controller under CKRM framework. Provides some config parameter support. Details about the config parameters
in the Documentation patch.
----------------------------------------

 include/linux/ckrm_mem.h        |   14 ++++
 include/linux/ckrm_mem_inline.h |    4 +
 kernel/ckrm/ckrm_memcore.c      |  127 ++++++++++++++++++++++++++++++++
++++++--
 kernel/ckrm/ckrm_memctlr.c      |   49 +++++++++++++++
 mm/vmscan.c                     |   96 ++++++++++++++++++++++++++++--
 5 files changed, 279 insertions(+), 11 deletions(-)

Content-Disposition: inline; filename=11-05-mem_guar-config

Index: linux-2.6.12/include/linux/ckrm_mem.h
===================================================================
@@ -63,16 +63,28 @@ struct ckrm_mem_res {
 	int nr_dontcare;		/* # of dont care children */
 
 	struct ckrm_zone ckrm_zone[MAX_NR_ZONES];
+
+ 	struct list_head shrink_list;	/* list of classes that are near
+				 	 * limit and need to be shrunk
+					 */
+	int shrink_count;
+	unsigned long last_shrink;
 };
 
+#define CLS_AT_LIMIT		(1)
+
 extern atomic_t ckrm_mem_real_count;
 extern struct ckrm_res_ctlr mem_rcbs;
 extern struct ckrm_mem_res *ckrm_mem_root_class;
 extern struct list_head ckrm_memclass_list;
+extern struct list_head ckrm_shrink_list;
 extern spinlock_t ckrm_mem_lock;
 extern spinlock_t ckrm_overguar_lock[MAX_NR_ZONES];
 extern int ckrm_nr_mem_classes;
 extern unsigned int ckrm_tot_lru_pages;
+extern int ckrm_mem_shrink_count;
+extern int ckrm_mem_shrink_to;
+extern int ckrm_mem_shrink_interval;
 
 extern void ckrm_mem_migrate_mm(struct mm_struct *, struct ckrm_mem_res

*);
extern void ckrm_mem_migrate_all_pages(struct ckrm_mem_res *,
@@ -84,6 +96,8 @@ extern int ckrm_class_limit_ok(struct ck

extern struct ckrm_zone *ckrm_get_max_overguar_czone(int);

+extern void ckrm_shrink_atlimit(struct ckrm_mem_res *); +
#else

#define ckrm_mem_migrate_mm(a, b) do {} while (0)

Index: linux-2.6.12/include/linux/ckrm_mem_inline.h
===================================================================
@@ -26,6 +26,8 @@
 
 #ifdef CONFIG_CKRM_RES_MEM
 
+#define ckrm_shrink_list_empty() list_empty(&ckrm_shrink_list)
+
 static inline struct ckrm_mem_res *
 ckrm_task_memclass(struct task_struct *tsk)
 {

@@ -324,6 +326,8 @@ static inline void ckrm_add_tail_inactiv
 
 #else
 
+#define ckrm_shrink_list_empty()		(1)
+
 static inline void *
 ckrm_task_memclass(struct task_struct *tsk)
 {

Index: linux-2.6.12/kernel/ckrm/ckrm_memctlr.c
===================================================================
@@ -59,10 +59,13 @@ ckrm_del_from_guar_list(struct ckrm_zone
 	}
 }
 
+extern int ckrm_mem_state;
+
 void
 add_use_count(struct ckrm_mem_res *cls, int borrow, int zindex, int

cnt)
{
int i, pg_total = 0;
+ extern int ckrm_mem_shrink_at;
struct ckrm_mem_res *parcls = ckrm_memclass(cls->parent);

if (!cls)
@@ -82,6 +85,12 @@ add_use_count(struct ckrm_mem_res *cls,
} else
atomic_add(cnt, &ckrm_mem_real_count);
ckrm_add_to_guar_list(&cls->ckrm_zone[zindex], zindex);
+
+ if (ckrm_mem_state && (cls->pg_limit != CKRM_SHARE_DONTCARE) &&
+ (pg_total >=
+ ((ckrm_mem_shrink_at * cls->pg_limit) / 100)) &&
+ (!test_bit(CLS_AT_LIMIT, &cls->flags)))
+ ckrm_shrink_atlimit(cls);
return;
}

@@ -113,7 +122,7 @@ ckrm_class_limit_ok(struct ckrm_mem_res
{
int ret, i, pg_total = 0;

- if ((mem_rcbs.resid == -1) || !cls)
+ if ((ckrm_mem_state == 0) || (mem_rcbs.resid == -1) || !cls)
return 1;
for (i = 0; i < MAX_NR_ZONES; i++)
pg_total += cls->pg_total[i];
@@ -123,6 +132,10 @@ ckrm_class_limit_ok(struct ckrm_mem_res
} else
ret = (pg_total <= cls->pg_limit);

+ /* If we are failing, just nudge the back end */
+ if (ret == 0)
+ ckrm_shrink_atlimit(cls);
+
return ret;
}

@@ -407,3 +420,37 @@ ckrm_get_max_overguar_czone(int zindex)

return maxczone;
}
+LIST_HEAD(ckrm_shrink_list);
+
+void
+ckrm_shrink_atlimit(struct ckrm_mem_res *cls)
+{
+ struct zone *zone;
+ unsigned long flags;
+ int order;
+
+ if (!cls || (cls->pg_limit == CKRM_SHARE_DONTCARE))
+ return;
+ if (test_and_set_bit(CLS_AT_LIMIT, &cls->flags))
+ return;
+ if (time_after(jiffies, cls->last_shrink +
+ ckrm_mem_shrink_interval * HZ)) {
+ cls->last_shrink = jiffies;
+ cls->shrink_count = 0;
+ }
+ cls->shrink_count++;
+ if (cls->shrink_count > ckrm_mem_shrink_count) {
+ clear_bit(CLS_AT_LIMIT, &cls->flags);
+ return;
+ }
+ spin_lock_irqsave(&ckrm_mem_lock, flags);
+ list_add(&cls->shrink_list, &ckrm_shrink_list);
+ spin_unlock_irqrestore(&ckrm_mem_lock, flags);
+ for_each_zone(zone) {
+ /* This is just a number to get to wakeup kswapd */
+ order = cls->pg_total[0] -
+ ((ckrm_mem_shrink_to * cls->pg_limit) / 100);
+ wakeup_kswapd(zone, order);
+ break; /* only once is enough */
+ }
+}

----------------------------------------------------------------------
    Chandra Seetharaman               | Be careful what you choose....
              - [email protected]   |      .......you may get it.
----------------------------------------------------------------------


--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>