aboutsummaryrefslogtreecommitdiff
path: root/src/shareable_cache.rs
blob: a8fee5153f64d555e510296e529c03181c2196b6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
use std::cell::RefCell;
use std::rc::Rc;

use rustv::isa;
use rustv::memory::{MemoryInterface, Result, SharedMemory};

/// A cache that can be used as two separate caches or one
/// set-associative cache.
#[derive(Clone)]
pub struct ShareableCache<'a> {
    // The idea is to create two separate ShareableCaches, one for
    // each player.
    primary: SharedMemory<'a>,
    secondary: SharedMemory<'a>,
    secondary_enabled: bool,
    use_secondary: bool,
}

impl<'a> ShareableCache<'a> {
    pub fn new(cache1: SharedMemory<'a>, cache2: SharedMemory<'a>)
               -> (Rc<RefCell<ShareableCache<'a>>>,
                   Rc<RefCell<ShareableCache<'a>>>) {
        (Rc::new(RefCell::new(ShareableCache {
            primary: cache1.clone(),
            secondary: cache2.clone(),
            secondary_enabled: false,
            use_secondary: false,
        })), Rc::new(RefCell::new(ShareableCache {
            primary: cache2.clone(),
            secondary: cache1.clone(),
            secondary_enabled: false,
            use_secondary: false,
        })))
    }

    pub fn enable_secondary(&mut self) {
        self.secondary_enabled = true;
        self.use_secondary = true;
    }

    pub fn disable_secondary(&mut self) {
        self.secondary_enabled = false;
    }
}

impl<'a> MemoryInterface for ShareableCache<'a> {
    fn latency(&self) -> u32 {
        self.primary.borrow().latency()
    }

    fn step(&mut self) {
        // We only step the primary cache. The idea is that the
        // secondary cache should be the primary cache of another
        // ShareableCache.
        self.primary.borrow_mut().step();
    }

    fn is_address_accessible(&self, address: isa::Address) -> bool {
        self.primary.borrow().is_address_accessible(address) ||
            (self.secondary_enabled &&
             self.secondary.borrow().is_address_accessible(address))
    }

    fn read_word(&mut self, address: isa::Address) -> Result<isa::Word> {
        if self.secondary_enabled {
            if self.primary.borrow().is_address_accessible(address) {
                self.primary.borrow_mut().read_word(address)
            }
            else if self.secondary.borrow().is_address_accessible(address) {
                self.secondary.borrow_mut().read_word(address)
            }
            else {
                self.use_secondary = !self.use_secondary;
                if self.use_secondary {
                    self.secondary.borrow_mut().read_word(address)
                }
                else {
                    self.primary.borrow_mut().read_word(address)
                }
            }
        }
        else {
            self.primary.borrow_mut().read_word(address)
        }
    }

    fn write_word(&mut self, address: isa::Address, value: isa::Word) -> Result<()> {
        if self.secondary_enabled {
            if self.primary.borrow().is_address_accessible(address) {
                self.primary.borrow_mut().write_word(address, value)
            }
            else if self.secondary.borrow().is_address_accessible(address) {
                self.secondary.borrow_mut().write_word(address, value)
            }
            else {
                self.use_secondary = !self.use_secondary;
                if self.use_secondary {
                    self.secondary.borrow_mut().write_word(address, value)
                }
                else {
                    self.primary.borrow_mut().write_word(address, value)
                }
            }
        }
        else {
            self.primary.borrow_mut().write_word(address, value)
        }
    }
}