Use (Interleaving off), and provide system variables to adjust the size

of cache and bank number

2 files changed, 407 insertions, 146 deletions

diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
index 05c7fc3df98c..7cf07ee1dad9 100644
--- a/litmus/bank_proc.c
+++ b/litmus/bank_proc.c
@@ -18,22 +18,58 @@
 #include <litmus/litmus_proc.h>
 #include <litmus/sched_trace.h>
 
-
 #define LITMUS_LOCKDEP_NAME_MAX_LEN 50
 
 // This Address Decoding is used in imx6-sabredsd platform
-#define CACHE_MASK 0x0000f000      
-#define BANK_MASK  0x00007000      
-#define OFFSET_SHIFT 12
+#define BANK_MASK  0x38000000     
+#define BANK_SHIFT  27
+#define CACHE_MASK  0x0000f000      
+#define CACHE_SHIFT 12
+
+#define PAGES_PER_COLOR 256
+unsigned int NUM_PAGE_LIST;  //8*16
+
+unsigned int number_banks;
+unsigned int number_cachecolors;
+
+unsigned int set_partition_max = 0x0000ffff;
+unsigned int set_partition_min = 0;
+unsigned int bank_partition_max = 0x000000ff;
+unsigned int bank_partition_min = 0;
+
+unsigned int set_partition[9] = {
+        0x00000003,  /* Core 0, and Level A*/
+        0x00000003,  /* Core 0, and Level B*/
+        0x0000000C,  /* Core 1, and Level A*/
+        0x0000000C,  /* Core 1, and Level B*/
+        0x00000030,  /* Core 2, and Level A*/
+        0x00000030,  /* Core 2, and Level B*/
+        0x000000C0,  /* Core 3, and Level A*/
+        0x000000C0,  /* Core 3, and Level B*/
+        0x0000ff00,  /* Level C */
+};
 
-#define PAGES_PER_COLOR 1024
+unsigned int bank_partition[9] = {
+        0x00000010,  /* Core 0, and Level A*/
+        0x00000010,  /* Core 0, and Level B*/
+        0x00000020,  /* Core 1, and Level A*/
+        0x00000020,  /* Core 1, and Level B*/
+        0x00000040,  /* Core 2, and Level A*/
+        0x00000040,  /* Core 2, and Level B*/
+        0x00000080,  /* Core 3, and Level A*/
+        0x00000080,  /* Core 3, and Level B*/
+        0x0000000f,  /* Level C */
+};
 
-unsigned long curr_cachecolor;
-int used_cachecolor;
+unsigned int set_index[9] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0
+};
 
+unsigned int bank_index[9] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0
+};
 
-unsigned long number_banks;
-unsigned long number_cachecolors;
+struct mutex void_lockdown_proc;
 
 
 /*
@@ -46,39 +82,80 @@ struct color_group {
         atomic_t nr_pages;
 };
 
+
+static struct color_group *color_groups;
+
 /*
- * This is old code which is not used in current version
- */ 
-/*
-static struct alloced_pages {
-        spinlock_t lock;
-        struct list_head list;
-} alloced_pages;
+ * Naive function to count the number of 1's
+ */
+unsigned int counting_one_set(unsigned int v)
+{
+//    unsigned int v; // count the number of bits set in v
+    unsigned int c; // c accumulates the total bits set in v
+
+    for (c = 0; v; v >>= 1)
+    {
+        c += v & 1;
+    }
+    return c;
+}
 
-struct alloced_page {
-        struct page *page;
-        struct vm_area_struct *vma;
-        struct list_head list;
-};
-*/
+unsigned int two_exp(unsigned int e)
+{
+    unsigned int v = 1;
+    for (e; e>0; e-- )
+    {
+        v=v*2;
+    }
+    return v;
+}
+
+unsigned int num_by_bitmask_index(bitmask, index)
+{
+    unsigned int pos = 0;
+
+    while(true)
+    {
+        if(index ==0 && (bitmask & 1)==1)
+        {
+            break;
+        }
+        if(index !=0 && (bitmask & 1)==1){
+            index--;
+        }
+        pos++;
+        bitmask = bitmask >>1;
+
+    }
+    return pos;
+}
 
-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)
+static inline unsigned int page_color(struct page *page)
 {
-        return ((page_to_phys(page)& CACHE_MASK) >> PAGE_SHIFT);
+        return ((page_to_phys(page)& CACHE_MASK) >> CACHE_SHIFT);
 }
 
 /* Decoding page bank number, 0~7 */ 
-static inline unsigned long page_bank(struct page *page)
+static inline unsigned int page_bank(struct page *page)
 {
-        return ((page_to_phys(page)& BANK_MASK) >> PAGE_SHIFT);
+        return ((page_to_phys(page)& BANK_MASK) >> BANK_SHIFT);
 }
 
+static inline unsigned int page_list_index(struct page *page)
+{
+    unsigned int idx;  
+    idx = (page_color(page) + page_bank(page)*(number_cachecolors));
+//    printk("address = %lx, ", page_to_phys(page));
+//    printk("color(%d), bank(%d), indx = %d\n", page_color(page), page_bank(page), idx);
+
+    return idx; 
+}
+
+
+
 /*
  * It is used to determine the smallest number of page lists. 
  */
@@ -86,7 +163,7 @@ static unsigned long smallest_nr_pages(void)
 {
         unsigned long i, min_pages = -1;
         struct color_group *cgroup;
-        for (i = 0; i < number_cachecolors; ++i) {
+        for (i = 0; i < NUM_PAGE_LIST; ++i) {
                 cgroup = &color_groups[i];
                 if (atomic_read(&cgroup->nr_pages) < min_pages)
                         min_pages = atomic_read(&cgroup->nr_pages);
@@ -94,12 +171,22 @@ static unsigned long smallest_nr_pages(void)
         return min_pages;
 }
 
+static void show_nr_pages(void)
+{
+        unsigned long i;
+        struct color_group *cgroup;
+        for (i = 0; i < NUM_PAGE_LIST; ++i) {
+                cgroup = &color_groups[i];
+                printk("i =%d, nr_pages = %d\n", i, atomic_read(&cgroup->nr_pages));
+        }
+}
+
 /*
  * Add a page to current pool.
  */
 void add_page_to_color_list(struct page *page)
 {
-        const unsigned long color = page_color(page);
+        const unsigned long color = page_list_index(page);
         struct color_group *cgroup = &color_groups[color];
         BUG_ON(in_list(&page->lru) || PageLRU(page));
         BUG_ON(page_count(page) > 1);
@@ -116,38 +203,47 @@ void add_page_to_color_list(struct page *page)
  */
 static int do_add_pages(void)
 {
-//      printk("LITMUS do add pages\n");
+        printk("LITMUS do add pages\n");
         
         struct page *page, *page_tmp;
         LIST_HEAD(free_later);
         unsigned long color;
         int ret = 0;
+        int i = 0;
 
         // until all the page lists contain enough pages 
+        //for (i =0; i<5; i++) {
         while (smallest_nr_pages() < PAGES_PER_COLOR) {
         
                 page = alloc_page(GFP_HIGHUSER_MOVABLE);
-                
                 if (unlikely(!page)) {
-        //              printk(KERN_WARNING "Could not allocate pages.\n");
+                        printk(KERN_WARNING "Could not allocate pages.\n");
                         ret = -ENOMEM;
                         goto out;
                 }
-                color = page_color(page);
+                color = page_list_index(page);
+                //show_nr_pages();
+                //printk("before : nr_pages = %d\n", atomic_read(&color_groups[color].nr_pages));
                 if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR) {
                         add_page_to_color_list(page);
                 } else{
                         // Pages here will be freed later 
                         list_add_tail(&page->lru, &free_later);
                 }
-        }
+               //show_nr_pages();
+                //printk("after : nr_pages = %d\n", atomic_read(&color_groups[color].nr_pages));
+
+        }
+        show_nr_pages();
+#if 1
         // Free the unwanted pages
         list_for_each_entry_safe(page, page_tmp, &free_later, lru) {
                 list_del(&page->lru);
                 __free_page(page);
         }
+#endif
 out:
-        return ret;
+        return ret;
 }
 
 /*
@@ -162,7 +258,7 @@ static struct  page *new_alloc_page_color( unsigned long color)
         struct color_group *cgroup;
         struct page *rPage = NULL;
                 
-        if( (color <0) || (color)>15) {
+        if( (color <0) || (color)>(number_cachecolors*number_banks -1)) {
                 TRACE_CUR("Wrong color %lu\n", color);  
 //              printk(KERN_WARNING "Wrong color %lu\n", color);
                 goto out_unlock;
@@ -192,31 +288,17 @@ out:
 
 
 /*
- * Provide pages for replacement 
- * This is used to generate experiments 
- */
-struct page *new_alloc_page_predefined(struct page *page,  int **x)
-{
-        unsigned int color = curr_cachecolor; 
-        
-//      printk("allocate new page color = %d\n", color);        
-        struct color_group *cgroup;
-        struct page *rPage = NULL;
-        
-        rPage =  new_alloc_page_color(color);
-        curr_cachecolor = (color + 1)% used_cachecolor;
-out:
-        return rPage;
-}
-/*
  * provide pages for replacement according to  
- * 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 
+ * node = 0 for Level A tasks in Cpu 0
+ * node = 1 for Level B tasks in Cpu 0
+ * node = 2 for Level A tasks in Cpu 1
+ * node = 3 for Level B tasks in Cpu 1
+ * node = 4 for Level A tasks in Cpu 2
+ * node = 5 for Level B tasks in Cpu 2
+ * node = 6 for Level A tasks in Cpu 3
+ * node = 7 for Level B tasks in Cpu 3
+ * node = 8 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);  
@@ -224,79 +306,20 @@ struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
         struct color_group *cgroup;
         struct page *rPage = NULL;
         unsigned int color;
-        get_random_bytes(&color, sizeof(unsigned int));
         
-        // Decode the node to decide what color pages we should provide
-        switch(node ){
-                case 0:
-                case 1:
-                case 2:
-                case 3:
-                        color = (color%4) * 4 + node;
-                case 4:
-                        color = (color%16);
-/*
-                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:
-                        TRACE_CUR("Wrong color %lu\n", color);  
-                        return rPage;
-*/
-        }
 
+        unsigned int idx = 0;
+        idx += num_by_bitmask_index(set_partition[node], set_index[node]);
+        idx += number_cachecolors* num_by_bitmask_index(bank_partition[node], bank_index[node]);
+        printk("node  = %d, idx = %d\n", node, idx);
 
-//      printk("allocate new page color = %d\n", color);
-                
-        rPage =  new_alloc_page_color(color);
+        rPage =  new_alloc_page_color(idx);
+        
+            
+        set_index[node] = (set_index[node]+1) % counting_one_set(set_partition[node]);
+        bank_index[node] = (bank_index[node]+1) % counting_one_set(bank_partition[node]);
         return rPage; 
 }
-#else
-struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
-{
-        return new_alloc_page_predefined(page,  x);
-}
-#endif
-
-/*
- * Provide pages for replacement according to bank number. 
- * This is used in cache way partition 
- */
-struct page *new_alloc_page_banknr(struct page *page, unsigned long banknr, int **x)
-{
-//      printk("allocate new page bank = %d\n", banknr);        
-        struct color_group *cgroup;
-        struct page *rPage = NULL;
-        unsigned int color;
-        get_random_bytes(&color, sizeof(unsigned int));
-        
-        if((banknr<= 7) && (banknr>=0)){
-                color = (color%2) * 8 + banknr;
-        }else{
-                goto out;
-        }
-        
-        rPage =  new_alloc_page_color(color);
-                
-out:
-        return rPage;
-}
-
-
-void set_number_of_colors(int colornr)
-{
-//      printk(KERN_WARNING "Set of colors = %d.\n", colornr);
-        used_cachecolor = colornr ; 
-        curr_cachecolor = 0;
-}
 
 
 
@@ -306,12 +329,14 @@ void set_number_of_colors(int colornr)
  */ 
 static int __init init_variables(void)
 {
-        number_banks = 1+(BANK_MASK >> PAGE_SHIFT); 
-        number_cachecolors = 1+(CACHE_MASK >> PAGE_SHIFT);
-        used_cachecolor = 16;
-        curr_cachecolor = 0;
-
-        
+        number_banks = counting_one_set(BANK_MASK); 
+        number_banks = two_exp(number_banks); 
+
+        number_cachecolors = counting_one_set(CACHE_MASK);
+        number_cachecolors = two_exp(number_cachecolors);
+        NUM_PAGE_LIST = number_banks * number_cachecolors; 
+        printk(KERN_WARNING "number of banks = %d, number of cachecolors=%d\n", number_banks, number_cachecolors);
+        mutex_init(&void_lockdown_proc);
 }
 
 
@@ -324,39 +349,274 @@ static int __init init_color_groups(void)
         unsigned long i;
         int err = 0;
 
-        color_groups = kmalloc(number_cachecolors *
-                        sizeof(struct color_group), GFP_KERNEL);
+        printk("NUM_PAGE_LIST = %d\n", NUM_PAGE_LIST);
+        color_groups = kmalloc(NUM_PAGE_LIST *sizeof(struct color_group), GFP_KERNEL);
+
         if (!color_groups) {
-//              printk(KERN_WARNING "Could not allocate color groups.\n");
+                printk(KERN_WARNING "Could not allocate color groups.\n");
                 err = -ENOMEM;
         }else{
 
-                for (i = 0; i < number_cachecolors; ++i) {
+                for (i = 0; i < NUM_PAGE_LIST; ++i) {
                         cgroup = &color_groups[i];
                         atomic_set(&cgroup->nr_pages, 0);
                         INIT_LIST_HEAD(&cgroup->list);
                         spin_lock_init(&cgroup->lock);
                 }
         }
-        return err;
+        return err;
+}
+
+int set_partition_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        int ret = 0, i = 0;
+        mutex_lock(&void_lockdown_proc);
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        if (ret)
+                goto out;
+        if (write) {
+            printk("New set Partition : \n");
+            for(i =0;i <9;i++)
+            {
+                set_index[i] = 0;
+                printk("set[%d] = %x \n", i, set_partition[i]);
+            }
+        }
+out:
+        mutex_unlock(&void_lockdown_proc);
+        return ret;
 }
 
+int bank_partition_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        int ret = 0, i = 0;
+        mutex_lock(&void_lockdown_proc);
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        if (ret)
+                goto out;
+        if (write) {
+            for(i =0;i <9;i++)
+            {
+                bank_index[i] = 0;
+            }
+        }
+out:
+        mutex_unlock(&void_lockdown_proc);
+        return ret;
+}
+
+
+static struct ctl_table cache_table[] =
+{
+        
+        {
+                .procname       = "C0_LA_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[0],
+                .maxlen         = sizeof(set_partition[0]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },      
+        {
+                .procname       = "C0_LB_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[1],
+                .maxlen         = sizeof(set_partition[1]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },      
+        {
+                .procname       = "C1_LA_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[2],
+                .maxlen         = sizeof(set_partition[2]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },
+        {
+                .procname       = "C1_LB_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[3],
+                .maxlen         = sizeof(set_partition[3]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },
+        {
+                .procname       = "C2_LA_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[4],
+                .maxlen         = sizeof(set_partition[4]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },
+        {
+                .procname       = "C2_LB_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[5],
+                .maxlen         = sizeof(set_partition[5]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },
+        {
+                .procname       = "C3_LA_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[6],
+                .maxlen         = sizeof(set_partition[6]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },
+        {
+                .procname       = "C3_LB_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[7],
+                .maxlen         = sizeof(set_partition[7]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },      
+        {
+                .procname       = "Call_LC_set",
+                .mode           = 0666,
+                .proc_handler   = set_partition_handler,
+                .data           = &set_partition[8],
+                .maxlen         = sizeof(set_partition[8]),
+                .extra1         = &set_partition_min,
+                .extra2         = &set_partition_max,
+        },      
+        {
+                .procname       = "C0_LA_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[0],
+                .maxlen         = sizeof(set_partition[0]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },
+        {
+                .procname       = "C0_LB_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[1],
+                .maxlen         = sizeof(set_partition[1]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },              
+        {
+                .procname       = "C1_LA_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[2],
+                .maxlen         = sizeof(set_partition[2]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },
+        {
+                .procname       = "C1_LB_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[3],
+                .maxlen         = sizeof(set_partition[3]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },
+        {
+                .procname       = "C2_LA_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[4],
+                .maxlen         = sizeof(set_partition[4]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },      
+        {
+                .procname       = "C2_LB_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[5],
+                .maxlen         = sizeof(set_partition[5]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },              
+        {
+                .procname       = "C3_LA_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[6],
+                .maxlen         = sizeof(set_partition[6]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },      
+        {
+                .procname       = "C3_LB_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[7],
+                .maxlen         = sizeof(set_partition[7]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },      
+        {
+                .procname       = "Call_LC_bank",
+                .mode           = 0666,
+                .proc_handler   = bank_partition_handler,
+                .data           = &bank_partition[8],
+                .maxlen         = sizeof(set_partition[8]),
+                .extra1         = &bank_partition_min,
+                .extra2         = &bank_partition_max,
+        },      
+
+
+        { }
+};
+
+static struct ctl_table litmus_dir_table[] = {
+        {
+                .procname       = "litmus",
+                .mode           = 0555,
+                .child          = cache_table,
+        },
+        { }
+};
+
+
+static struct ctl_table_header *litmus_sysctls;
+
+
 /*
  * Initialzie this proc 
  */
 static int __init litmus_color_init(void)
 {
         int err=0;
-        
+        printk("Init bankproc.c\n");
+
         //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); 
+
+        printk(KERN_INFO "Registering LITMUS^RT proc color sysctl.\n");
+
+        litmus_sysctls = register_sysctl_table(litmus_dir_table);
+        if (!litmus_sysctls) {
+                printk(KERN_WARNING "Could not register LITMUS^RT color sysctl.\n");
+                err = -EFAULT;
+                goto out;
+        }
+
         init_color_groups();                    
         do_add_pages();
 
-//      printk(KERN_INFO "Registering LITMUS^RT color and bank proc.\n");
+        printk(KERN_INFO "Registering LITMUS^RT color and bank proc.\n");
+out:
         return err;
 }
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 77c609b5a932..035207991732 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -390,7 +390,7 @@ do_return:
 extern int isolate_lru_page(struct page *page);
 extern void putback_lru_page(struct page *page);
 
-#if 1
+#if 0
 static struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
 {
         return alloc_pages_exact_node(0, GFP_HIGHUSER_MOVABLE, 0);
@@ -501,7 +501,8 @@ asmlinkage long sys_set_page_color(int cpu)
                 node = 4;
         else
                 node = cpu;
-        
+
+        //node= 0;
         if (!list_empty(&pagelist)) {
                 ret = migrate_pages(&pagelist, new_alloc_page, node, MIGRATE_ASYNC, MR_SYSCALL);
                 TRACE_TASK(current, "%ld pages not migrated.\n", ret);