add bank_proc.c for cache and bank coloring

Conflicts:
	litmus/litmus.c

4 files changed, 262 insertions, 3 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index 997524f91363..713a14f7c4fc 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -20,6 +20,7 @@ obj-y     = sched_plugin.o litmus.o \
             ctrldev.o \
             uncachedev.o \
             cache_proc.o \
+            bank_proc.o \
             sched_gsn_edf.o \
             sched_psn_edf.o \
             sched_pfp.o
diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
new file mode 100644
index 000000000000..2c69657b53bd
--- /dev/null
+++ b/litmus/bank_proc.c
@@ -0,0 +1,254 @@
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sysctl.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+#include <linux/mm.h>
+#include <linux/random.h>
+
+#include <litmus/litmus_proc.h>
+#include <litmus/sched_trace.h>
+
+#define LITMUS_LOCKDEP_NAME_MAX_LEN 50
+
+// This is Address Decoding for imx6-sabredsd board
+#define CACHE_MASK 0x0000f000      
+#define BANK_MASK  0x00007000      
+#define OFFSET_SHIFT 12
+
+#define PAGES_PER_COLOR 1024
+
+unsigned long number_banks;
+unsigned long number_cachecolors;
+
+struct color_group {
+        spinlock_t lock;
+        char _lock_name[LITMUS_LOCKDEP_NAME_MAX_LEN];
+        struct list_head list;
+        atomic_t nr_pages;
+};
+
+static struct alloced_pages {
+        spinlock_t lock;
+        struct list_head list;
+} alloced_pages;
+
+struct alloced_page {
+        struct page *page;
+        struct vm_area_struct *vma;
+        struct list_head list;
+};
+
+static struct color_group *color_groups;
+static struct lock_class_key color_lock_keys[16];
+
+//static struct color_group *color_groups;
+
+/* Decoding page color, 0~15 */ 
+static inline unsigned long page_color(struct page *page)
+{
+        return ((page_to_phys(page)& CACHE_MASK) >> PAGE_SHIFT);
+}
+
+/* Decoding page bank number, 0~7 */ 
+static inline unsigned long page_bank(struct page *page)
+{
+        return ((page_to_phys(page)& BANK_MASK) >> PAGE_SHIFT);
+}
+
+static unsigned long smallest_nr_pages(void)
+{
+        unsigned long i, min_pages = -1;
+        struct color_group *cgroup;
+        for (i = 0; i < number_cachecolors; ++i) {
+                cgroup = &color_groups[i];
+                if (atomic_read(&cgroup->nr_pages) < min_pages)
+                        min_pages = atomic_read(&cgroup->nr_pages);
+        }
+        return min_pages;
+}
+/*
+ * Page's count should be one, it sould not be on any LRU list.
+ */
+void add_page_to_color_list(struct page *page)
+{
+        const unsigned long color = page_color(page);
+        struct color_group *cgroup = &color_groups[color];
+        BUG_ON(in_list(&page->lru) || PageLRU(page));
+        BUG_ON(page_count(page) > 1);
+        spin_lock(&cgroup->lock);
+        list_add_tail(&page->lru, &cgroup->list);
+        atomic_inc(&cgroup->nr_pages);
+//      SetPageLRU(page);
+        spin_unlock(&cgroup->lock);
+}
+
+static int do_add_pages(void)
+{
+        printk("LITMUS do add pages\n");
+        
+        struct page *page, *page_tmp;
+        LIST_HEAD(free_later);
+        unsigned long color;
+        int ret = 0;
+
+        while (smallest_nr_pages() < PAGES_PER_COLOR) {
+        
+                //page = alloc_page(GFP_HIGHUSER | __GFP_MOVABLE);
+                page = alloc_page(GFP_HIGHUSER_MOVABLE);
+                
+                if (unlikely(!page)) {
+                        printk(KERN_WARNING "Could not allocate pages.\n");
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                color = page_color(page);
+                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR) {
+        //              SetPageReserved(page);
+                        add_page_to_color_list(page);
+                } else
+                        list_add_tail(&page->lru, &free_later);
+        }
+        list_for_each_entry_safe(page, page_tmp, &free_later, lru) {
+                list_del(&page->lru);
+                __free_page(page);
+        }
+        /* setup the color queue stuff */
+//      ret = setup_flusher_array();
+out:
+        return ret;
+}
+
+
+/*
+ * provide pages for replacement 
+ * node = 0 for Level A, B tasks in Cpu 0
+ * node = 1 for Level A, B tasks in Cpu 1
+ * node = 2 for Level A, B tasks in Cpu 2
+ * node = 3 for Level A, B tasks in Cpu 3
+ * node = 4 for Level C tasks 
+ */
+ #if 1 
+struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
+{
+        printk("allocate new page node = %d\n", node);  
+//      return alloc_pages_exact_node(node, GFP_HIGHUSER_MOVABLE, 0);
+        struct color_group *cgroup;
+        struct page *rPage = NULL;
+        unsigned int color;
+        get_random_bytes(&color, sizeof(unsigned int));
+        
+        /*
+        if(node ==0){
+                color = (color%2)*8+node;
+        }else if(node == 1){
+                color = (color%2)*8+node;
+        }else if(node == 2){
+                color = (color%2)*8+;
+        }else if(node == 3){
+                color = color%2 + 6;
+        }else if(node == 4){
+                color = color%8 + 8;
+        }else{
+                goto out;
+        }
+        */
+        
+        switch(node ){
+                case 0:
+                case 1: 
+                case 2: 
+                case 3:
+                        color = (color%2) * 8 + node;
+                        break;
+                case 4:
+                        color = (color%8)+4;
+                        if(color >=8)   
+                                color+=4;
+                        break;
+                default:
+                        goto out;
+        }
+
+
+        printk("allocate new page color = %d\n", color);
+                
+        cgroup = &color_groups[color];
+        spin_lock(&cgroup->lock);
+        if (unlikely(!atomic_read(&cgroup->nr_pages))) {
+                TRACE_CUR("No free %lu colored pages.\n", color);
+                printk(KERN_WARNING "no free %lu colored pages.\n", color);
+                goto out_unlock;
+        }
+        rPage = list_first_entry(&cgroup->list, struct page, lru);
+        BUG_ON(page_count(rPage) > 1);
+        get_page(rPage);
+        list_del(&rPage->lru);
+        atomic_dec(&cgroup->nr_pages);
+//      ClearPageLRU(rPage);
+out_unlock:
+        spin_unlock(&cgroup->lock);
+out:
+        do_add_pages();
+        return rPage;
+        //return  alloc_page(GFP_HIGHUSER_MOVABLE);
+}
+#endif
+
+static int __init init_variables(void)
+{
+        number_banks = 1+(BANK_MASK >> PAGE_SHIFT); 
+        number_cachecolors = 1+(CACHE_MASK >> PAGE_SHIFT);
+}
+
+
+
+static int __init init_color_groups(void)
+{
+        struct color_group *cgroup;
+        unsigned long i;
+        int err = 0;
+
+        color_groups = kmalloc(number_cachecolors *
+                        sizeof(struct color_group), GFP_KERNEL);
+        if (!color_groups) {
+                printk(KERN_WARNING "Could not allocate color groups.\n");
+                err = -ENOMEM;
+        }else{
+
+                for (i = 0; i < number_cachecolors; ++i) {
+                        cgroup = &color_groups[i];
+                        atomic_set(&cgroup->nr_pages, 0);
+                        INIT_LIST_HEAD(&cgroup->list);
+                        spin_lock_init(&cgroup->lock);
+//                      LOCKDEP_DYNAMIC_ALLOC(&cgroup->lock, &color_lock_keys[i],
+//                                      cgroup->_lock_name, "color%lu", i);
+                }
+        }
+        return err;
+}
+
+/*
+ * Initialzie the this proc 
+ */
+static int __init litmus_color_init(void)
+{
+        int err=0;
+        
+        INIT_LIST_HEAD(&alloced_pages.list);
+        spin_lock_init(&alloced_pages.lock);
+        init_variables();
+        printk("Cache number = %d , Cache mask = 0x%lx\n", number_cachecolors, CACHE_MASK); 
+        printk("Bank number = %d , Bank mask = 0x%lx\n", number_banks, BANK_MASK); 
+        init_color_groups();                    
+        do_add_pages();
+
+        printk(KERN_INFO "Registering LITMUS^RT color and bank proc.\n");
+        return err;
+}
+
+module_init(litmus_color_init);
+
diff --git a/litmus/cache_proc.c b/litmus/cache_proc.c
index 4425bfb8bbd4..cc818b9f1fc4 100644
--- a/litmus/cache_proc.c
+++ b/litmus/cache_proc.c
@@ -242,4 +242,4 @@ out:
         return ret;
 }
 
-module_init(litmus_sysctl_init);
\ No newline at end of file
+module_init(litmus_sysctl_init);
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 6034ff8731af..dcb9ed58962c 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -392,11 +392,14 @@ static struct page *walk_page_table(unsigned long addr)
 extern int isolate_lru_page(struct page *page);
 extern void putback_lru_page(struct page *page);
 
+extern struct page *new_alloc_page(struct page *page, unsigned long node, int **x);
+
+#if 0
 static struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
 {
         return alloc_pages_exact_node(node, GFP_HIGHUSER_MOVABLE, 0);
 }
-
+#endif
 asmlinkage long sys_set_page_color(int cpu)
 {
         long ret = 0;
@@ -442,6 +445,7 @@ asmlinkage long sys_set_page_color(int cpu)
                                 continue;
                         if (!old_page)
                                 continue;
+
                         if (PageReserved(old_page)) {
                                 put_page(old_page);
                                 continue;
@@ -482,7 +486,7 @@ asmlinkage long sys_set_page_color(int cpu)
         
         ret = 0;
         if (!list_empty(&pagelist)) {
-                ret = migrate_pages(&pagelist, new_alloc_page, 0, MIGRATE_ASYNC, MR_SYSCALL);
+                ret = migrate_pages(&pagelist, new_alloc_page, 4, MIGRATE_ASYNC, MR_SYSCALL);
                 if (ret) {
                         printk(KERN_INFO "%ld pages not migrated.\n", ret);
                         putback_lru_pages(&pagelist);