| use std::{ |
| process::Command, |
| time::{Duration, Instant}, |
| }; |
|
|
| use eyre::{eyre, Context, ContextCompat}; |
| use shared_memory_server::{ShmemClient, ShmemConf, ShmemServer}; |
|
|
| fn main() -> eyre::Result<()> { |
| let mut args = std::env::args(); |
| let executable = args.next().wrap_err("no arg 0")?; |
| let arg = args.next(); |
|
|
| match arg.as_deref() { |
| Some("client") => client(args.next().wrap_err("no shmem id")?)?, |
| None => server(executable)?, |
| Some(other) => eyre::bail!("unexpected argument `{other}`"), |
| } |
|
|
| Ok(()) |
| } |
|
|
| fn server(executable: String) -> eyre::Result<()> { |
| let shmem = ShmemConf::new() |
| .size(4096) |
| .create() |
| .wrap_err("failed to create shmem region")?; |
| let shmem_id = shmem.get_os_id().to_owned(); |
| let mut server = unsafe { ShmemServer::new(shmem) }.wrap_err("failed to create ShmemServer")?; |
|
|
| let mut client = Command::new(executable); |
| client.arg("client").arg(shmem_id); |
| let mut client_handle = client.spawn().wrap_err("failed to spawn client process")?; |
|
|
| server_loop(&mut server).wrap_err("server loop failed")?; |
|
|
| let status = client_handle |
| .wait() |
| .wrap_err("failed to wait for client process")?; |
|
|
| if status.success() { |
| Ok(()) |
| } else { |
| Err(eyre!("client failed")) |
| } |
| } |
|
|
| #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)] |
| enum Request { |
| Ping, |
| } |
|
|
| #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)] |
| enum Reply { |
| Pong, |
| } |
|
|
| fn server_loop(server: &mut ShmemServer<Request, Reply>) -> eyre::Result<()> { |
| while let Some(request) = server.listen().wrap_err("failed to receive next message")? { |
| match request { |
| Request::Ping => server |
| .send_reply(&Reply::Pong) |
| .wrap_err("failed to send reply")?, |
| } |
| } |
| Ok(()) |
| } |
|
|
| fn client(shmem_id: String) -> eyre::Result<()> { |
| let shmem = ShmemConf::new() |
| .os_id(shmem_id) |
| .open() |
| .wrap_err("failed to open shmem region")?; |
| let mut client = unsafe { ShmemClient::new(shmem, Some(Duration::from_secs(2))) } |
| .wrap_err("failed to create ShmemClient")?; |
|
|
| client_loop(&mut client).wrap_err("client loop failed")?; |
|
|
| Ok(()) |
| } |
|
|
| fn client_loop(client: &mut ShmemClient<Request, Reply>) -> eyre::Result<()> { |
| let mut latencies = Vec::new(); |
| for _ in 0..10_000_000 { |
| let start = Instant::now(); |
| let reply = client.request(&Request::Ping).wrap_err("ping failed")?; |
| match reply { |
| Reply::Pong => { |
| latencies.push(start.elapsed()); |
| } |
| } |
| } |
|
|
| let n = latencies.len(); |
| let avg_latency = latencies.iter().copied().sum::<Duration>() / n as u32; |
| let min_latency = latencies.iter().min().unwrap(); |
| let max_latency = latencies.iter().max().unwrap(); |
| println!("average latency: {avg_latency:?} (min: {min_latency:?}, max: {max_latency:?})"); |
|
|
| let mut longest: Vec<_> = latencies.iter().enumerate().map(|(i, d)| (d, i)).collect(); |
| longest.sort_unstable_by(|a, b| b.cmp(a)); |
|
|
| println!("\nlongest iterations:"); |
| for (duration, index) in &longest[..10] { |
| println!(" {index}: {duration:?}") |
| } |
|
|
| Ok(()) |
| } |
|
|
