117 lines
3.3 KiB
Rust
117 lines
3.3 KiB
Rust
use std::{rc::Rc, cell::RefCell};
|
|
|
|
use super::process::Process;
|
|
use crate::{simulator::machine::{NUM_INT_REGS, NUM_FP_REGS, STACK_REG}};
|
|
|
|
const STACK_FENCEPOST: u32 = 0xdeadbeef;
|
|
|
|
/// Polymorphic macro to get thread without passing a name by default
|
|
#[macro_export]
|
|
macro_rules! get_new_thread {
|
|
() => { Thread::new(DEFAULT_THREAD_NAME) };
|
|
($a:literal) => {
|
|
Thread::new(&$a.to_string())
|
|
};
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
pub struct ThreadContext {
|
|
pub int_registers: [i64; NUM_INT_REGS],
|
|
pub float_registers: [f32; NUM_FP_REGS],
|
|
pub pc: u64,
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
pub struct Thread {
|
|
name: String,
|
|
pub process: Option<Rc<RefCell<Process>>>,
|
|
pub thread_context: ThreadContext,
|
|
pub stack_pointer: i32,
|
|
}
|
|
|
|
impl Thread {
|
|
|
|
/// Thread constructor
|
|
pub fn new(name: &str) -> Self {
|
|
Self {
|
|
name: String::from(name),
|
|
process: None,
|
|
// simulation_context: UContextT::new(),
|
|
thread_context: ThreadContext {
|
|
int_registers: [0; NUM_INT_REGS],
|
|
float_registers: [0f32; NUM_FP_REGS],
|
|
pc: 0
|
|
},
|
|
stack_pointer: 0,
|
|
}
|
|
}
|
|
|
|
pub fn init_thread_context(&mut self, initial_pc_reg: u64, initial_sp: u64, arg: i64) {
|
|
self.thread_context.pc = initial_pc_reg;
|
|
self.thread_context.int_registers[10] = arg;
|
|
self.thread_context.int_registers[STACK_REG] = initial_sp as i64;
|
|
}
|
|
|
|
/// Check if a thread has overflowed its stack
|
|
///
|
|
/// This assertion doesn't catch all stack overflow conditions and your program may still crash because of an overflow.
|
|
///
|
|
pub fn check_overflow(&self) {
|
|
// if self.simulator_context.stackBottom != STACK_FENCEPOST {
|
|
// panic!("thread {} has overflowed", self.get_name())
|
|
// }
|
|
}
|
|
|
|
pub fn get_name(&self) -> String {
|
|
self.name.clone()
|
|
}
|
|
|
|
/// Return reference to an optional Process
|
|
/// can be None if Thread hasn't been initialize
|
|
pub fn get_process_owner(&self) -> &Option<Rc<RefCell<Process>>> {
|
|
&self.process
|
|
}
|
|
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
|
|
use super::{Thread, ThreadContext, NUM_INT_REGS, NUM_FP_REGS};
|
|
const DEFAULT_THREAD_NAME: &str = "test_thread";
|
|
|
|
/// This macro allows for getting a Thread for which we've ensured proper initial state
|
|
/// in case a commit further down the line changes the initial state of threads generated
|
|
/// from Thread::new
|
|
macro_rules! expected_initial_state {
|
|
() => { expected_initial_state!(DEFAULT_THREAD_NAME) };
|
|
($a:expr) => { {
|
|
let mut x = Thread::new($a);
|
|
x.name = $a.to_string();
|
|
x.process = Option::None;
|
|
x.thread_context = ThreadContext {
|
|
int_registers: [0; NUM_INT_REGS],
|
|
float_registers: [0f32; NUM_FP_REGS],
|
|
pc: 0
|
|
};
|
|
x.stack_pointer = 0;
|
|
x }
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_macro() {
|
|
let t = get_new_thread!("hello");
|
|
assert_eq!(t.get_name(), "hello");
|
|
let t = get_new_thread!(1);
|
|
assert_eq!(t.get_name(), "1");
|
|
}
|
|
|
|
#[test]
|
|
fn check_init() {
|
|
let t = get_new_thread!();
|
|
let expected_state = expected_initial_state!();
|
|
assert_eq!(t, expected_state)
|
|
}
|
|
|
|
} |