Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • weber/simcore-rs
  • markeffl/simcore-rs
2 results
Show changes
Commits on Source (35)
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 959 additions and 795 deletions
.gitignore
View file @ 11e245f4
/target
/.idea/
/uml/
/odemx-lite/related documents/
Cargo.lock
View file @ 11e245f4
This diff is collapsed.
Cargo.toml
View file @ 11e245f4
[package]
name = "simcore-rs"
version = "0.1.0"
authors = ["Dorian Weber <weber@informatik.hu-berlin.de>"]
edition = "2018"
authors = [
"Dorian Weber <weber@informatik.hu-berlin.de>",
]
edition = "2024"
[dev-dependencies]
rand = { version = "0.9", default-features = false, features = ["small_rng"] }
rand_distr = "0.5"
rayon = "1.10"
[profile.release]
lto = true
lto = "thin"
debug = "full"
opt-level = 3
[dependencies]
rand = { version = "0.7", default-features = false, features = ["small_rng"] }
[dev-dependencies]
criterion = "0.3.3"
[[bench]]
name = "barbershop"
harness = false
[profile.bench]
lto = true
debug = false
LICENSE 0 → 100644
View file @ 11e245f4
Copyright 2024 Dorian Weber
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the “Software”), to deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
README.md
View file @ 11e245f4
# Process-Based Simulation with Stackless Coroutines
## Overview
This repository contains the source code for the simulator core discussed in our SAM 2020 paper.
In order to run the examples, you should install the [Rust-compiler] first.
The `src/` directory contains the source code for our simulator core *simcore-rs* as well as the decompressor-tokenizer-
and the barbershop-example from the paper. The folder `benches/` contains the code used for benchmarking the barbershop-
example. In `slx/` one can find the SLX-code for the barbershop-example, including benchmarking provisions.
The `results/` directory contains our benchmarking results for the barbershop-example in Rust and SLX.
Unfortunately, we are unable to provide a link to the SLX-compiler at this time. Please contact us if you wish to
execute the barbershop-example in SLX as well.
## Executing the Sample Code
You may execute the decompressor-tokenizer example using `cargo run --bin coroutines` and the barbershop example
using `cargo run --bin barbershop`. For the benchmarks of the simulator core in case of the barbershop example you may
enter `cargo bench` into your terminal. Cargo will download and compile all the dependencies for you.
Should you wish to execute the SLX code as well, you will need to obtain a version of SLX first. The free student
version is sufficient to run the benchmarks with a sample size of 1 for a quick comparison between SLX and Rust, but in
order to get statistically relevant results, you need to own a license for the full version of SLX.
## Benchmarks
We executed the benchmarks under Windows 10 on an Intel Core i7-10750H processor with 6 cores and 32 GB DDR4 RAM.
You can find the results under `results/barbershop.lis` for SLX and `results/barbershop/report/index.html` for Rust.
In a nutshell: we see a speed difference between the SLX- and the Rust-version of the barbershop example of about 3 in
favor of SLX. We have summarized the results in the following table for your convenience:
| Model Time | SLX Mean | SLX SD | Rust Mean | Rust SD |
|:----------:|---------:|---------:|----------:|---------:|
| 100000 | 0.514 ms | 0.052 ms | 1.446 ms | 0.039 ms |
| 200000 | 1.034 ms | 0.069 ms | 2.882 ms | 0.046 ms |
| 300000 | 1.552 ms | 0.073 ms | 4.389 ms | 0.064 ms |
| 400000 | 2.069 ms | 0.089 ms | 5.754 ms | 0.051 ms |
| 500000 | 2.592 ms | 0.116 ms | 7.188 ms | 0.054 ms |
| 600000 | 3.106 ms | 0.121 ms | 8.904 ms | 0.117 ms |
| 700000 | 3.618 ms | 0.127 ms | 10.232 ms | 0.078 ms |
| 800000 | 4.136 ms | 0.150 ms | 11.587 ms | 0.230 ms |
# A Minimalistic Simulation Framework in Rust
## Introduction
This Rust project provides a minimally-viable library for creating and running simulations using asynchronous processes. By leveraging Rust's concurrency features, it allows you to simulate various scenarios, making it a valuable tool for studying the mechanics of simulation libraries in projects involving complex, process-based models.
This simulation core is not meant to be used in production code, see [odem-rs] for an earnest attempt.
## Features
The project includes:
- **Core Library (`lib.rs`)**: Defines reusable components for building simulators.
- **Utility Modules (`util.rs`)**: Provides support for common simulation tasks.
- **Example Models**: Demonstrates different aspects of the framework through three examples:
- `barbershop`
- `ferry`
- `philosophers`
- **Decompressor-Tokenizer (`bin/coroutines.rs`)**: An educational example with an executor, a corresponding spawner, and a channel that shows the mechanism without using unsafe code.
- **Decompressor-Tokenizer (`c/coroutines.c`)**: The same example implemented manually in C to illustrate the transformation performed by the Rust compiler on `async`/`await`.
## Getting Started
### Prerequisites
- **Rust Compiler**: Latest stable version is recommended. [Install Rust][Rust-compiler]
- no other dependencies
### Building the Project
To build the project, run:
```sh
cargo build
```
### Running the Examples
The examples are located in the `examples` directory and demonstrate different types of simulations:
- **Barbershop**: A discrete event simulation of a barbershop where customers arrive randomly, wait if the barber is busy, receive service, and depart. It tracks customer wait times and provides statistical analysis over the simulated period. This is a minimalistic model containing processes and time- and state-based synchronization.
- **Ferry**: Simulates a car-ferry system where cars arrive at multiple harbors and wait to be transported by ferries to other harbors. It tracks statistics like car wait times, ferry cargo lengths, and ferry load times. This example demonstrates complex synchronization, featuring channels and speculative execution.
- **Philosophers**: Simulates the classic Dining Philosophers problem, where philosophers alternate between thinking and eating, requiring coordination to avoid deadlocks. It tracks the time until a deadlock occurs and collects statistical data over multiple simulation runs. This example highlights parallel execution of multiple simulations and concurrent resource access.
To run an example, use:
```sh
cargo run --example <example_name>
```
For example, to run the barbershop simulation:
```sh
cargo run --example barbershop
```
## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
## Acknowledgments
Special thanks to the contributors of the Rust community for creating powerful tools that make projects like this
possible. Extra-special thanks to Lukas Markeffsky for helping me to refine this library both through fruitful
discussions and by resolving its soundness problems through a refactoring of the code.
[Rust-compiler]: https://rust.sh
[odem-rs]: https://crates.io/crates/odem-rs
benches/barbershop.rs deleted 100644 → 0
View file @ e4e01a0c
use simcore_rs::{Time, SimContext, Facility, simulation, Process};
use rand::{distributions::Uniform, rngs::SmallRng, SeedableRng, Rng};
use criterion::{Criterion, BenchmarkId, criterion_group, criterion_main, BatchSize};
use std::time::Duration;
use std::rc::Rc;
const SEED_A : u64 = 100000;
const SEED_S : u64 = 200000;
const RANGE : u32 = 8;
const STEP : Time = 100000.0;
fn barbershop(c: &mut Criterion) {
let mut group = c.benchmark_group("Barbershop");
let mut rng_a = SmallRng::seed_from_u64(SEED_A);
let mut rng_s = SmallRng::seed_from_u64(SEED_S);
group.measurement_time(Duration::from_secs_f64(60.0));
group.confidence_level(0.99);
for stop_time in (1..=RANGE).map(|c| Time::from(c)*STEP) {
group.bench_with_input(
BenchmarkId::from_parameter(stop_time),
&stop_time,
|b, &stop_time|
b.iter_batched(
|| BarberShop {
stop_time,
rng_a: SmallRng::from_rng(&mut rng_a).unwrap(),
rng_s: SmallRng::from_rng(&mut rng_s).unwrap(),
joe: Rc::new(Facility::new())
},
|shop| simulation(
|sim| Process::new(shop.actions(sim))
),
BatchSize::SmallInput
)
);
}
group.finish();
}
criterion_group!(benches, barbershop);
criterion_main!(benches);
/* *************************** Barbershop Example *************************** */
/// Barbershop process.
struct BarberShop {
stop_time: Time, rng_a: SmallRng, rng_s: SmallRng, joe: Rc<Facility>
}
impl BarberShop {
async fn actions(self, sim: SimContext<'_>) {
// unpack the barber shop structure for easier access
let Self {
stop_time, mut rng_a, mut rng_s, joe
} = self;
let joe2 = joe.clone();
// activate a process to generate the customers
sim.activate(async move {
let dist = Uniform::new(12.0, 24.0);
loop {
// wait some time before activating the next customer
sim.advance(rng_a.sample(dist)).await;
// generate new customers until the store closes officially
if sim.now() >= stop_time { return; }
// activate the next customer
sim.activate(Customer {
joe: joe.clone(),
rng: SmallRng::from_seed(rng_s.gen())
}.actions(sim));
}
});
// wait until the store closes
sim.advance(self.stop_time).await;
// finish processing the queue (no more customers arrive)
joe2.seize().await;
}
}
/// Customer process with access to the barber and a random number generator.
struct Customer { joe: Rc<Facility>, rng: SmallRng }
impl Customer {
pub async fn actions(mut self, sim: SimContext<'_>) {
// access the barber
self.joe.seize().await;
// spend time
sim.advance(self.rng.gen_range(12.0, 18.0)).await;
// release the barber
self.joe.release();
}
}
c/Makefile 0 → 100644
View file @ 11e245f4
#!/usr/bin/make
.SUFFIXES:
.PHONY: all run clean
TAR = coroutines
SRC = $(wildcard *.c)
OBJ = $(SRC:%.c=%.o)
DEP = $(OBJ:%.o=%.d)
-include $(DEP)
CFLAGS = -std=c11 -Wall -pedantic -MMD -MP
%.o: %.c
$(CC) $(CFLAGS) $< -c
$(TAR): $(OBJ)
$(CC) $(CFLAGS) $^ -o $@
all: $(TAR)
run: all
./$(TAR)
clean:
$(RM) $(RMFILES) $(TAR) $(OBJ) $(DEP)
c/coroutines.c 0 → 100644
View file @ 11e245f4
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
/* Define either of them to enable the corresponding rewritten forms of the
* routines or both to have both of them rewritten. */
#define DECOMPRESS_COROUTINE
// #define TOKENIZE_COROUTINE
/* Helper macro to simplify tracing of the function calls and messages. */
#define TRACE(...) do { \
fprintf(stderr, __VA_ARGS__); \
putc('\n', stderr); \
} while (0)
/* Helper macro to catch array overflows for extreme inputs. */
#define CATCH_OVERFLOW(ARR, LEN) do { \
if ((LEN) >= sizeof(ARR)/sizeof(*ARR)) { \
fprintf(stderr, "PANIC: Array " #ARR " overflow detected, abort\n"); \
exit(-1); \
} \
} while (0)
/* Enumeration of possible token tags. */
enum Tag { WORD, PUNCT };
/* Names of the token tags. */
static const char *TOKEN_TAG[] = {
[WORD] = "Word", [PUNCT] = "Punct"
};
/* Token type with tag and value. */
typedef struct {
enum Tag tag;
char val[256];
size_t len;
} Token;
/* Primitive token channel for buffering multiple detected tokens. */
static struct {
Token token[256];
size_t len;
} token_chan;
/* Function that adds another character to the token value. */
void add_to_token(char c) {
Token *token = &token_chan.token[token_chan.len];
CATCH_OVERFLOW(token->val, token->len);
token->val[token->len++] = c;
}
/* Function that adds the corresponding tag and closes token construction. */
void got_token(enum Tag tag) {
CATCH_OVERFLOW(token_chan.token, token_chan.len);
Token *token = &token_chan.token[token_chan.len];
token->val[token->len] = '\0';
token->tag = tag;
TRACE("got_token(%s) = \"%s\"", TOKEN_TAG[tag], token->val);
++token_chan.len;
}
/* Stackless coroutine-version of the decompress-routine. */
int co_decompress(void) {
static int pc, l, c;
switch (pc) {
case 0: while (1) {
c = getchar();
if (c == EOF)
return EOF;
if (c == 0xFF) {
l = getchar();
c = getchar();
while (l--) {
TRACE("nextchar() = '%c'", c);
pc = 1;
return c;
case 1:;
}
} else {
TRACE("nextchar() = '%c'", c);
pc = 2;
return c;
case 2:;
}
}}
}
/* Stackless coroutine-version of the tokenize-routine. */
void co_tokenize(int c) {
static int pc = 1;
switch (pc) {
case 0: while (1) {
pc = 1;
return;
case 1:;
TRACE("emit('%c')", c);
if (c == EOF)
return;
if (isalpha(c)) {
do {
add_to_token(c);
pc = 2;
return;
case 2:;
TRACE("emit('%c')", c);
} while (isalpha(c));
got_token(WORD);
}
add_to_token(c);
got_token(PUNCT);
}}
}
/* Decodes RLE-encoded input and pushes it into the tokenizer coroutine. */
void decompress(void) {
while (1) {
int c = getchar();
if (c == EOF)
break;
if (c == 0xFF) {
int l = getchar();
c = getchar();
while (l--) {
co_tokenize(c);
}
} else
co_tokenize(c);
}
co_tokenize(EOF);
}
/* Calls the decompressor-coroutine for decoding RLE-encoded input and
* constructs token. */
void tokenize(void) {
while (1) {
int c = co_decompress();
if (c == EOF)
break;
if (isalpha(c)) {
do {
add_to_token(c);
c = co_decompress();
} while (isalpha(c));
got_token(WORD);
}
add_to_token(c);
got_token(PUNCT);
}
}
/* Prints all token currently present in the token channel. */
void printToken(void) {
for (size_t i = 0; i < token_chan.len; ++i) {
Token *token = &token_chan.token[i];
TRACE(
"Token: {\n"
"\ttag: %s,\n"
"\tval: \"%s\"\n"
"}",
TOKEN_TAG[token->tag],
token->val
);
token->len = 0;
}
token_chan.len = 0;
}
/* Program entry. */
int main() {
#if defined(TOKENIZE_COROUTINE) && defined(DECOMPRESS_COROUTINE)
fprintf(stderr, "Decompress Coroutine, Tokenize Coroutine\n");
for (int c; (c = co_decompress()) != EOF;) {
co_tokenize(c);
printToken();
}
#elif defined(TOKENIZE_COROUTINE)
fprintf(stderr, "Tokenize Routine, Decompress Coroutine\n");
tokenize();
#elif defined(DECOMPRESS_COROUTINE)
fprintf(stderr, "Decompress Routine, Tokenize Coroutine\n");
decompress();
#else
#error "At least one (or both) of TOKENIZE_COROUTINE or DECOMPRESS_COROUTINE should be defined."
#endif
return 0;
}
examples/barbershop.rs 0 → 100644
View file @ 11e245f4
//! A discrete event simulation of a barbershop using `simcore_rs`, the
//! simulator core developed as part of my (Dorian Weber) dissertation.
//!
//! This module models a simple barbershop scenario where customers arrive at
//! random intervals, wait if the barber is busy, receive service, and then
//! depart. The simulation tracks customer wait times and provides statistical
//! analysis over the simulated period.
//!
//! # Notes
//! - The simulation assumes a continuous operation of the barbershop over the
//! specified duration.
//! - Customers arriving after the shop closes are not admitted; however, the
//! barber will finish servicing any remaining customers.
use rand::{rngs::SmallRng, Rng};
use simcore_rs::{
util::{Facility, RandomVariable},
Process, Sim, Time,
};
use std::cell::RefCell;
// Helper constants for random number generator seeds.
const SEED_A: u64 = 100_000;
const SEED_S: u64 = 200_000;
/// Globally shared data for the barbershop simulation.
struct Barbershop {
/// Random number generator for customer arrival times.
rng_a: RefCell<SmallRng>,
/// Random number generator for service times.
rng_s: RefCell<SmallRng>,
/// Facility representing the barber (Joe).
joe: Facility,
/// Statistical accumulator for customer wait times.
wait_time: RandomVariable,
}
/// Represents a customer in the barbershop simulation.
struct Customer;
impl Customer {
/// Defines the actions performed by a customer in the simulation.
///
/// The customer arrives at the barbershop, waits for the barber to be
/// available, gets a haircut (spends time being serviced), and then leaves.
pub async fn actions(self, sim: Sim<'_, Barbershop>) {
// Record the arrival time for wait time calculation.
let arrival_time = sim.now();
// Seize the barber (wait if not available).
sim.global().joe.seize().await;
// Calculate and record the customer's wait time.
sim.global().wait_time.tabulate(sim.now() - arrival_time);
// Simulate the time taken for the haircut.
let cut = sim.global().rng_s.borrow_mut().random_range(12.0..18.0);
sim.advance(cut).await;
// Release the barber for the next customer.
sim.global().joe.release();
}
}
/// The main simulation function.
///
/// This function initializes the customer arrival process, runs the simulation
/// for the specified duration, and ensures that all customers are serviced
/// before the simulation ends.
async fn sim_main(sim: Sim<'_, Barbershop>, duration: Time) {
// Activate a process to generate customers at random intervals.
sim.activate(async move {
loop {
// Wait for a random time before the next customer arrives.
let wait_time = sim.global().rng_a.borrow_mut().random_range(12.0..24.0);
sim.advance(wait_time).await;
// If the simulation time exceeds the duration, stop generating customers.
if sim.now() >= duration {
return;
}
// Activate a new customer process.
sim.activate(Customer.actions(sim));
}
});
// Run the simulation until the store closes.
sim.advance(duration).await;
// Ensure the barber finishes servicing any remaining customers.
sim.global().joe.seize().await;
}
/// Entry point for the barbershop simulation.
///
/// Initializes the simulation environment and runs the simulation for a
/// specified duration.
fn main() {
use rand::SeedableRng;
// Run the simulation and collect the result.
let result = simcore_rs::simulation(
// Initialize the global data for the simulation.
Barbershop {
rng_a: RefCell::new(SmallRng::seed_from_u64(SEED_A)),
rng_s: RefCell::new(SmallRng::seed_from_u64(SEED_S)),
joe: Facility::new(),
wait_time: RandomVariable::new(),
},
// Simulation entry point.
|sim| Process::new(sim, sim_main(sim, 3.0 * 7.0 * 24.0 * 60.0)),
);
// Print statistics after the simulation ends.
println!("wait_time: {:#.3?}", result.wait_time);
}
examples/ferry.rs 0 → 100644
View file @ 11e245f4
//! A discrete event simulation of a car-ferry system using `simcore_rs`, the
//! simulator core developed as part of my (Dorian Weber) dissertation.
//!
//! This module models a ferry system where cars arrive at multiple harbors and
//! wait to be transported by ferries to other harbors. The simulation tracks
//! various statistics such as car wait times, ferry cargo lengths, and ferry
//! load times over the simulated period.
//!
//! # Notes
//!
//! - The simulation assumes continuous operation over the specified duration.
//! - Cars that are not picked up by the end of the simulation are accounted for
//! in the wait time statistics.
//! - The ferry routes are set up in such a way that each ferry starts at a
//! different harbor and cycles through all harbors.
use rand::{rngs::SmallRng, Rng, SeedableRng};
use rand_distr::{Distribution, Exp, Normal};
use simcore_rs::{
util::{channel, select, RandomVariable, Receiver, Sender},
Process, Sim, Time,
};
use std::cell::RefCell;
// Constants for simulation parameters.
const SEED: u64 = 100_000;
const FERRY_COUNT: usize = 2;
const HARBOR_COUNT: usize = 4;
const HARBOR_DISTANCE: Time = 10.0;
const FERRY_TIMEOUT: Time = 5.0;
const FERRY_CAPACITY: usize = 5;
/// Shared global data for the ferry simulation.
struct Ferries {
/// Master random number generator for seeding.
master_rng: RefCell<SmallRng>,
/// Statistical accumulator for ferry cargo lengths.
ferry_cargo_len: RandomVariable,
/// Statistical accumulator for ferry load times.
ferry_load_time: RandomVariable,
/// Statistical accumulator for car wait times.
car_wait_time: RandomVariable,
}
/// Represents a car in the simulation.
#[derive(Debug)]
struct Car {
/// Time when the car arrives at the pier.
arrival_time: Time,
/// Duration required to load the car onto the ferry.
load_duration: Time,
}
/// Represents a pier (harbor) where cars arrive and wait for ferries.
struct Pier {
/// Random number generator specific to this pier.
rng: SmallRng,
/// Channel to send cars to the ferry.
landing_site: Sender<Car>,
}
/// Represents a ferry that transports cars between harbors.
struct Ferry {
/// Cargo hold containing the cars on the ferry.
cargo: Vec<Car>,
/// Timeout duration for ferry departure.
timeout: Time,
/// Time taken to travel between harbors.
travel_time: Time,
/// Receivers from piers to accept arriving cars.
piers: Vec<Receiver<Car>>,
}
impl Pier {
/// Simulates the actions of a pier in the simulation.
///
/// Cars arrive at the pier following an exponential distribution
/// and are sent to the ferry when it arrives.
async fn actions(mut self, sim: Sim<'_, Ferries>) {
// Arrival and loading time distributions.
let arrival_delay = Exp::new(0.1).unwrap();
let loading_delay = Normal::new(0.5, 0.2).unwrap();
loop {
// Wait for the next car to arrive.
sim.advance(arrival_delay.sample(&mut self.rng)).await;
// Create a new car with arrival and load times.
self.landing_site
.send(Car {
arrival_time: sim.now(),
load_duration: loading_delay
.sample_iter(&mut self.rng)
.find(|&val| val >= 0.0)
.unwrap(),
})
.await
.expect("No ferries in the simulation");
}
}
}
impl Ferry {
/// Simulates the actions of a ferry in the simulation.
///
/// The ferry travels between harbors, loads cars, waits for a timeout or
/// until it reaches capacity, and then moves to the next harbor.
async fn actions(mut self, sim: Sim<'_, Ferries>) {
loop {
for pier in self.piers.iter() {
// Unload the cars at the current pier.
for car in self.cargo.drain(..) {
sim.advance(car.load_duration).await;
}
let begin_loading = sim.now();
// Load cars until capacity is reached or timeout occurs.
while self.cargo.len() < self.cargo.capacity() {
match select(sim, pier.recv(), async {
sim.advance(self.timeout).await;
None
})
.await
{
// A car arrived before timeout.
Some(car) => {
sim.global()
.car_wait_time
.tabulate(sim.now() - car.arrival_time);
sim.advance(car.load_duration).await;
self.cargo.push(car);
}
// Timeout occurred; depart to next harbor.
None => break,
}
}
// Record ferry loading statistics.
sim.global()
.ferry_load_time
.tabulate(sim.now() - begin_loading);
sim.global()
.ferry_cargo_len
.tabulate(self.cargo.len() as f64);
// Travel to the next harbor.
sim.advance(self.travel_time).await;
}
}
}
}
/// The main simulation function.
///
/// Sets up the piers and ferries, activates their processes, and runs the simulation
/// for the specified duration.
async fn sim_main(sim: Sim<'_, Ferries>, duration: Time, ferries: usize, harbors: usize) {
let mut ports = Vec::with_capacity(harbors);
// Create all the harbors (piers).
for _ in 0..harbors {
let (sx, rx) = channel();
let harbor = Pier {
rng: SmallRng::from_seed(sim.global().master_rng.borrow_mut().random()),
landing_site: sx,
};
sim.activate(harbor.actions(sim));
ports.push(rx);
}
// Create all the ferries.
for i in 0..ferries {
let ferry = Ferry {
cargo: Vec::with_capacity(FERRY_CAPACITY),
timeout: FERRY_TIMEOUT,
travel_time: HARBOR_DISTANCE,
piers: ports
.iter()
.skip(i)
.chain(ports.iter().take(i))
.cloned()
.collect(),
};
sim.activate(ferry.actions(sim));
}
// Run the simulation for the specified duration.
sim.advance(duration).await;
// Handle any cars that weren't picked up by a ferry.
for port in ports {
for _ in 0..port.len() {
let car = port.recv().await.unwrap();
sim.global()
.car_wait_time
.tabulate(sim.now() - car.arrival_time);
}
}
}
/// Entry point for the ferry simulation.
///
/// Initializes the simulation environment and runs the simulation for one week.
fn main() {
let result = simcore_rs::simulation(
// Global shared data.
Ferries {
master_rng: RefCell::new(SmallRng::seed_from_u64(SEED)),
ferry_cargo_len: RandomVariable::new(),
ferry_load_time: RandomVariable::new(),
car_wait_time: RandomVariable::new(),
},
// Simulation entry point.
|sim| {
Process::new(
sim,
sim_main(sim, 24.0 * 60.0 * 365.0, FERRY_COUNT, HARBOR_COUNT),
)
},
);
// Output simulation statistics.
println!("Number of harbors: {}", HARBOR_COUNT);
println!("Number of ferries: {}", FERRY_COUNT);
println!("Car wait time: {:#.3?}", result.car_wait_time);
println!("Ferry cargo len: {:#.3?}", result.ferry_cargo_len);
println!("Ferry load time: {:#.3?}", result.ferry_load_time);
}
examples/philosophers.rs 0 → 100644
View file @ 11e245f4
//! A discrete event simulation of the Dining Philosophers problem using
//! `simcore_rs`, the simulator core developed as part of my (Dorian Weber)
//! dissertation.
//!
//! This module models the classic Dining Philosophers problem, where multiple
//! philosophers sit around a table and alternate between thinking and eating.
//! They need two forks to eat and must coordinate to avoid deadlocks. The
//! simulation tracks the time until a deadlock occurs and collects statistical
//! data over multiple runs.
//!
//! # Notes
//!
//! - The simulation detects deadlocks when all philosophers are waiting for
//! forks and none can proceed.
//! - The statistical data collected includes the time until deadlock over
//! multiple simulation runs.
use rand::{rngs::SmallRng, Rng, SeedableRng};
use rand_distr::{Exp, Normal, Uniform};
use rayon::prelude::*;
use simcore_rs::{
util::{until, Control, RandomVariable},
Process, Sim, Time,
};
use std::{
cell::{Cell, RefCell},
rc::Rc,
};
// Constants for simulation parameters.
const PHILOSOPHER_COUNT: usize = 5;
const SEED: u64 = 100_000;
/// Shared global data for the simulation.
struct Philosophers {
/// Master random number generator for seeding.
master_rng: RefCell<SmallRng>,
/// Cell to store the simulation duration until deadlock.
sim_duration: Cell<Time>,
}
/// Represents the shared table with forks for the philosophers.
struct Table {
/// Controls for each fork, indicating whether it is held.
forks: Vec<Control<bool>>,
/// Counter for the number of forks currently held.
forks_held: Control<usize>,
/// Counter for the number of forks currently awaited.
forks_awaited: Control<usize>,
}
impl Table {
/// Creates a new table with a specified number of forks.
fn new(forks: usize) -> Self {
Table {
forks: (0..forks).map(|_| Control::new(false)).collect(),
forks_held: Control::default(),
forks_awaited: Control::default(),
}
}
/// Acquires a fork at a given position, blocking until it is available.
async fn acquire_fork(&self, i: usize) {
let num = i % self.forks.len();
self.forks_awaited.set(self.forks_awaited.get() + 1);
until(&self.forks[num], |fork| !fork.get()).await;
self.forks[num].set(true);
self.forks_awaited.set(self.forks_awaited.get() - 1);
self.forks_held.set(self.forks_held.get() + 1);
}
/// Releases a fork at a given position back to the table.
fn release_fork(&self, i: usize) {
self.forks[i % self.forks.len()].set(false);
self.forks_held.set(self.forks_held.get() - 1);
}
}
/// Represents a philosopher in the simulation.
struct Philosopher {
/// Reference to the shared table.
table: Rc<Table>,
/// The seat index of the philosopher at the table.
seat: usize,
/// Random number generator for this philosopher.
rng: SmallRng,
}
impl Philosopher {
/// Simulates the actions of a philosopher.
///
/// The philosopher alternates between thinking and eating, and tries to
/// acquire forks.
async fn actions(mut self, sim: Sim<'_, Philosophers>) {
let thinking_duration = Exp::new(1.0).unwrap();
let artificial_delay = Uniform::new(0.1, 0.2).unwrap();
let eating_duration = Normal::new(0.5, 0.2).unwrap();
let rng = &mut self.rng;
loop {
// Spend some time pondering the nature of things.
sim.advance(rng.sample(thinking_duration)).await;
// Acquire the first fork.
self.table.acquire_fork(self.seat).await;
// Introduce an artificial delay to leave room for deadlocks.
sim.advance(rng.sample(artificial_delay)).await;
// Acquire the second fork.
self.table.acquire_fork(self.seat + 1).await;
// Spend some time eating.
sim.advance(
rng.sample_iter(eating_duration).find(|&v| v >= 0.0).unwrap(),
)
.await;
// Release the forks.
self.table.release_fork(self.seat + 1);
self.table.release_fork(self.seat);
}
}
}
/// Runs a single simulation instance of the Dining Philosophers problem.
///
/// Initializes the table and philosophers, and waits until a deadlock occurs.
async fn sim_main(sim: Sim<'_, Philosophers>, count: usize) {
let table = Rc::new(Table::new(count));
// Create the philosopher processes and seat them.
for i in 0..count {
sim.activate(
Philosopher {
table: table.clone(),
seat: i,
rng: SmallRng::from_seed(sim.global().master_rng.borrow_mut().random()),
}
.actions(sim),
);
}
// Wait for the precise configuration indicating a deadlock.
until(
(&table.forks_held, &table.forks_awaited),
|(held, awaited)| held.get() == count && awaited.get() == count,
)
.await;
// Record the current simulation time.
sim.global().sim_duration.set(sim.now());
}
/// Runs multiple simulation instances in parallel and collects statistics.
///
/// # Arguments
///
/// * `count` - The number of philosophers (and forks) in each simulation.
/// * `reruns` - The number of simulation runs to perform.
///
/// # Returns
///
/// A `RandomVar` containing statistical data of simulation durations until
/// deadlock.
fn philosophers(count: usize, reruns: usize) -> RandomVariable {
// Use thread-based parallelism to concurrently run simulation models.
(1..=reruns)
.into_par_iter()
.map(|i| {
simcore_rs::simulation(
// Global data.
Philosophers {
master_rng: RefCell::new(SmallRng::seed_from_u64(i as u64 * SEED)),
sim_duration: Cell::default(),
},
// Simulation entry point.
|sim| Process::new(sim, sim_main(sim, count)),
)
.sim_duration
.get()
})
.fold(RandomVariable::new, |var, duration| {
var.tabulate(duration);
var
})
.reduce(RandomVariable::new, |var_a, var_b| {
var_a.merge(&var_b);
var_a
})
}
/// Entry point for the Dining Philosophers simulation.
///
/// Runs multiple simulations and prints out the statistical results.
fn main() {
const EXPERIMENT_COUNT: usize = 500;
let sim_duration = philosophers(PHILOSOPHER_COUNT, EXPERIMENT_COUNT);
println!("Simulation duration until deadlock: {:#?}", sim_duration);
}
results/barbershop.lis deleted 100644 → 0
View file @ e4e01a0c
barbershop.slx: SLX-64 AN206 Lines: 7,086 Errors: 0 Warnings: 0 Lines/Second: 680,384 Peak Memory: 111 MB
Execution begins
[100000] mean 0.514 ms, stddev 0.052 ms, half-width 0.001 ms
[200000] mean 1.034 ms, stddev 0.069 ms, half-width 0.002 ms
[300000] mean 1.552 ms, stddev 0.073 ms, half-width 0.002 ms
[400000] mean 2.069 ms, stddev 0.089 ms, half-width 0.002 ms
[500000] mean 2.592 ms, stddev 0.116 ms, half-width 0.003 ms
[600000] mean 3.106 ms, stddev 0.121 ms, half-width 0.003 ms
[700000] mean 3.618 ms, stddev 0.127 ms, half-width 0.003 ms
[800000] mean 4.136 ms, stddev 0.150 ms, half-width 0.004 ms
Execution complete
Objects created: 44 passive and 1,999,959,827 active Pucks created: 2,000,039,828 Peak Memory: 111 MB Time: 3.10 Minutes
results/barbershop/100000/base/benchmark.json deleted 100644 → 0
View file @ e4e01a0c
{"group_id":"Barbershop","function_id":null,"value_str":"100000","throughput":null,"full_id":"Barbershop/100000","directory_name":"barbershop/100000","title":"Barbershop/100000"}
\ No newline at end of file
results/barbershop/100000/base/estimates.json deleted 100644 → 0
View file @ e4e01a0c
{"mean":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1437673.8153504157,"upper_bound":1457739.90065053},"point_estimate":1446297.0024249256,"standard_error":3937.0189967761453},"median":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1434354.1666666667,"upper_bound":1440389.705882353},"point_estimate":1436577.9974123058,"standard_error":1531.9600428949157},"median_abs_dev":{"confidence_interval":{"confidence_level":0.99,"lower_bound":7185.896329241905,"upper_bound":16778.632086656973},"point_estimate":11867.187634297417,"standard_error":1942.5462696386846},"slope":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1435637.0842025997,"upper_bound":1444796.192653672},"point_estimate":1439804.5507610464,"standard_error":1771.7022156902058},"std_dev":{"confidence_interval":{"confidence_level":0.99,"lower_bound":17120.720790680873,"upper_bound":59051.723972006665},"point_estimate":39619.83674728129,"standard_error":8415.04789825481}}
\ No newline at end of file
results/barbershop/100000/base/raw.csv deleted 100644 → 0
View file @ e4e01a0c
group,function,value,throughput_num,throughput_type,sample_measured_value,unit,iteration_count
Barbershop,,100000,,,11258300.0,ns,8
Barbershop,,100000,,,23151400.0,ns,16
Barbershop,,100000,,,40156200.0,ns,24
Barbershop,,100000,,,45149100.0,ns,32
Barbershop,,100000,,,60543800.0,ns,40
Barbershop,,100000,,,71699100.0,ns,48
Barbershop,,100000,,,80908600.0,ns,56
Barbershop,,100000,,,91111400.0,ns,64
Barbershop,,100000,,,101436500.0,ns,72
Barbershop,,100000,,,115971500.0,ns,80
Barbershop,,100000,,,129275200.0,ns,88
Barbershop,,100000,,,156750700.0,ns,96
Barbershop,,100000,,,152675000.0,ns,104
Barbershop,,100000,,,159118900.0,ns,112
Barbershop,,100000,,,172122500.0,ns,120
Barbershop,,100000,,,181849500.0,ns,128
Barbershop,,100000,,,194189300.0,ns,136
Barbershop,,100000,,,214791000.0,ns,144
Barbershop,,100000,,,219014100.0,ns,152
Barbershop,,100000,,,230268100.0,ns,160
Barbershop,,100000,,,236874700.0,ns,168
Barbershop,,100000,,,251145100.0,ns,176
Barbershop,,100000,,,265018500.0,ns,184
Barbershop,,100000,,,276687500.0,ns,192
Barbershop,,100000,,,283880800.0,ns,200
Barbershop,,100000,,,330524200.0,ns,208
Barbershop,,100000,,,335799500.0,ns,216
Barbershop,,100000,,,322610900.0,ns,224
Barbershop,,100000,,,334612300.0,ns,232
Barbershop,,100000,,,343695900.0,ns,240
Barbershop,,100000,,,352043900.0,ns,248
Barbershop,,100000,,,368207000.0,ns,256
Barbershop,,100000,,,378854900.0,ns,264
Barbershop,,100000,,,386805900.0,ns,272
Barbershop,,100000,,,403057700.0,ns,280
Barbershop,,100000,,,414145400.0,ns,288
Barbershop,,100000,,,425241200.0,ns,296
Barbershop,,100000,,,435164000.0,ns,304
Barbershop,,100000,,,449720100.0,ns,312
Barbershop,,100000,,,464929500.0,ns,320
Barbershop,,100000,,,467967100.0,ns,328
Barbershop,,100000,,,485652600.0,ns,336
Barbershop,,100000,,,489110800.0,ns,344
Barbershop,,100000,,,505077900.0,ns,352
Barbershop,,100000,,,521007300.0,ns,360
Barbershop,,100000,,,530084600.0,ns,368
Barbershop,,100000,,,533162100.0,ns,376
Barbershop,,100000,,,553346000.0,ns,384
Barbershop,,100000,,,568680100.0,ns,392
Barbershop,,100000,,,577911800.0,ns,400
Barbershop,,100000,,,587679000.0,ns,408
Barbershop,,100000,,,594449700.0,ns,416
Barbershop,,100000,,,604859200.0,ns,424
Barbershop,,100000,,,617146600.0,ns,432
Barbershop,,100000,,,652916800.0,ns,440
Barbershop,,100000,,,643365800.0,ns,448
Barbershop,,100000,,,649919000.0,ns,456
Barbershop,,100000,,,671399400.0,ns,464
Barbershop,,100000,,,677201500.0,ns,472
Barbershop,,100000,,,684634300.0,ns,480
Barbershop,,100000,,,697488200.0,ns,488
Barbershop,,100000,,,716516000.0,ns,496
Barbershop,,100000,,,721044200.0,ns,504
Barbershop,,100000,,,731838500.0,ns,512
Barbershop,,100000,,,740138200.0,ns,520
Barbershop,,100000,,,755934800.0,ns,528
Barbershop,,100000,,,769604300.0,ns,536
Barbershop,,100000,,,810699600.0,ns,544
Barbershop,,100000,,,821170400.0,ns,552
Barbershop,,100000,,,823984500.0,ns,560
Barbershop,,100000,,,815695000.0,ns,568
Barbershop,,100000,,,821230400.0,ns,576
Barbershop,,100000,,,837383300.0,ns,584
Barbershop,,100000,,,851223400.0,ns,592
Barbershop,,100000,,,863588200.0,ns,600
Barbershop,,100000,,,876111800.0,ns,608
Barbershop,,100000,,,884431700.0,ns,616
Barbershop,,100000,,,900753300.0,ns,624
Barbershop,,100000,,,906882700.0,ns,632
Barbershop,,100000,,,916174800.0,ns,640
Barbershop,,100000,,,928050500.0,ns,648
Barbershop,,100000,,,941027000.0,ns,656
Barbershop,,100000,,,953379100.0,ns,664
Barbershop,,100000,,,964365900.0,ns,672
Barbershop,,100000,,,978582000.0,ns,680
Barbershop,,100000,,,997588400.0,ns,688
Barbershop,,100000,,,1012511400.0,ns,696
Barbershop,,100000,,,1019418400.0,ns,704
Barbershop,,100000,,,1032338000.0,ns,712
Barbershop,,100000,,,1055256400.0,ns,720
Barbershop,,100000,,,1048397500.0,ns,728
Barbershop,,100000,,,1055206300.0,ns,736
Barbershop,,100000,,,1071154100.0,ns,744
Barbershop,,100000,,,1080270800.0,ns,752
Barbershop,,100000,,,1095260000.0,ns,760
Barbershop,,100000,,,1097986500.0,ns,768
Barbershop,,100000,,,1105461000.0,ns,776
Barbershop,,100000,,,1115698800.0,ns,784
Barbershop,,100000,,,1134741200.0,ns,792
Barbershop,,100000,,,1145929400.0,ns,800
results/barbershop/100000/base/sample.json deleted 100644 → 0
View file @ e4e01a0c
{"sampling_mode":"Linear","iters":[8.0,16.0,24.0,32.0,40.0,48.0,56.0,64.0,72.0,80.0,88.0,96.0,104.0,112.0,120.0,128.0,136.0,144.0,152.0,160.0,168.0,176.0,184.0,192.0,200.0,208.0,216.0,224.0,232.0,240.0,248.0,256.0,264.0,272.0,280.0,288.0,296.0,304.0,312.0,320.0,328.0,336.0,344.0,352.0,360.0,368.0,376.0,384.0,392.0,400.0,408.0,416.0,424.0,432.0,440.0,448.0,456.0,464.0,472.0,480.0,488.0,496.0,504.0,512.0,520.0,528.0,536.0,544.0,552.0,560.0,568.0,576.0,584.0,592.0,600.0,608.0,616.0,624.0,632.0,640.0,648.0,656.0,664.0,672.0,680.0,688.0,696.0,704.0,712.0,720.0,728.0,736.0,744.0,752.0,760.0,768.0,776.0,784.0,792.0,800.0],"times":[11258300.0,23151400.0,40156200.0,45149100.0,60543800.0,71699100.0,80908600.0,91111400.0,101436500.0,115971500.0,129275200.0,156750700.0,152675000.0,159118900.0,172122500.0,181849500.0,194189300.0,214791000.0,219014100.0,230268100.0,236874700.0,251145100.0,265018500.0,276687500.0,283880800.0,330524200.0,335799500.0,322610900.0,334612300.0,343695900.0,352043900.0,368207000.0,378854900.0,386805900.0,403057700.0,414145400.0,425241200.0,435164000.0,449720100.0,464929500.0,467967100.0,485652600.0,489110800.0,505077900.0,521007300.0,530084600.0,533162100.0,553346000.0,568680100.0,577911800.0,587679000.0,594449700.0,604859200.0,617146600.0,652916800.0,643365800.0,649919000.0,671399400.0,677201500.0,684634300.0,697488200.0,716516000.0,721044200.0,731838500.0,740138200.0,755934800.0,769604300.0,810699600.0,821170400.0,823984500.0,815695000.0,821230400.0,837383300.0,851223400.0,863588200.0,876111800.0,884431700.0,900753300.0,906882700.0,916174800.0,928050500.0,941027000.0,953379100.0,964365900.0,978582000.0,997588400.0,1012511400.0,1019418400.0,1032338000.0,1055256400.0,1048397500.0,1055206300.0,1071154100.0,1080270800.0,1095260000.0,1097986500.0,1105461000.0,1115698800.0,1134741200.0,1145929400.0]}
\ No newline at end of file
results/barbershop/100000/base/tukey.json deleted 100644 → 0
View file @ e4e01a0c
[1382557.362869584,1405953.0950970615,1468341.7143703348,1491737.4465978122]
\ No newline at end of file
results/barbershop/100000/change/estimates.json deleted 100644 → 0
View file @ e4e01a0c
{"mean":{"confidence_interval":{"confidence_level":0.99,"lower_bound":-0.026656087951228594,"upper_bound":-0.012351824951377698},"point_estimate":-0.0196823801740047,"standard_error":0.002867583888859883},"median":{"confidence_interval":{"confidence_level":0.99,"lower_bound":-0.028796524055541284,"upper_bound":-0.019401893555118788},"point_estimate":-0.023139155847256565,"standard_error":0.0018353663800739035}}
\ No newline at end of file
results/barbershop/100000/new/benchmark.json deleted 100644 → 0
View file @ e4e01a0c
{"group_id":"Barbershop","function_id":null,"value_str":"100000","throughput":null,"full_id":"Barbershop/100000","directory_name":"barbershop/100000","title":"Barbershop/100000"}
\ No newline at end of file
results/barbershop/100000/new/estimates.json deleted 100644 → 0
View file @ e4e01a0c
{"mean":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1437673.8153504157,"upper_bound":1457739.90065053},"point_estimate":1446297.0024249256,"standard_error":3937.0189967761453},"median":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1434354.1666666667,"upper_bound":1440389.705882353},"point_estimate":1436577.9974123058,"standard_error":1531.9600428949157},"median_abs_dev":{"confidence_interval":{"confidence_level":0.99,"lower_bound":7185.896329241905,"upper_bound":16778.632086656973},"point_estimate":11867.187634297417,"standard_error":1942.5462696386846},"slope":{"confidence_interval":{"confidence_level":0.99,"lower_bound":1435637.0842025997,"upper_bound":1444796.192653672},"point_estimate":1439804.5507610464,"standard_error":1771.7022156902058},"std_dev":{"confidence_interval":{"confidence_level":0.99,"lower_bound":17120.720790680873,"upper_bound":59051.723972006665},"point_estimate":39619.83674728129,"standard_error":8415.04789825481}}
\ No newline at end of file