diff --git a/Cargo.toml b/Cargo.toml
index ec5f25f85512c03b1b1db74912c3aeafb769c6d8..cf1838b6f72bd61c265c5eed2d72bda9510d64aa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,13 @@
[package]
name = "simcore-rs"
version = "0.1.0"
-authors = ["Dorian Weber <weber@informatik.hu-berlin.de>"]
+authors = [
+ "Dorian Weber <weber@informatik.hu-berlin.de>",
+ "Paula Wiesner <wiesnerp@informatik.hu-berlin.de>",
+ "Joachim Fischer <fischer@informatik.hu-berlin.de>"
+]
edition = "2018"
-[features]
-default = ["mock"]
-mock = []
-
[profile.release]
lto = true
opt-level = 3
diff --git a/README.md b/README.md
index 8de797198a55d628bfa499443b8c5d323b7e5783..49ef5323766c87f57f28ffe4dcf16b09dc209e81 100644
--- a/README.md
+++ b/README.md
@@ -1,36 +1,32 @@
-# Process-Based Simulation with Stackless Coroutines
+# A Closer Look at Process-Based Simulation with Stackless Coroutines
## Overview
-This repository contains the source code for the simulator core discussed in our IST 2021 paper.
+This repository contains the source code for the simulator core discussed in our IST 2021 paper as well as code needed to run and benchmark the sample scenarios from the paper.
In order to run the examples and benchmarks, you should install the [Rust-compiler], SLX and a C++ compiler first.
-Any C++-14 conforming compiler should work, the ODEMx-library is translated using Rust code that searches for a compiler
-first, so the popular compilers `msvc`, `clang`, `mingw` and `gcc` should all work out of the box.
+Any C++-14 conforming compiler should work, the ODEMx-library is translated using Rust-code that searches for a compiler first, so the popular compilers `msvc`, `clang`, `mingw` and `gcc` should work out of the box.
-Unfortunately, there is no way to get SLX at the moment, as the creator James O. Henriksen passed away in 2020, and the
-company's original website has vanished. We are unsure if it would be legal for us to provide you with the demo
-version in the context of this repository, so we opted against it. Please contact us if you wish to obtain the free
-version of SLX for your own benchmarks.
+Unfortunately, there is no way to get SLX at the moment, as the creator James O. Henriksen passed away in 2020, and the company's original website has vanished.
+We are unsure if it would be legal for us to provide you with the demo version in the context of this repository, so we opted against it.
+Please contact us if you wish to obtain the free version of SLX for your own benchmarks.
-The `src/` directory contains the source code for our simulator core *simcore-rs* as well as the decompressor-tokenizer
-example from the paper. The folder `examples/` contains the *Barbershop*, *Car Ferry* and *Dining Philosopher* examples
-including the code used for the comparative benchmarks. In `slx/` one can find the SLX-code for the same examples,
-also including benchmarking provisions in the form of (real time) measurements. The `cpp/` folder contains three
-sub-projects for the three examples that use ODEMx. The `results/` directory contains the complete report for our
-benchmarking results. Finally, the `odemx-lite/` folder contains a pure version of ODEMx, that is pure in the sense
-that all external dependencies have been stripped, and it only requires a C++-14 conforming compiler to be translated.
+The `src/` directory contains the source code for our simulator core *simcore-rs* as well as the decompressor-tokenizer example from the paper.
+The folder `examples/` contains the *Barbershop*, *Car Ferry* and *Dining Philosopher* examples including the code used to generate the comparative benchmarks.
+In `slx/` one can find the SLX-code for the same examples, also including benchmarking provisions in the form of (real time) measurements.
+The `c/` folder contains the manually transformed version of the decompressor-tokenizer example into coroutines in C as well as a `Makefile` for compilation.
+The `cpp/` folder contains three sub-projects for the three examples that use ODEMx.
+The `results/` directory contains the complete report for our benchmarking results.
+Finally, the `odemx-lite/` folder contains a clean version of ODEMx, that has all external dependencies stripped and only requires a C++-14 conforming compiler to be translated.
## Executing the Sample Code
-You may execute the decompressor-tokenizer example using `cargo run --bin coroutines` and the other examples using
-`cargo run --example <name>` for `<name>` in [*barbershop*, *ferry*, *philosophers*]. For the benchmarks enter
-`cargo bench` into your terminal (or `cargo bench --example <name>` if you wish to run a specific benchmark).
-Cargo will download and compile all the dependencies for you.
+You may execute the decompressor-tokenizer example using `cargo run --bin coroutines` and the other examples using `cargo run --example <name>` for `<name>` in [*barbershop*, *ferry*, *philosophers*].
+For the analogous example in C, change into the `c/` directory and call `make run`. Note that the example reads from `stdin`, so this path requires manual input from the terminal.
+For the benchmarks enter `cargo bench` into your terminal (or `cargo bench --example <name>` if you wish to run a specific benchmark).
+Cargo will download and compile all the dependencies automatically.
-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 but is about 30% slower than the full version of SLX due to its generation
-of 32-bit binaries rather than 64-bit binaries like the full version does.
+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 but is about 30% slower than the full version of SLX due to its generation of 32-bit binaries rather than 64-bit binaries like the full version does.
## Benchmarks
-We executed the benchmarks under Windows 10 on an Intel Core i7-10750H processor with 6 cores (12 with hyper-threading)
-and 32 GB DDR4 RAM with activated link-time optimizations and optimization level 3.
+We executed the benchmarks under Windows 10 on an Intel Core i7-10750H processor with 6 cores (12 with hyper-threading) and 32 GB DDR4 RAM with activated link-time optimizations and optimization level 3.
You can find the results under `results/criterion/report/index.html` for all three simulation systems.
diff --git a/c/decompress-tokenize.c b/c/decompress-tokenize.c
index 4fa51a6d5ad1cb0498c92919aedfd80079e75493..401ac0bd5f5cdfd51d781eac357167c53f65733c 100644
--- a/c/decompress-tokenize.c
+++ b/c/decompress-tokenize.c
@@ -118,9 +118,9 @@ void decompress(void) {
if (c == EOF)
break;
if (c == 0xFF) {
- int len = getchar();
+ int l = getchar();
c = getchar();
- while (len--) {
+ while (l--) {
co_tokenize(c);
}
} else
diff --git a/src/bin/coroutines.rs b/src/bin/coroutines.rs
index be9f88cd280934b2da67203af570144ae59160fc..2204b68ae76bba13505a06ce30c0d612666619c8 100644
--- a/src/bin/coroutines.rs
+++ b/src/bin/coroutines.rs
@@ -1,18 +1,18 @@
use self::Token::*;
use std::rc::Rc;
-async fn decompress(mut input: impl Iterator<Item=u8>,
- output: Sender<char>) {
- while let Some(c) = input.next() {
+async fn decompress<I>(mut inp: I, out: Sender<char>)
+where I: Iterator<Item = u8> {
+ while let Some(c) = inp.next() {
if c == 0xFF {
- let len = input.next().unwrap();
- let c = input.next().unwrap();
+ let len = inp.next().unwrap();
+ let c = inp.next().unwrap();
for _ in 0..len {
- output.send(c as char).await;
+ out.send(c as char).await;
}
} else {
- output.send(c as char).await;
+ out.send(c as char).await;
}
}
}
@@ -20,20 +20,20 @@ async fn decompress(mut input: impl Iterator<Item=u8>,
#[derive(Clone, Debug)]
enum Token { WORD(String), PUNCT(char) }
-async fn tokenize(input: Receiver<char>, output: Sender<Token>) {
- while let Some(mut c) = input.recv().await {
+async fn tokenize(inp: Receiver<char>, out: Sender<Token>) {
+ while let Some(mut c) = inp.recv().await {
if c.is_alphabetic() {
let mut text = c.to_string();
- while let Some(new_c) = input.recv().await {
+ while let Some(new_c) = inp.recv().await {
if new_c.is_alphabetic() {
text.push(new_c);
} else {
c = new_c; break;
}
}
- output.send(WORD(text)).await;
+ out.send(WORD(text)).await;
}
- output.send(PUNCT(c)).await;
+ out.send(PUNCT(c)).await;
}
}
@@ -43,8 +43,8 @@ fn main() {
let input = b"He\xff\x02lo IST!".iter().cloned();
exec.run(async {
- let (s1, r1) = channel();
- let (s2, r2) = channel();
+ let (s1, r1) = channel::<char>();
+ let (s2, r2) = channel::<Token>();
spawner.spawn(decompress(input, s1));
spawner.spawn(tokenize(r1, s2));
diff --git a/src/lib.rs b/src/lib.rs
index 01be5822d08052537b3d32d47d4504e9d4a3c3a1..0c99bac0167d1796b0b1d2e407c30c6d6dcd2800 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -41,7 +41,8 @@ pub type Time = f64;
/// ```
/// fn simulation<G>(shared: G, main: impl for<'s> Active<'s,G>) {}
/// ```
-pub fn simulation<G>(shared: G, main: impl FnOnce(SimContext<G>) -> Process<G>) -> G {
+pub fn simulation<G,F>(shared: G, main: F) -> G
+where F: FnOnce(SimContext<G>) -> Process<G> {
// create a fresh scheduler and a handle to it
let sched = Scheduler::new(shared);
let sim = SimContext { handle: &sched };
@@ -175,8 +176,9 @@ impl<'s,G> SimContext<'s,G> {
/// Activates a new process with the given future.
#[inline]
- pub fn activate(&self, fut: impl Future<Output = ()> + 's) {
- self.reactivate(Process::new(*self, fut));
+ pub fn activate<F>(&self, f: F)
+ where F: Future<Output = ()> + 's {
+ self.reactivate(Process::new(*self, f));
}
/// Reactivates a process that has been suspended with wait().
@@ -497,7 +499,7 @@ impl Future for Sleep {
}
/// Future that returns immediately with a cloned waker.
-struct Waker {}
+struct Waker;
impl Future for Waker {
type Output = task::Waker;
@@ -533,7 +535,7 @@ impl Facility {
/// Attempts to seize the facility, blocking until it's possible.
pub async fn seize(&self) {
if self.in_use.replace(true) {
- self.queue.borrow_mut().push_back(Waker{}.await);
+ self.queue.borrow_mut().push_back(Waker.await);
sleep().await;
}
}
@@ -559,8 +561,8 @@ pub struct Promise<T> {
impl<T> Promise<T> {
/// Creates a new promise with an unwritten result.
- pub fn new(caller: task::Waker) -> Self {
- Self { caller, result: Cell::new(None) }
+ pub fn new(waker: task::Waker) -> Self {
+ Self { caller: waker, result: Cell::new(None) }
}
/// Writes the result value and reawakens the caller.