aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/main.rs1
-rw-r--r--src/shareable_cache.rs100
-rw-r--r--src/trapped_cache.rs116
3 files changed, 82 insertions, 135 deletions
diff --git a/src/main.rs b/src/main.rs
index a4cf598..615a965 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,7 +10,6 @@ mod globals;
mod memory_tracker;
mod shareable_cache;
mod system;
-mod trapped_cache;
use std::fs::File;
use std::io::Read;
diff --git a/src/shareable_cache.rs b/src/shareable_cache.rs
index 6ee17c3..4da9777 100644
--- a/src/shareable_cache.rs
+++ b/src/shareable_cache.rs
@@ -1,5 +1,10 @@
use rustv::isa;
-use rustv::memory::{MemoryInterface, Result, SharedMemory};
+use rustv::memory::{MemoryError, MemoryInterface, Result, SharedMemory};
+
+pub const WRITE_TRAP_VALUE: u8 = 0x42;
+pub const AREA_TRAP_VALUE: u8 = 0x43;
+
+pub const WRITE_TRAP_STALL: u32 = 1_000_000;
/// A cache that can be used as two separate caches or one
/// set-associative cache.
@@ -45,18 +50,77 @@ impl<'a> ShareableCache<'a> {
(primary_accessible, secondary_accessible)
}
+}
+
+fn snoop(cache: &mut SharedMemory<'a>,
+ address: isa::Address, value: isa::Word) {
+ // Cache snooping: update all cache lines when a write is made
+ if cache.borrow().is_address_accessible(address) {
+ // Depends on invariant: write_word completes instantly
+ // when the address is accessible (in-cache)
+ let _ = cache.borrow_mut().write_word(address, value);
+ }
+}
+
+fn as_bytes(word: isa::Word) -> [isa::Byte; 4] {
+ [(word & 0xFF) as isa::Byte,
+ ((word >> 8) & 0xFF) as isa::Byte,
+ ((word >> 16) & 0xFF) as isa::Byte,
+ ((word >> 24) & 0xFF) as isa::Byte]
+}
+
+fn check_traps(cache: &mut MemoryInterface,
+ address: isa::Address, value: isa::Word) -> Result<()> {
+ if cache.is_address_accessible(address) {
+ // No stall - check for trap
+ let old_value = cache.read_word(address);
+
+ match old_value {
+ Ok(old_value) => {
+ // TODO: helper method on isa::Word (would require
+ // newtype) for accessing individual bytes?
+
+ let old_bytes = as_bytes(old_value);
+ let new_bytes = as_bytes(value);
- fn snoop(cache: &mut SharedMemory<'a>,
- address: isa::Address, value: isa::Word) {
- // Cache snooping: update all cache lines when a write is made
- if cache.borrow().is_address_accessible(address) {
- // Depends on invariant: write_word completes instantly
- // when the address is accessible (in-cache)
- let _ = cache.borrow_mut().write_word(address, value);
+ let mut traps_set = 0;
+ let mut traps_hit = 0;
+
+ for (old, new) in old_bytes.iter().zip(new_bytes.iter()) {
+ if *old == WRITE_TRAP_VALUE &&
+ *new != WRITE_TRAP_VALUE {
+ traps_hit += 1;
+ }
+ else if *old != WRITE_TRAP_VALUE &&
+ *new == WRITE_TRAP_VALUE {
+ traps_set += 1;
+ }
+ }
+
+ if traps_hit > 0 {
+ info!("[memory] {} write trap(s) hit at address {:x},\
+ stalling for 1_000_000 cycles each",
+ traps_hit, address);
+ Err(MemoryError::CacheMiss {
+ stall_cycles: traps_hit * WRITE_TRAP_STALL,
+ })
+ }
+ else {
+ cache.cache.write_word(address, value)
+ }
+ }
+ Err(e) => {
+ panic!("Could not read accessible value: {:?}", e)
+ }
}
}
+ else {
+ // Not in cache - defer to fetch
+ cache.cache.write_word(address, value)
+ }
}
+
impl<'a> MemoryInterface for ShareableCache<'a> {
fn latency(&self) -> u32 {
self.primary.borrow().latency()
@@ -112,28 +176,28 @@ impl<'a> MemoryInterface for ShareableCache<'a> {
self.address_accessible(address);
if primary_accessible {
- ShareableCache::snoop(&mut self.secondary, address, value);
- self.primary.borrow_mut().write_word(address, value)
+ snoop(&mut self.secondary, address, value);
+ check_traps(&self.primary.borrow_mut(), address, value)
}
else if secondary_accessible {
- ShareableCache::snoop(&mut self.primary, address, value);
- self.secondary.borrow_mut().write_word(address, value)
+ snoop(&mut self.primary, address, value);
+ check_traps(&self.secondary.borrow_mut(), address, value)
}
else {
self.use_secondary = !self.use_secondary;
if self.use_secondary {
- ShareableCache::snoop(&mut self.primary, address, value);
- self.secondary.borrow_mut().write_word(address, value)
+ snoop(&mut self.primary, address, value);
+ check_traps(&self.secondary.borrow_mut(), address, value)
}
else {
- ShareableCache::snoop(&mut self.secondary, address, value);
- self.primary.borrow_mut().write_word(address, value)
+ snoop(&mut self.secondary, address, value);
+ check_traps(&self.primary.borrow_mut(), address, value)
}
}
}
else {
- ShareableCache::snoop(&mut self.secondary, address, value);
- self.primary.borrow_mut().write_word(address, value)
+ snoop(&mut self.secondary, address, value);
+ check_traps(&self.primary.borrow_mut(), address, value)
}
}
}
diff --git a/src/trapped_cache.rs b/src/trapped_cache.rs
deleted file mode 100644
index 690a734..0000000
--- a/src/trapped_cache.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use rustv::isa;
-use rustv::memory::{MemoryError, MemoryInterface, Result};
-
-pub const WRITE_TRAP_VALUE: u8 = 0x42;
-pub const AREA_TRAP_VALUE: u8 = 0x43;
-
-pub const WRITE_TRAP_STALL: MemoryError = MemoryError::CacheMiss {
- stall_cycles: 10000
-};
-
-/// A cache that stalls when a trap is triggered.
-pub struct TrappedCache<T: MemoryInterface> {
- cache: T,
- half: isa::Address,
-}
-
-// TODO: move this t
-enum WordOffset {
- Byte0,
- Byte1,
- Byte2,
- Byte3,
-}
-
-impl<T: MemoryInterface> TrappedCache<T> {
- pub fn new(cache: T, half: isa::Address) -> TrappedCache<T> {
- TrappedCache {
- cache: cache,
- half: half,
- }
- }
-
- fn clear_trap(&mut self, address: isa::Address, offset: WordOffset) {
- // Precondition: address is in the cache and can be
- // read/written without stalling
- match self.read_word(address) {
- Ok(value) => {
- let new_value = match offset {
- WordOffset::Byte0 => value & 0xFFFFFF00,
- WordOffset::Byte1 => value & 0xFFFF00FF,
- WordOffset::Byte2 => value & 0xFF00FFFF,
- WordOffset::Byte3 => value & 0x00FFFFFF,
- };
-
- match self.write_word(address, new_value) {
- Ok(()) => {},
- Err(e) => panic!("{:?}", e),
- }
- },
- Err(e) => panic!("{:?}", e),
- }
- }
-}
-
-impl<T: MemoryInterface> MemoryInterface for TrappedCache<T> {
- fn latency(&self) -> u32 {
- self.cache.latency()
- }
-
- fn step(&mut self) {
- self.cache.step();
- }
-
- fn is_address_accessible(&self, address: isa::Address) -> bool {
- self.cache.is_address_accessible(address)
- }
-
- fn read_word(&mut self, address: isa::Address) -> Result<isa::Word> {
- self.cache.read_word(address)
- }
-
- fn write_word(&mut self, address: isa::Address,
- value: isa::Word) -> Result<()> {
- if self.is_address_accessible(address) {
- // No stall - check for trap
- let old_value = self.read_word(address);
-
- match old_value {
- Ok(old_value) => {
- // TODO: helper method on isa::Word (would require
- // newtype) for accessing individual bytes?
- if ((old_value & 0xFF) as u8) == WRITE_TRAP_VALUE &&
- ((value & 0xFF) as u8) != WRITE_TRAP_VALUE {
- self.clear_trap(old_value, WordOffset::Byte0);
- Err(WRITE_TRAP_STALL)
- }
- else if (((old_value >> 8) & 0xFF) as u8) == WRITE_TRAP_VALUE &&
- (((value >> 8) & 0xFF) as u8) == WRITE_TRAP_VALUE {
- self.clear_trap(old_value, WordOffset::Byte1);
- Err(WRITE_TRAP_STALL)
- }
- else if (((old_value >> 16) & 0xFF) as u8) == WRITE_TRAP_VALUE &&
- (((value >> 16) & 0xFF) as u8) == WRITE_TRAP_VALUE {
- self.clear_trap(old_value, WordOffset::Byte2);
- Err(WRITE_TRAP_STALL)
- }
- else if (((old_value >> 24) & 0xFF) as u8) == WRITE_TRAP_VALUE &&
- (((value >> 24) & 0xFF) as u8) == WRITE_TRAP_VALUE {
- self.clear_trap(old_value, WordOffset::Byte3);
- Err(WRITE_TRAP_STALL)
- }
- else {
- self.cache.write_word(address, value)
- }
- }
- Err(e) => {
- panic!("Could not read accessible value: {:?}", e)
- }
- }
- }
- else {
- // Not in cache - defer to fetch
- self.cache.write_word(address, value)
- }
- }
-}