Rename KMALLOC_* -> MEM_* [2/2]
[akaros.git] / kern / src / colored_caches.c
index 38bcc12..354a61e 100644 (file)
@@ -5,34 +5,34 @@
  * Kevin Klues <klueska@cs.berkeley.edu>    
  */
 
-#ifdef __SHARC__
-#pragma nosharc
-#define SINIT(x) x
-#endif
-
 #include <ros/common.h>
 #include <arch/mmu.h>
-#include <arch/bitmask.h>
+#include <bitmask.h>
 #include <colored_caches.h>
 #include <stdio.h>
 #include <atomic.h>
 #include <kmalloc.h>
+#include <page_alloc.h>
 
 #define l1 (available_caches.l1)
 #define l2 (available_caches.l2)
 #define l3 (available_caches.l3)
 
-spinlock_t cache_colors_lock;
+spinlock_t cache_colors_lock = SPINLOCK_INITIALIZER_IRQSAVE;
 
 /************** Cache Related Functions  *****************/
 inline void init_cache_properties(cache_t *c, size_t sz_k, size_t wa, size_t clsz) {
-       c->wa = SINIT(wa);
-       c->sz_k = SINIT(sz_k);
-       c->clsz = SINIT(clsz);
+       c->wa = wa;
+       c->sz_k = sz_k;
+       c->clsz = clsz;
 
+#ifdef CONFIG_PAGE_COLORING
        //Added as optimization (derived from above);
        size_t nc = get_cache_num_page_colors(c);
-       c->num_colors = SINIT(nc);
+       c->num_colors = nc;
+#else
+       c->num_colors = 1;
+#endif
 }
 
 inline void init_free_cache_colors_map(cache_t* c) 
@@ -42,14 +42,11 @@ inline void init_free_cache_colors_map(cache_t* c)
        FILL_BITMASK(c->free_colors_map, c->num_colors);
 }
 
-inline size_t get_page_color(uintptr_t page, cache_t *c) {
-    return (page % c->num_colors);
-}
 inline size_t get_offset_in_cache_line(uintptr_t addr, cache_t *c) {
     return (addr % get_cache_bytes_per_line(c));
 }
 
-void print_cache_properties(char *NT lstring, cache_t *c)
+void print_cache_properties(char *lstring, cache_t *c)
 {
        printk("%s_WAYS_ASSOCIATIVE: %ld\n", lstring, get_cache_ways_associative(c));
        printk("%s_LINE_SIZE_BYTES: %ld\n", lstring, get_cache_line_size_bytes(c));
@@ -167,7 +164,7 @@ static inline void clr_color_range(uint16_t color, uint8_t* map,
 }
 
 static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c, 
-                                                              struct proc* p) 
+                                                         uint8_t* colors_map) 
 {
        if(!GET_BITMASK_BIT(c->free_colors_map, color))
                return -ENOCACHE;       
@@ -179,12 +176,11 @@ static inline error_t __cache_color_alloc_specific(size_t color, cache_t* c,
        if(l3)
                clr_color_range(color, l3->free_colors_map, c, l3);
 
-       printk("I am here now three...\n");
-       set_color_range(color, p->cache_colors_map, c, llc_cache);
+       set_color_range(color, colors_map, c, llc_cache);
        return ESUCCESS;
 }
 
-static inline error_t __cache_color_alloc(cache_t* c, struct proc* p) 
+static inline error_t __cache_color_alloc(cache_t* c, uint8_t* colors_map) 
 {
        if(BITMASK_IS_CLEAR(c->free_colors_map, c->num_colors))
                return -ENOCACHE;       
@@ -195,18 +191,18 @@ static inline error_t __cache_color_alloc(cache_t* c, struct proc* p)
                        break;
        } while(++color);
 
-       return __cache_color_alloc_specific(color, c, p);       
+       return __cache_color_alloc_specific(color, c, colors_map);      
 }
 
 static inline void __cache_color_free_specific(size_t color, cache_t* c, 
-                                                          struct proc* p) 
+                                                     uint8_t* colors_map) 
 {
        if(GET_BITMASK_BIT(c->free_colors_map, color))
                return;
        else {
                size_t r = llc_cache->num_colors / c->num_colors;
                size_t base = color*r;
-               if(!BITMASK_IS_SET_IN_RANGE(p->cache_colors_map, base, base+r))
+               if(!BITMASK_IS_SET_IN_RANGE(colors_map, base, base+r))
                        return;
        }
 
@@ -217,10 +213,10 @@ static inline void __cache_color_free_specific(size_t color, cache_t* c,
        if(l1)
                set_color_range(color, l1->free_colors_map, c, l1);
 
-       clr_color_range(color, p->cache_colors_map, c, llc_cache);
+       clr_color_range(color, colors_map, c, llc_cache);
 }
 
-static inline void __cache_color_free(cache_t* c, struct proc* p) 
+static inline void __cache_color_free(cache_t* c, uint8_t* colors_map) 
 {
        if(BITMASK_IS_FULL(c->free_colors_map, c->num_colors))
                return; 
@@ -230,41 +226,58 @@ static inline void __cache_color_free(cache_t* c, struct proc* p)
                if(!GET_BITMASK_BIT(c->free_colors_map, color)) {
                        size_t r = llc_cache->num_colors / c->num_colors;
                        size_t base = color*r;
-                       if(BITMASK_IS_SET_IN_RANGE(p->cache_colors_map, base, base+r))
+                       if(BITMASK_IS_SET_IN_RANGE(colors_map, base, base+r))
                                break;
                }
        } while(++color < c->num_colors);
        if(color == c->num_colors)
                return;
 
-       __cache_color_free_specific(color, c, p);       
+       __cache_color_free_specific(color, c, colors_map);      
+}
+
+uint8_t* cache_colors_map_alloc() {
+#ifdef CONFIG_PAGE_COLORING
+       uint8_t* colors_map = kmalloc(llc_cache->num_colors, 0);
+       if(colors_map)
+               CLR_BITMASK(colors_map, llc_cache->num_colors);
+       return colors_map;
+#else
+       return global_cache_colors_map;
+#endif
+}
+
+void cache_colors_map_free(uint8_t* colors_map) {
+#ifdef CONFIG_PAGE_COLORING
+       kfree(colors_map);
+#endif
 }
 
-error_t cache_color_alloc(cache_t* c, struct proc* p) 
+error_t cache_color_alloc(cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       error_t e = __cache_color_alloc(c, p);
+       error_t e = __cache_color_alloc(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
        return e;
 }
-error_t cache_color_alloc_specific(size_t color, cache_t* c, struct proc* p) 
+error_t cache_color_alloc_specific(size_t color, cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       error_t e = __cache_color_alloc_specific(color, c, p);
+       error_t e = __cache_color_alloc_specific(color, c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
        return e;
 }
 
-void cache_color_free(cache_t* c, struct proc* p) 
+void cache_color_free(cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       __cache_color_free(c, p);
+       __cache_color_free(c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
 }
-void cache_color_free_specific(size_t color, cache_t* c, struct proc* p) 
+void cache_color_free_specific(size_t color, cache_t* c, uint8_t* colors_map) 
 {
        spin_lock_irqsave(&cache_colors_lock);
-       __cache_color_free_specific(color, c, p);
+       __cache_color_free_specific(color, c, colors_map);
        spin_unlock_irqsave(&cache_colors_lock);
 }