mohr/nexosim
1
0
Fork 0
forked from ROMEO/nexosim
Code Pull Requests Activity

Return both simulation and scheduler at init

Browse Source
This commit is contained in:
Serge Barral
2024-11-15 16:52:24 +01:00
parent f4686af49a
commit 0f1d876aed
20 changed files with 101 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
asynchronix/tests/integration/model_scheduling.rs
View File

@ -36,7 +36,8 @@ fn model_schedule_event(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
.unwrap()
.0;
simu.process_event(TestModel::trigger, (), addr).unwrap();
simu.step().unwrap();
@ -82,7 +83,8 @@ fn model_cancel_future_keyed_event(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
.unwrap()
.0;
simu.process_event(TestModel::trigger, (), addr).unwrap();
simu.step().unwrap();
@ -129,7 +131,8 @@ fn model_cancel_same_time_keyed_event(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
.unwrap()
.0;
simu.process_event(TestModel::trigger, (), addr).unwrap();
simu.step().unwrap();
@ -172,7 +175,8 @@ fn model_schedule_periodic_event(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
.unwrap()
.0;
simu.process_event(TestModel::trigger, (), addr).unwrap();
@ -224,7 +228,8 @@ fn model_cancel_periodic_event(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
.unwrap()
.0;
simu.process_event(TestModel::trigger, (), addr).unwrap();

3
asynchronix/tests/integration/simulation_clock_sync.rs
View File

@ -39,14 +39,13 @@ fn clock_sync(
let addr = mbox.address();
let t0 = MonotonicTime::EPOCH;
let mut simu = SimInit::with_num_threads(num_threads)
let (mut simu, scheduler) = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "test")
.set_clock(clock)
.set_clock_tolerance(clock_tolerance)
.init(t0)
.unwrap();
let scheduler = simu.scheduler();
let mut delta = Duration::ZERO;
for tick_ms in ticks_ms {
let tick = Duration::from_millis(*tick_ms);

12
asynchronix/tests/integration/simulation_deadlock.rs
View File

@ -45,7 +45,8 @@ fn deadlock_on_mailbox_overflow(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, MODEL_NAME)
.init(t0)
.unwrap();
.unwrap()
.0;
match simu.process_event(TestModel::activate_output, (), addr) {
Err(ExecutionError::Deadlock(deadlock_info)) => {
@ -80,7 +81,8 @@ fn deadlock_on_query_loopback(num_threads: usize) {
let mut simu = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, MODEL_NAME)
.init(t0)
.unwrap();
.unwrap()
.0;
match simu.process_query(TestModel::activate_requestor, (), addr) {
Err(ExecutionError::Deadlock(deadlock_info)) => {
@ -124,7 +126,8 @@ fn deadlock_on_transitive_query_loopback(num_threads: usize) {
.add_model(model1, mbox1, MODEL1_NAME)
.add_model(model2, mbox2, MODEL2_NAME)
.init(t0)
.unwrap();
.unwrap()
.0;
match simu.process_query(TestModel::activate_requestor, (), addr1) {
Err(ExecutionError::Deadlock(deadlock_info)) => {
@ -181,7 +184,8 @@ fn deadlock_on_multiple_query_loopback(num_threads: usize) {
.add_model(model1, mbox1, MODEL1_NAME)
.add_model(model2, mbox2, MODEL2_NAME)
.init(t0)
.unwrap();
.unwrap()
.0;
match simu.process_query(TestModel::activate_requestor, (), addr0) {
Err(ExecutionError::Deadlock(deadlock_info)) => {

2
asynchronix/tests/integration/simulation_panic.rs
View File

@ -48,7 +48,7 @@ fn model_panic(num_threads: usize) {
// Run the simulation.
let t0 = MonotonicTime::EPOCH;
let mut simu = siminit.init(t0).unwrap();
let mut simu = siminit.init(t0).unwrap().0;
match simu.process_event(TestModel::countdown_in, INIT_COUNTDOWN, addr0) {
Err(ExecutionError::Panic { model, payload }) => {

47
asynchronix/tests/integration/simulation_scheduling.rs
View File

@ -6,7 +6,7 @@ use std::time::Duration;
use asynchronix::model::Context;
use asynchronix::model::Model;
use asynchronix::ports::{EventBuffer, Output};
use asynchronix::simulation::{Address, Mailbox, SimInit, Simulation};
use asynchronix::simulation::{Address, Mailbox, Scheduler, SimInit, Simulation};
use asynchronix::time::MonotonicTime;
const MT_NUM_THREADS: usize = 4;
@ -32,7 +32,12 @@ impl<T: Clone + Send + 'static> Model for PassThroughModel<T> {}
fn passthrough_bench<T: Clone + Send + 'static>(
num_threads: usize,
t0: MonotonicTime,
) -> (Simulation, Address<PassThroughModel<T>>, EventBuffer<T>) {
) -> (
Simulation,
Scheduler,
Address<PassThroughModel<T>>,
EventBuffer<T>,
) {
// Bench assembly.
let mut model = PassThroughModel::new();
let mbox = Mailbox::new();
@ -41,19 +46,17 @@ fn passthrough_bench<T: Clone + Send + 'static>(
model.output.connect_sink(&out_stream);
let addr = mbox.address();
let simu = SimInit::with_num_threads(num_threads)
let (simu, scheduler) = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.init(t0)
.unwrap();
(simu, addr, out_stream)
(simu, scheduler, addr, out_stream)
}
fn schedule_events(num_threads: usize) {
let t0 = MonotonicTime::EPOCH;
let (mut simu, addr, mut output) = passthrough_bench(num_threads, t0);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut output) = passthrough_bench(num_threads, t0);
// Queue 2 events at t0+3s and t0+2s, in reverse order.
scheduler
@ -92,9 +95,7 @@ fn schedule_events(num_threads: usize) {
fn schedule_keyed_events(num_threads: usize) {
let t0 = MonotonicTime::EPOCH;
let (mut simu, addr, mut output) = passthrough_bench(num_threads, t0);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut output) = passthrough_bench(num_threads, t0);
let event_t1 = scheduler
.schedule_keyed_event(
@ -133,9 +134,7 @@ fn schedule_keyed_events(num_threads: usize) {
fn schedule_periodic_events(num_threads: usize) {
let t0 = MonotonicTime::EPOCH;
let (mut simu, addr, mut output) = passthrough_bench(num_threads, t0);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut output) = passthrough_bench(num_threads, t0);
// Queue 2 periodic events at t0 + 3s + k*2s.
scheduler
@ -172,9 +171,7 @@ fn schedule_periodic_events(num_threads: usize) {
fn schedule_periodic_keyed_events(num_threads: usize) {
let t0 = MonotonicTime::EPOCH;
let (mut simu, addr, mut output) = passthrough_bench(num_threads, t0);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut output) = passthrough_bench(num_threads, t0);
// Queue 2 periodic events at t0 + 3s + k*2s.
scheduler
@ -292,6 +289,7 @@ fn timestamp_bench(
clock: impl Clock + 'static,
) -> (
Simulation,
Scheduler,
Address<TimestampModel>,
EventBuffer<(Instant, SystemTime)>,
) {
@ -303,13 +301,13 @@ fn timestamp_bench(
model.stamp.connect_sink(&stamp_stream);
let addr = mbox.address();
let simu = SimInit::with_num_threads(num_threads)
let (simu, scheduler) = SimInit::with_num_threads(num_threads)
.add_model(model, mbox, "")
.set_clock(clock)
.init(t0)
.unwrap();
(simu, addr, stamp_stream)
(simu, scheduler, addr, stamp_stream)
}
#[cfg(not(miri))]
@ -335,9 +333,7 @@ fn system_clock_from_instant(num_threads: usize) {
let clock = SystemClock::from_instant(simulation_ref, wall_clock_ref);
let (mut simu, addr, mut stamp) = timestamp_bench(num_threads, t0, clock);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut stamp) = timestamp_bench(num_threads, t0, clock);
// Queue a single event at t0 + 0.1s.
scheduler
@ -391,9 +387,7 @@ fn system_clock_from_system_time(num_threads: usize) {
let clock = SystemClock::from_system_time(simulation_ref, wall_clock_ref);
let (mut simu, addr, mut stamp) = timestamp_bench(num_threads, t0, clock);
let scheduler = simu.scheduler();
let (mut simu, scheduler, addr, mut stamp) = timestamp_bench(num_threads, t0, clock);
// Queue a single event at t0 + 0.1s.
scheduler
@ -435,11 +429,10 @@ fn auto_system_clock(num_threads: usize) {
let t0 = MonotonicTime::EPOCH;
const TOLERANCE: f64 = 0.005; // [s]
let (mut simu, addr, mut stamp) = timestamp_bench(num_threads, t0, AutoSystemClock::new());
let (mut simu, scheduler, addr, mut stamp) =
timestamp_bench(num_threads, t0, AutoSystemClock::new());
let instant_t0 = Instant::now();
let scheduler = simu.scheduler();
// Queue a periodic event at t0 + 0.2s + k*0.2s.
scheduler
.schedule_periodic_event(

6
asynchronix/tests/integration/simulation_timeout.rs
View File

@ -51,7 +51,8 @@ fn timeout_untriggered(num_threads: usize) {
.add_model(model, mbox, "test")
.set_timeout(Duration::from_secs(1))
.init(t0)
.unwrap();
.unwrap()
.0;
assert!(simu.process_event(TestModel::input, (), addr).is_ok());
}
@ -69,7 +70,8 @@ fn timeout_triggered(num_threads: usize) {
.add_model(model, mbox, "test")
.set_timeout(Duration::from_secs(1))
.init(t0)
.unwrap();
.unwrap()
.0;
assert!(matches!(
simu.process_event(TestModel::input, (), addr),