From 7e1c12b5e10345759695ac4f17f3121f8858eb8c Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Mon, 10 Jul 2023 11:46:50 +0200 Subject: [PATCH 1/7] Improve configuration deserialization with serde Add some tests to ensure deserialization works as intended. --- Cargo.lock | 33 ++++----- Cargo.toml | 1 + src/lib.rs | 186 +++++++++++++++++++++++++++++++++++++++++++++----- src/main.rs | 84 ++++++++++------------- src/worker.rs | 25 +++++-- 5 files changed, 242 insertions(+), 87 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 765152a..cb2d779 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -30,7 +30,7 @@ checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] @@ -70,6 +70,7 @@ dependencies = [ "nix", "rand", "rand_distr", + "serde", "syscalls", "usdt", ] @@ -277,7 +278,7 @@ checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] @@ -540,7 +541,7 @@ dependencies = [ "pest_meta", "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] @@ -574,18 +575,18 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" [[package]] name = "proc-macro2" -version = "1.0.56" +version = "1.0.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435" +checksum = "78803b62cbf1f46fde80d7c0e803111524b9877184cfe7c3033659490ac7a7da" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.26" +version = "1.0.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc" +checksum = "573015e8ab27661678357f27dc26460738fd2b6c86e46f386fde94cb5d913105" dependencies = [ "proc-macro2", ] @@ -685,22 +686,22 @@ checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041" [[package]] name = "serde" -version = "1.0.160" +version = "1.0.171" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c" +checksum = "30e27d1e4fd7659406c492fd6cfaf2066ba8773de45ca75e855590f856dc34a9" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.160" +version = "1.0.171" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "291a097c63d8497e00160b166a967a4a79c64f3facdd01cbd7502231688d77df" +checksum = "389894603bd18c46fa56231694f8d827779c0951a667087194cf9de94ed24682" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] @@ -722,7 +723,7 @@ checksum = "bcec881020c684085e55a25f7fd888954d56609ef363479dc5a1305eb0d40cab" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] @@ -775,9 +776,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.15" +version = "2.0.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822" +checksum = "15e3fc8c0c74267e2df136e5e5fb656a464158aa57624053375eb9c8c6e25ae2" dependencies = [ "proc-macro2", "quote", @@ -833,7 +834,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.25", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index c0e41c1..ad08e57 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,3 +18,4 @@ log = "0.4.6" env_logger = "0.9.0" config = "0.13.3" syscalls = "0.6.13" +serde = { version = "1.0.171", features = ["derive"] } diff --git a/src/lib.rs b/src/lib.rs index 209cfdb..52d3661 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,28 +1,182 @@ +use serde::Deserialize; + pub mod worker; -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy, Clone, Deserialize)] +#[serde(tag = "distribution")] pub enum Distribution { - Zipfian, - Uniform, + #[serde(alias = "zipf")] + Zipfian { n_ports: u64, exponent: f64 }, + #[serde(alias = "uniform")] + Uniform { lower: u64, upper: u64 }, } -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy, Clone, Deserialize)] +#[serde(rename_all = "lowercase", tag = "type")] pub enum Workload { - Endpoints, - Processes, - Syscalls, + Endpoints { + #[serde(flatten)] + distribution: Distribution, + }, + Processes { + arrival_rate: f64, + departure_rate: f64, + random_process: bool, + }, + Syscalls { + arrival_rate: f64, + }, } -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy, Clone, Deserialize)] pub struct WorkloadConfig { pub restart_interval: u64, - pub endpoints_dist: Distribution, pub workload: Workload, - pub zipf_exponent: f64, - pub n_ports: u64, - pub uniform_lower: u64, - pub uniform_upper: u64, - pub arrival_rate: f64, - pub departure_rate: f64, - pub random_process: bool, +} + +#[cfg(test)] +mod tests { + use super::*; + use config::{Config, File, FileFormat}; + + #[test] + fn test_processes() { + let input = r#" + restart_interval = 10 + + [workload] + type = "processes" + arrival_rate = 10.0 + departure_rate = 200.0 + random_process = true + "#; + + let config = Config::builder() + .add_source(File::from_str(input, FileFormat::Toml)) + .build() + .expect("failed to parse configuration") + .try_deserialize::() + .expect("failed to deserialize into WorkloadConfig"); + + let WorkloadConfig { + restart_interval, + workload, + } = config; + assert_eq!(restart_interval, 10); + if let Workload::Processes { + arrival_rate, + departure_rate, + random_process, + } = workload + { + assert_eq!(arrival_rate, 10.0); + assert_eq!(departure_rate, 200.0); + assert!(random_process); + } else { + panic!("wrong workload type found"); + } + } + + #[test] + fn test_endpoints_zipf() { + let input = r#" + restart_interval = 10 + + [workload] + type = "endpoints" + distribution = "zipf" + n_ports = 200 + exponent = 1.4 + "#; + + let config = Config::builder() + .add_source(File::from_str(input, FileFormat::Toml)) + .build() + .expect("failed to parse configuration") + .try_deserialize::() + .expect("failed to deserialize into WorkloadConfig"); + + let WorkloadConfig { + restart_interval, + workload, + } = config; + assert_eq!(restart_interval, 10); + + if let Workload::Endpoints { distribution } = workload { + if let Distribution::Zipfian { n_ports, exponent } = distribution { + assert_eq!(n_ports, 200); + assert_eq!(exponent, 1.4); + } else { + panic!("wrong distribution type found"); + } + } else { + panic!("wrong workload type found"); + } + } + + #[test] + fn test_endpoints_uniform() { + let input = r#" + restart_interval = 10 + + [workload] + type = "endpoints" + distribution = "uniform" + upper = 100 + lower = 1 + "#; + + let config = Config::builder() + .add_source(File::from_str(input, FileFormat::Toml)) + .build() + .expect("failed to parse configuration") + .try_deserialize::() + .expect("failed to deserialize into WorkloadConfig"); + + let WorkloadConfig { + restart_interval, + workload, + } = config; + assert_eq!(restart_interval, 10); + + if let Workload::Endpoints { distribution } = workload { + if let Distribution::Uniform { lower, upper } = distribution { + assert_eq!(lower, 1); + assert_eq!(upper, 100); + } else { + panic!("wrong distribution type found"); + } + } else { + panic!("wrong workload type found"); + } + } + + #[test] + fn test_syscalls() { + let input = r#" + restart_interval = 10 + + [workload] + type = "syscalls" + arrival_rate = 10.0 + "#; + + let config = Config::builder() + .add_source(File::from_str(input, FileFormat::Toml)) + .build() + .expect("failed to parse configuration") + .try_deserialize::() + .expect("failed to deserialize into WorkloadConfig"); + + let WorkloadConfig { + restart_interval, + workload, + } = config; + assert_eq!(restart_interval, 10); + if let Workload::Syscalls { arrival_rate } = workload { + assert_eq!(arrival_rate, 10.0); + } else { + panic!("wrong workload type found"); + } + } } diff --git a/src/main.rs b/src/main.rs index 817ad7a..8a3771a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,8 +2,6 @@ extern crate log; extern crate core_affinity; -use std::collections::HashMap; - use berserker::WorkloadConfig; use config::Config; use fork::{fork, Fork}; @@ -19,7 +17,7 @@ use berserker::{worker::WorkerConfig, Distribution, Workload}; fn main() { // Retrieve the IDs of all active CPU cores. let core_ids = core_affinity::get_core_ids().unwrap(); - let settings = Config::builder() + let config = Config::builder() // Add in `./Settings.toml` .add_source(config::File::with_name("/etc/berserker/workload.toml").required(false)) .add_source(config::File::with_name("workload.toml").required(false)) @@ -28,7 +26,7 @@ fn main() { .add_source(config::Environment::with_prefix("WORKLOAD")) .build() .unwrap() - .try_deserialize::>() + .try_deserialize::() .unwrap(); let mut lower = 1024; @@ -36,49 +34,28 @@ fn main() { env_logger::init(); - let workload = match settings["workload"].as_str() { - "endpoints" => Workload::Endpoints, - "processes" => Workload::Processes, - "syscalls" => Workload::Syscalls, - _ => Workload::Endpoints, - }; - - let endpoints_dist = match settings["endpoints_distribution"].as_str() { - "zipf" => Distribution::Zipfian, - "uniform" => Distribution::Uniform, - _ => Distribution::Zipfian, - }; - - let config = WorkloadConfig { - restart_interval: settings["restart_interval"].parse::().unwrap(), - endpoints_dist, - workload, - zipf_exponent: settings["zipf_exponent"].parse::().unwrap(), - n_ports: settings["n_ports"].parse::().unwrap(), - arrival_rate: settings["arrival_rate"].parse::().unwrap(), - departure_rate: settings["departure_rate"].parse::().unwrap(), - uniform_lower: settings["uniform_lower"].parse::().unwrap(), - uniform_upper: settings["uniform_upper"].parse::().unwrap(), - random_process: settings["random_process"].parse::().unwrap(), - }; - // Create processes for each active CPU core. let handles: Vec<_> = iproduct!(core_ids.into_iter(), 0..9) .map(|(cpu, process)| { - match config.endpoints_dist { - Distribution::Zipfian => { - let n_ports: f64 = thread_rng() - .sample(Zipf::new(config.n_ports, config.zipf_exponent).unwrap()); - - lower = upper; - upper += n_ports as usize; - } - Distribution::Uniform => { - let n_ports = thread_rng() - .sample(Uniform::new(config.uniform_lower, config.uniform_upper)); - - lower = upper; - upper += n_ports as usize; + if let Workload::Endpoints { distribution } = config.workload { + match distribution { + Distribution::Zipfian { n_ports, exponent } => { + let n_ports: f64 = + thread_rng().sample(Zipf::new(n_ports, exponent).unwrap()); + + lower = upper; + upper += n_ports as usize; + } + Distribution::Uniform { + lower: config_lower, + upper: config_upper, + } => { + // TODO: Double check this branch + let n_ports = thread_rng().sample(Uniform::new(config_lower, config_upper)); + + lower = upper; + upper += n_ports as usize; + } } } @@ -92,11 +69,20 @@ fn main() { let worker_config = WorkerConfig::new(config, cpu, process, lower, upper); loop { - let _res = match config.workload { - Workload::Endpoints => worker_config.listen_payload(), - Workload::Processes => worker_config.process_payload(), - Workload::Syscalls => worker_config.syscalls_payload(), - }; + match config.workload { + Workload::Endpoints { distribution: _ } => { + worker_config.listen_payload() + } + Workload::Processes { + arrival_rate: _, + departure_rate: _, + random_process: _, + } => worker_config.process_payload(), + Workload::Syscalls { arrival_rate: _ } => { + worker_config.syscalls_payload() + } + } + .unwrap(); } } diff --git a/src/worker.rs b/src/worker.rs index 7b8a723..1cd69fc 100644 --- a/src/worker.rs +++ b/src/worker.rs @@ -8,7 +8,7 @@ use rand::{distributions::Alphanumeric, thread_rng, Rng}; use rand_distr::Exp; use syscalls::{syscall, Sysno}; -use crate::WorkloadConfig; +use crate::{Workload, WorkloadConfig}; #[derive(Debug, Copy, Clone)] pub struct WorkerConfig { @@ -37,7 +37,13 @@ impl WorkerConfig { } fn spawn_process(&self, lifetime: u64) -> Result<()> { - if self.workload.random_process { + let Workload::Processes { + arrival_rate: _, + departure_rate: _, + random_process, + } = self.workload.workload else {unreachable!()}; + + if random_process { let uniq_arg: String = rand::thread_rng() .sample_iter(&Alphanumeric) .take(7) @@ -76,14 +82,19 @@ impl WorkerConfig { self.process, self.cpu.id, self.lower, self.upper ); + let Workload::Processes { + arrival_rate, + departure_rate, + random_process: _, + } = self.workload.workload else {unreachable!()}; + loop { - let lifetime: f64 = - thread_rng().sample(Exp::new(self.workload.departure_rate).unwrap()); + let lifetime: f64 = thread_rng().sample(Exp::new(departure_rate).unwrap()); let worker = *self; thread::spawn(move || worker.spawn_process((lifetime * 1000.0).round() as u64)); - let interval: f64 = thread_rng().sample(Exp::new(self.workload.arrival_rate).unwrap()); + let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); info!( "{}-{}: Interval {}, rounded {}, lifetime {}, rounded {}", self.cpu.id, @@ -125,13 +136,15 @@ impl WorkerConfig { self.process, self.cpu.id, self.lower, self.upper ); + let Workload::Syscalls { arrival_rate } = self.workload.workload else {unreachable!()}; + loop { let worker = *self; thread::spawn(move || { worker.do_syscall().unwrap(); }); - let interval: f64 = thread_rng().sample(Exp::new(self.workload.arrival_rate).unwrap()); + let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); info!( "{}-{}: Interval {}, rounded {}", self.cpu.id, From 091f67f82a040c53a95d760ca5d67f46afffef21 Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Mon, 10 Jul 2023 12:02:26 +0200 Subject: [PATCH 2/7] Adjust default workload Add workload examples. --- workload.toml | 15 ++------------- workloads/endpoints-uniform.toml | 7 +++++++ workloads/endpoints-zipf.toml | 7 +++++++ workloads/processes.toml | 7 +++++++ workloads/syscalls.toml | 5 +++++ 5 files changed, 28 insertions(+), 13 deletions(-) create mode 100644 workloads/endpoints-uniform.toml create mode 100644 workloads/endpoints-zipf.toml create mode 100644 workloads/processes.toml create mode 100644 workloads/syscalls.toml diff --git a/workload.toml b/workload.toml index 67d2cbe..f161df0 100644 --- a/workload.toml +++ b/workload.toml @@ -1,18 +1,7 @@ restart_interval = 10 -workload = "processes" -# endpoints workload -endpoints_distribution = "zipf" - -# endpoints zipf parameters -n_ports = 200 -zipf_exponent = 1.4 - -# endppoints uniform parameters -uniform_upper = 100 -uniform_lower = 1 - -# processes workload +[workload] +type = "processes" arrival_rate = 10.0 departure_rate = 200.0 random_process = true diff --git a/workloads/endpoints-uniform.toml b/workloads/endpoints-uniform.toml new file mode 100644 index 0000000..3c3b418 --- /dev/null +++ b/workloads/endpoints-uniform.toml @@ -0,0 +1,7 @@ +restart_interval = 10 + +[workload] +type = "endpoints" +distribution = "uniform" +uniform_upper = 100 +uniform_lower = 1 diff --git a/workloads/endpoints-zipf.toml b/workloads/endpoints-zipf.toml new file mode 100644 index 0000000..8680572 --- /dev/null +++ b/workloads/endpoints-zipf.toml @@ -0,0 +1,7 @@ +restart_interval = 10 + +[workload] +type = "endpoints" +distribution = "zipf" +n_ports = 200 +exponent = 1.4 diff --git a/workloads/processes.toml b/workloads/processes.toml new file mode 100644 index 0000000..f161df0 --- /dev/null +++ b/workloads/processes.toml @@ -0,0 +1,7 @@ +restart_interval = 10 + +[workload] +type = "processes" +arrival_rate = 10.0 +departure_rate = 200.0 +random_process = true diff --git a/workloads/syscalls.toml b/workloads/syscalls.toml new file mode 100644 index 0000000..0cbdcfc --- /dev/null +++ b/workloads/syscalls.toml @@ -0,0 +1,5 @@ +restart_interval = 10 + +[workload] +type = "syscalls" +arrival_rate = 10.0 From f1c7042ab3b43d59aef55fb4be3f8a859dc1907f Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Mon, 10 Jul 2023 12:55:51 +0200 Subject: [PATCH 3/7] Split workers using a Worker trait --- src/main.rs | 20 +---- src/worker.rs | 181 ---------------------------------------- src/worker/endpoints.rs | 67 +++++++++++++++ src/worker/mod.rs | 54 ++++++++++++ src/worker/processes.rs | 120 ++++++++++++++++++++++++++ src/worker/syscalls.rs | 82 ++++++++++++++++++ 6 files changed, 327 insertions(+), 197 deletions(-) delete mode 100644 src/worker.rs create mode 100644 src/worker/endpoints.rs create mode 100644 src/worker/mod.rs create mode 100644 src/worker/processes.rs create mode 100644 src/worker/syscalls.rs diff --git a/src/main.rs b/src/main.rs index 8a3771a..335381c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,6 +2,7 @@ extern crate log; extern crate core_affinity; +use berserker::worker::new_worker; use berserker::WorkloadConfig; use config::Config; use fork::{fork, Fork}; @@ -12,7 +13,7 @@ use rand::prelude::*; use rand_distr::Uniform; use rand_distr::Zipf; -use berserker::{worker::WorkerConfig, Distribution, Workload}; +use berserker::{Distribution, Workload}; fn main() { // Retrieve the IDs of all active CPU cores. @@ -66,23 +67,10 @@ fn main() { } Ok(Fork::Child) => { if core_affinity::set_for_current(cpu) { - let worker_config = WorkerConfig::new(config, cpu, process, lower, upper); + let worker = new_worker(config, cpu, process, lower, upper); loop { - match config.workload { - Workload::Endpoints { distribution: _ } => { - worker_config.listen_payload() - } - Workload::Processes { - arrival_rate: _, - departure_rate: _, - random_process: _, - } => worker_config.process_payload(), - Workload::Syscalls { arrival_rate: _ } => { - worker_config.syscalls_payload() - } - } - .unwrap(); + worker.run_payload().unwrap(); } } diff --git a/src/worker.rs b/src/worker.rs deleted file mode 100644 index 1cd69fc..0000000 --- a/src/worker.rs +++ /dev/null @@ -1,181 +0,0 @@ -use std::{io::Result, net::TcpListener, process::Command, thread, time}; - -use core_affinity::CoreId; -use fork::{fork, Fork}; -use log::{info, warn}; -use nix::{sys::wait::waitpid, unistd::Pid}; -use rand::{distributions::Alphanumeric, thread_rng, Rng}; -use rand_distr::Exp; -use syscalls::{syscall, Sysno}; - -use crate::{Workload, WorkloadConfig}; - -#[derive(Debug, Copy, Clone)] -pub struct WorkerConfig { - workload: WorkloadConfig, - cpu: CoreId, - process: usize, - lower: usize, - upper: usize, -} - -impl WorkerConfig { - pub fn new( - workload: WorkloadConfig, - cpu: CoreId, - process: usize, - lower: usize, - upper: usize, - ) -> Self { - WorkerConfig { - workload, - cpu, - process, - lower, - upper, - } - } - - fn spawn_process(&self, lifetime: u64) -> Result<()> { - let Workload::Processes { - arrival_rate: _, - departure_rate: _, - random_process, - } = self.workload.workload else {unreachable!()}; - - if random_process { - let uniq_arg: String = rand::thread_rng() - .sample_iter(&Alphanumeric) - .take(7) - .map(char::from) - .collect(); - let _res = Command::new("stub").arg(uniq_arg).output().unwrap(); - Ok(()) - } else { - match fork() { - Ok(Fork::Parent(child)) => { - info!("Parent: child {}", child); - waitpid(Pid::from_raw(child), None).unwrap(); - Ok(()) - } - Ok(Fork::Child) => { - info!( - "{}-{}: Child start, {}", - self.cpu.id, self.process, lifetime - ); - thread::sleep(time::Duration::from_millis(lifetime)); - info!("{}-{}: Child stop", self.cpu.id, self.process); - Ok(()) - } - Err(_) => { - warn!("Failed"); - Ok(()) - } - } - } - } - - // Spawn processes with a specified rate - pub fn process_payload(&self) -> std::io::Result<()> { - info!( - "Process {} from {}: {}-{}", - self.process, self.cpu.id, self.lower, self.upper - ); - - let Workload::Processes { - arrival_rate, - departure_rate, - random_process: _, - } = self.workload.workload else {unreachable!()}; - - loop { - let lifetime: f64 = thread_rng().sample(Exp::new(departure_rate).unwrap()); - - let worker = *self; - thread::spawn(move || worker.spawn_process((lifetime * 1000.0).round() as u64)); - - let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); - info!( - "{}-{}: Interval {}, rounded {}, lifetime {}, rounded {}", - self.cpu.id, - self.process, - interval, - (interval * 1000.0).round() as u64, - lifetime, - (lifetime * 1000.0).round() as u64 - ); - thread::sleep(time::Duration::from_millis( - (interval * 1000.0).round() as u64 - )); - info!("{}-{}: Continue", self.cpu.id, self.process); - } - } - - pub fn listen_payload(&self) -> std::io::Result<()> { - info!( - "Process {} from {}: {}-{}", - self.process, self.cpu.id, self.lower, self.upper - ); - - let restart_interval = self.workload.restart_interval; - - let listeners: Vec<_> = (self.lower..self.upper) - .map(|port| thread::spawn(move || listen(port, restart_interval))) - .collect(); - - for listener in listeners { - let _res = listener.join().unwrap(); - } - - Ok(()) - } - - pub fn syscalls_payload(&self) -> Result<()> { - info!( - "Process {} from {}: {}-{}", - self.process, self.cpu.id, self.lower, self.upper - ); - - let Workload::Syscalls { arrival_rate } = self.workload.workload else {unreachable!()}; - - loop { - let worker = *self; - thread::spawn(move || { - worker.do_syscall().unwrap(); - }); - - let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); - info!( - "{}-{}: Interval {}, rounded {}", - self.cpu.id, - self.process, - interval, - (interval * 1000.0).round() as u64 - ); - thread::sleep(time::Duration::from_millis( - (interval * 1000.0).round() as u64 - )); - info!("{}-{}: Continue", self.cpu.id, self.process); - } - } - - fn do_syscall(&self) -> std::io::Result<()> { - match unsafe { syscall!(Sysno::getpid) } { - Ok(_) => Ok(()), - Err(err) => { - warn!("Syscall failed: {}", err); - Ok(()) - } - } - } -} - -fn listen(port: usize, sleep: u64) -> std::io::Result<()> { - let addr = format!("127.0.0.1:{port}"); - let listener = TcpListener::bind(addr)?; - - let _res = listener.incoming(); - - thread::sleep(time::Duration::from_secs(sleep)); - Ok(()) -} diff --git a/src/worker/endpoints.rs b/src/worker/endpoints.rs new file mode 100644 index 0000000..e9e8f55 --- /dev/null +++ b/src/worker/endpoints.rs @@ -0,0 +1,67 @@ +use std::{net::TcpListener, thread, time}; + +use core_affinity::CoreId; +use log::info; + +use crate::WorkloadConfig; + +use super::{BaseConfig, Worker, WorkerError}; + +pub struct EndpointWorker { + config: BaseConfig, + workload: WorkloadConfig, +} + +impl EndpointWorker { + pub fn new( + workload: WorkloadConfig, + cpu: CoreId, + process: usize, + lower: usize, + upper: usize, + ) -> Self { + EndpointWorker { + config: BaseConfig { + cpu, + process, + lower, + upper, + }, + workload, + } + } +} + +impl Worker for EndpointWorker { + fn run_payload(&self) -> Result<(), WorkerError> { + let BaseConfig { + cpu, + process, + lower, + upper, + } = self.config; + info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + + let restart_interval = self.workload.restart_interval; + + let listeners: Vec<_> = (lower..upper) + .map(|port| thread::spawn(move || listen(port, restart_interval))) + .collect(); + + for listener in listeners { + let _res = listener.join().unwrap(); + } + + Ok(()) + } +} + +fn listen(port: usize, sleep: u64) -> std::io::Result<()> { + let addr = format!("127.0.0.1:{port}"); + let listener = TcpListener::bind(addr)?; + + let _res = listener.incoming(); + + thread::sleep(time::Duration::from_secs(sleep)); + Ok(()) +} diff --git a/src/worker/mod.rs b/src/worker/mod.rs new file mode 100644 index 0000000..279b720 --- /dev/null +++ b/src/worker/mod.rs @@ -0,0 +1,54 @@ +use std::fmt::Display; + +use core_affinity::CoreId; + +use crate::{Workload, WorkloadConfig}; + +use self::{endpoints::EndpointWorker, processes::ProcessesWorker, syscalls::SyscallsWorker}; + +pub mod endpoints; +pub mod processes; +pub mod syscalls; + +#[derive(Debug)] +pub enum WorkerError {} + +impl Display for WorkerError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "worker error found") + } +} + +pub trait Worker { + fn run_payload(&self) -> Result<(), WorkerError>; +} + +#[derive(Debug, Copy, Clone)] +struct BaseConfig { + cpu: CoreId, + process: usize, + lower: usize, + upper: usize, +} + +pub fn new_worker( + workload: WorkloadConfig, + cpu: CoreId, + process: usize, + lower: usize, + upper: usize, +) -> Box { + match workload.workload { + Workload::Processes { + arrival_rate: _, + departure_rate: _, + random_process: _, + } => Box::new(ProcessesWorker::new(workload, cpu, process, lower, upper)), + Workload::Endpoints { distribution: _ } => { + Box::new(EndpointWorker::new(workload, cpu, process, lower, upper)) + } + Workload::Syscalls { arrival_rate: _ } => { + Box::new(SyscallsWorker::new(workload, cpu, process, lower, upper)) + } + } +} diff --git a/src/worker/processes.rs b/src/worker/processes.rs new file mode 100644 index 0000000..b00866f --- /dev/null +++ b/src/worker/processes.rs @@ -0,0 +1,120 @@ +use std::{process::Command, thread, time}; + +use core_affinity::CoreId; +use fork::{fork, Fork}; +use log::{info, warn}; +use nix::{sys::wait::waitpid, unistd::Pid}; +use rand::{distributions::Alphanumeric, thread_rng, Rng}; +use rand_distr::Exp; + +use crate::{Workload, WorkloadConfig}; + +use super::{BaseConfig, Worker, WorkerError}; + +#[derive(Debug, Clone, Copy)] +pub struct ProcessesWorker { + config: BaseConfig, + workload: WorkloadConfig, +} + +impl ProcessesWorker { + pub fn new( + workload: WorkloadConfig, + cpu: CoreId, + process: usize, + lower: usize, + upper: usize, + ) -> Self { + ProcessesWorker { + config: BaseConfig { + cpu, + process, + lower, + upper, + }, + workload, + } + } + + fn spawn_process(&self, lifetime: u64) -> Result<(), WorkerError> { + let Workload::Processes { + arrival_rate: _, + departure_rate: _, + random_process, + } = self.workload.workload else { unreachable!() }; + let BaseConfig { + cpu, + process, + lower: _, + upper: _, + } = self.config; + + if random_process { + let uniq_arg: String = rand::thread_rng() + .sample_iter(&Alphanumeric) + .take(7) + .map(char::from) + .collect(); + let _res = Command::new("stub").arg(uniq_arg).output().unwrap(); + Ok(()) + } else { + match fork() { + Ok(Fork::Parent(child)) => { + info!("Parent: child {}", child); + waitpid(Pid::from_raw(child), None).unwrap(); + Ok(()) + } + Ok(Fork::Child) => { + info!("{}-{}: Child start, {}", cpu.id, process, lifetime); + thread::sleep(time::Duration::from_millis(lifetime)); + info!("{}-{}: Child stop", cpu.id, process); + Ok(()) + } + Err(_) => { + warn!("Failed"); + Ok(()) + } + } + } + } +} + +impl Worker for ProcessesWorker { + fn run_payload(&self) -> Result<(), super::WorkerError> { + let BaseConfig { + cpu, + process, + lower, + upper, + } = self.config; + info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + + let Workload::Processes { + arrival_rate, + departure_rate, + random_process: _, + } = self.workload.workload else {unreachable!()}; + + loop { + let lifetime: f64 = thread_rng().sample(Exp::new(departure_rate).unwrap()); + + let worker = *self; + thread::spawn(move || worker.spawn_process((lifetime * 1000.0).round() as u64)); + + let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); + info!( + "{}-{}: Interval {}, rounded {}, lifetime {}, rounded {}", + cpu.id, + process, + interval, + (interval * 1000.0).round() as u64, + lifetime, + (lifetime * 1000.0).round() as u64 + ); + thread::sleep(time::Duration::from_millis( + (interval * 1000.0).round() as u64 + )); + info!("{}-{}: Continue", cpu.id, process); + } + } +} diff --git a/src/worker/syscalls.rs b/src/worker/syscalls.rs new file mode 100644 index 0000000..52f9266 --- /dev/null +++ b/src/worker/syscalls.rs @@ -0,0 +1,82 @@ +use std::{thread, time}; + +use core_affinity::CoreId; +use log::{info, warn}; +use rand::{thread_rng, Rng}; +use rand_distr::Exp; +use syscalls::{syscall, Sysno}; + +use crate::{Workload, WorkloadConfig}; + +use super::{BaseConfig, Worker}; + +#[derive(Debug, Copy, Clone)] +pub struct SyscallsWorker { + config: BaseConfig, + workload: WorkloadConfig, +} + +impl SyscallsWorker { + pub fn new( + workload: WorkloadConfig, + cpu: CoreId, + process: usize, + lower: usize, + upper: usize, + ) -> Self { + SyscallsWorker { + config: BaseConfig { + cpu, + process, + lower, + upper, + }, + workload, + } + } + + fn do_syscall(&self) -> std::io::Result<()> { + match unsafe { syscall!(Sysno::getpid) } { + Ok(_) => Ok(()), + Err(err) => { + warn!("Syscall failed: {}", err); + Ok(()) + } + } + } +} + +impl Worker for SyscallsWorker { + fn run_payload(&self) -> Result<(), super::WorkerError> { + let BaseConfig { + cpu, + process, + lower, + upper, + } = self.config; + + info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + + let Workload::Syscalls { arrival_rate } = self.workload.workload else {unreachable!()}; + + loop { + let worker = *self; + thread::spawn(move || { + worker.do_syscall().unwrap(); + }); + + let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); + info!( + "{}-{}: Interval {}, rounded {}", + cpu.id, + process, + interval, + (interval * 1000.0).round() as u64 + ); + thread::sleep(time::Duration::from_millis( + (interval * 1000.0).round() as u64 + )); + info!("{}-{}: Continue", cpu.id, process); + } + } +} From 4408f5e761c6d2d098660298289e9bfcb981e1a4 Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Mon, 10 Jul 2023 13:20:03 +0200 Subject: [PATCH 4/7] Minor displaying improvements --- src/main.rs | 8 +++----- src/worker/endpoints.rs | 18 +++++++++--------- src/worker/mod.rs | 10 ++++++++++ src/worker/processes.rs | 22 +++++++++++----------- src/worker/syscalls.rs | 23 +++++++++++------------ 5 files changed, 44 insertions(+), 37 deletions(-) diff --git a/src/main.rs b/src/main.rs index 335381c..ce84f17 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,8 +2,6 @@ extern crate log; extern crate core_affinity; -use berserker::worker::new_worker; -use berserker::WorkloadConfig; use config::Config; use fork::{fork, Fork}; use itertools::iproduct; @@ -13,7 +11,7 @@ use rand::prelude::*; use rand_distr::Uniform; use rand_distr::Zipf; -use berserker::{Distribution, Workload}; +use berserker::{worker::new_worker, Distribution, Workload, WorkloadConfig}; fn main() { // Retrieve the IDs of all active CPU cores. @@ -76,8 +74,8 @@ fn main() { None } - Err(_) => { - warn!("Failed"); + Err(e) => { + warn!("Failed: {e:?}"); None } } diff --git a/src/worker/endpoints.rs b/src/worker/endpoints.rs index e9e8f55..03fcdc1 100644 --- a/src/worker/endpoints.rs +++ b/src/worker/endpoints.rs @@ -1,4 +1,4 @@ -use std::{net::TcpListener, thread, time}; +use std::{fmt::Display, net::TcpListener, thread, time}; use core_affinity::CoreId; use log::info; @@ -34,17 +34,11 @@ impl EndpointWorker { impl Worker for EndpointWorker { fn run_payload(&self) -> Result<(), WorkerError> { - let BaseConfig { - cpu, - process, - lower, - upper, - } = self.config; - info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + info!("{self}"); let restart_interval = self.workload.restart_interval; - let listeners: Vec<_> = (lower..upper) + let listeners: Vec<_> = (self.config.lower..self.config.upper) .map(|port| thread::spawn(move || listen(port, restart_interval))) .collect(); @@ -56,6 +50,12 @@ impl Worker for EndpointWorker { } } +impl Display for EndpointWorker { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.config) + } +} + fn listen(port: usize, sleep: u64) -> std::io::Result<()> { let addr = format!("127.0.0.1:{port}"); let listener = TcpListener::bind(addr)?; diff --git a/src/worker/mod.rs b/src/worker/mod.rs index 279b720..12df638 100644 --- a/src/worker/mod.rs +++ b/src/worker/mod.rs @@ -31,6 +31,16 @@ struct BaseConfig { upper: usize, } +impl Display for BaseConfig { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "Process {} from {}: {}-{}", + self.process, self.cpu.id, self.lower, self.upper + ) + } +} + pub fn new_worker( workload: WorkloadConfig, cpu: CoreId, diff --git a/src/worker/processes.rs b/src/worker/processes.rs index b00866f..7e72370 100644 --- a/src/worker/processes.rs +++ b/src/worker/processes.rs @@ -1,4 +1,4 @@ -use std::{process::Command, thread, time}; +use std::{fmt::Display, process::Command, thread, time}; use core_affinity::CoreId; use fork::{fork, Fork}; @@ -81,13 +81,7 @@ impl ProcessesWorker { impl Worker for ProcessesWorker { fn run_payload(&self) -> Result<(), super::WorkerError> { - let BaseConfig { - cpu, - process, - lower, - upper, - } = self.config; - info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + info!("{self}"); let Workload::Processes { arrival_rate, @@ -104,8 +98,8 @@ impl Worker for ProcessesWorker { let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); info!( "{}-{}: Interval {}, rounded {}, lifetime {}, rounded {}", - cpu.id, - process, + self.config.cpu.id, + self.config.process, interval, (interval * 1000.0).round() as u64, lifetime, @@ -114,7 +108,13 @@ impl Worker for ProcessesWorker { thread::sleep(time::Duration::from_millis( (interval * 1000.0).round() as u64 )); - info!("{}-{}: Continue", cpu.id, process); + info!("{}-{}: Continue", self.config.cpu.id, self.config.process); } } } + +impl Display for ProcessesWorker { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.config) + } +} diff --git a/src/worker/syscalls.rs b/src/worker/syscalls.rs index 52f9266..6e77111 100644 --- a/src/worker/syscalls.rs +++ b/src/worker/syscalls.rs @@ -1,4 +1,4 @@ -use std::{thread, time}; +use std::{fmt::Display, thread, time}; use core_affinity::CoreId; use log::{info, warn}; @@ -48,14 +48,7 @@ impl SyscallsWorker { impl Worker for SyscallsWorker { fn run_payload(&self) -> Result<(), super::WorkerError> { - let BaseConfig { - cpu, - process, - lower, - upper, - } = self.config; - - info!("Process {} from {}: {}-{}", process, cpu.id, lower, upper); + info!("{self}"); let Workload::Syscalls { arrival_rate } = self.workload.workload else {unreachable!()}; @@ -68,15 +61,21 @@ impl Worker for SyscallsWorker { let interval: f64 = thread_rng().sample(Exp::new(arrival_rate).unwrap()); info!( "{}-{}: Interval {}, rounded {}", - cpu.id, - process, + self.config.cpu.id, + self.config.process, interval, (interval * 1000.0).round() as u64 ); thread::sleep(time::Duration::from_millis( (interval * 1000.0).round() as u64 )); - info!("{}-{}: Continue", cpu.id, process); + info!("{}-{}: Continue", self.config.cpu.id, self.config.process); } } } + +impl Display for SyscallsWorker { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.config) + } +} From da007c320048666f32aa96469ec84d736d394cf2 Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Mon, 10 Jul 2023 13:21:17 +0200 Subject: [PATCH 5/7] Add tests running to CI --- .github/workflows/main.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a2b46d1..3320b1b 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -11,7 +11,7 @@ concurrency: cancel-in-progress: true jobs: - lint: + lint-and-test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 @@ -22,6 +22,9 @@ jobs: - name: Run clippy run: cargo clippy + - name: Run tests + run: cargo test + build: runs-on: ubuntu-latest steps: From e6187f87d2545683e991280a3bdff430ba616e9d Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Fri, 11 Aug 2023 13:20:13 +0200 Subject: [PATCH 6/7] Move port bounds to the endpoint worker The upper and lower bounds are only used by the endpoint worker, so it is now removed from other types. The new_worker function now takes mutable references to these bounds and the generation of independent port ranges is delegated to this function. This also means the workers must now be created by the parent process before forking itself in order to have one source of truth for the ranges (but this should be fine, since in the parent the worker goes out of scope right after forking). --- src/lib.rs | 2 +- src/main.rs | 29 ++--------------------- src/worker/endpoints.rs | 28 ++++++++++++++++------ src/worker/mod.rs | 51 +++++++++++++++++++++++++---------------- src/worker/processes.rs | 22 +++--------------- src/worker/syscalls.rs | 15 ++---------- 6 files changed, 60 insertions(+), 87 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 52d3661..551a739 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -102,7 +102,7 @@ mod tests { } = config; assert_eq!(restart_interval, 10); - if let Workload::Endpoints { distribution } = workload { + if let Workload::Endpoints { distribution, .. } = workload { if let Distribution::Zipfian { n_ports, exponent } = distribution { assert_eq!(n_ports, 200); assert_eq!(exponent, 1.4); diff --git a/src/main.rs b/src/main.rs index ce84f17..2adb93b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,11 +7,8 @@ use fork::{fork, Fork}; use itertools::iproduct; use nix::sys::wait::waitpid; use nix::unistd::Pid; -use rand::prelude::*; -use rand_distr::Uniform; -use rand_distr::Zipf; -use berserker::{worker::new_worker, Distribution, Workload, WorkloadConfig}; +use berserker::{worker::new_worker, WorkloadConfig}; fn main() { // Retrieve the IDs of all active CPU cores. @@ -36,27 +33,7 @@ fn main() { // Create processes for each active CPU core. let handles: Vec<_> = iproduct!(core_ids.into_iter(), 0..9) .map(|(cpu, process)| { - if let Workload::Endpoints { distribution } = config.workload { - match distribution { - Distribution::Zipfian { n_ports, exponent } => { - let n_ports: f64 = - thread_rng().sample(Zipf::new(n_ports, exponent).unwrap()); - - lower = upper; - upper += n_ports as usize; - } - Distribution::Uniform { - lower: config_lower, - upper: config_upper, - } => { - // TODO: Double check this branch - let n_ports = thread_rng().sample(Uniform::new(config_lower, config_upper)); - - lower = upper; - upper += n_ports as usize; - } - } - } + let worker = new_worker(config, cpu, process, &mut lower, &mut upper); match fork() { Ok(Fork::Parent(child)) => { @@ -65,8 +42,6 @@ fn main() { } Ok(Fork::Child) => { if core_affinity::set_for_current(cpu) { - let worker = new_worker(config, cpu, process, lower, upper); - loop { worker.run_payload().unwrap(); } diff --git a/src/worker/endpoints.rs b/src/worker/endpoints.rs index 03fcdc1..4953e08 100644 --- a/src/worker/endpoints.rs +++ b/src/worker/endpoints.rs @@ -7,9 +7,15 @@ use crate::WorkloadConfig; use super::{BaseConfig, Worker, WorkerError}; +struct EndpointWorkload { + restart_interval: u64, + lower: usize, + upper: usize, +} + pub struct EndpointWorker { config: BaseConfig, - workload: WorkloadConfig, + workload: EndpointWorkload, } impl EndpointWorker { @@ -20,14 +26,18 @@ impl EndpointWorker { lower: usize, upper: usize, ) -> Self { + let WorkloadConfig { + restart_interval, + workload: _, + } = workload; + EndpointWorker { - config: BaseConfig { - cpu, - process, + config: BaseConfig { cpu, process }, + workload: EndpointWorkload { + restart_interval, lower, upper, }, - workload, } } } @@ -36,9 +46,13 @@ impl Worker for EndpointWorker { fn run_payload(&self) -> Result<(), WorkerError> { info!("{self}"); - let restart_interval = self.workload.restart_interval; + let EndpointWorkload { + restart_interval, + lower, + upper, + } = self.workload; - let listeners: Vec<_> = (self.config.lower..self.config.upper) + let listeners: Vec<_> = (lower..upper) .map(|port| thread::spawn(move || listen(port, restart_interval))) .collect(); diff --git a/src/worker/mod.rs b/src/worker/mod.rs index 12df638..9804626 100644 --- a/src/worker/mod.rs +++ b/src/worker/mod.rs @@ -1,8 +1,10 @@ use std::fmt::Display; use core_affinity::CoreId; +use rand::{thread_rng, Rng}; +use rand_distr::{Uniform, Zipf}; -use crate::{Workload, WorkloadConfig}; +use crate::{Distribution, Workload, WorkloadConfig}; use self::{endpoints::EndpointWorker, processes::ProcessesWorker, syscalls::SyscallsWorker}; @@ -27,17 +29,11 @@ pub trait Worker { struct BaseConfig { cpu: CoreId, process: usize, - lower: usize, - upper: usize, } impl Display for BaseConfig { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!( - f, - "Process {} from {}: {}-{}", - self.process, self.cpu.id, self.lower, self.upper - ) + write!(f, "Process {} from {}", self.process, self.cpu.id) } } @@ -45,20 +41,35 @@ pub fn new_worker( workload: WorkloadConfig, cpu: CoreId, process: usize, - lower: usize, - upper: usize, + lower_bound: &mut usize, + upper_bound: &mut usize, ) -> Box { match workload.workload { - Workload::Processes { - arrival_rate: _, - departure_rate: _, - random_process: _, - } => Box::new(ProcessesWorker::new(workload, cpu, process, lower, upper)), - Workload::Endpoints { distribution: _ } => { - Box::new(EndpointWorker::new(workload, cpu, process, lower, upper)) - } - Workload::Syscalls { arrival_rate: _ } => { - Box::new(SyscallsWorker::new(workload, cpu, process, lower, upper)) + Workload::Processes { .. } => Box::new(ProcessesWorker::new(workload, cpu, process)), + Workload::Endpoints { distribution } => { + match distribution { + Distribution::Zipfian { n_ports, exponent } => { + let n_ports: f64 = thread_rng().sample(Zipf::new(n_ports, exponent).unwrap()); + + *lower_bound = *upper_bound; + *upper_bound += n_ports as usize; + } + Distribution::Uniform { lower, upper } => { + // TODO: Double check this branch + let n_ports = thread_rng().sample(Uniform::new(lower, upper)); + + *lower_bound = *upper_bound; + *upper_bound += n_ports as usize; + } + } + Box::new(EndpointWorker::new( + workload, + cpu, + process, + *lower_bound, + *upper_bound, + )) } + Workload::Syscalls { .. } => Box::new(SyscallsWorker::new(workload, cpu, process)), } } diff --git a/src/worker/processes.rs b/src/worker/processes.rs index 7e72370..ee4f0a1 100644 --- a/src/worker/processes.rs +++ b/src/worker/processes.rs @@ -18,20 +18,9 @@ pub struct ProcessesWorker { } impl ProcessesWorker { - pub fn new( - workload: WorkloadConfig, - cpu: CoreId, - process: usize, - lower: usize, - upper: usize, - ) -> Self { + pub fn new(workload: WorkloadConfig, cpu: CoreId, process: usize) -> Self { ProcessesWorker { - config: BaseConfig { - cpu, - process, - lower, - upper, - }, + config: BaseConfig { cpu, process }, workload, } } @@ -42,12 +31,7 @@ impl ProcessesWorker { departure_rate: _, random_process, } = self.workload.workload else { unreachable!() }; - let BaseConfig { - cpu, - process, - lower: _, - upper: _, - } = self.config; + let BaseConfig { cpu, process } = self.config; if random_process { let uniq_arg: String = rand::thread_rng() diff --git a/src/worker/syscalls.rs b/src/worker/syscalls.rs index 6e77111..f97564a 100644 --- a/src/worker/syscalls.rs +++ b/src/worker/syscalls.rs @@ -17,20 +17,9 @@ pub struct SyscallsWorker { } impl SyscallsWorker { - pub fn new( - workload: WorkloadConfig, - cpu: CoreId, - process: usize, - lower: usize, - upper: usize, - ) -> Self { + pub fn new(workload: WorkloadConfig, cpu: CoreId, process: usize) -> Self { SyscallsWorker { - config: BaseConfig { - cpu, - process, - lower, - upper, - }, + config: BaseConfig { cpu, process }, workload, } } From 86a2ead64af6424be0a3741ca3e43e4dbb7797e2 Mon Sep 17 00:00:00 2001 From: Mauro Ezequiel Moltrasio Date: Fri, 11 Aug 2023 13:25:47 +0200 Subject: [PATCH 7/7] Fix uniform endpoints workload --- workloads/endpoints-uniform.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/workloads/endpoints-uniform.toml b/workloads/endpoints-uniform.toml index 3c3b418..197ba6e 100644 --- a/workloads/endpoints-uniform.toml +++ b/workloads/endpoints-uniform.toml @@ -3,5 +3,5 @@ restart_interval = 10 [workload] type = "endpoints" distribution = "uniform" -uniform_upper = 100 -uniform_lower = 1 +upper = 100 +lower = 1