Criterion calibration sync performance bench

Author: RainerZ

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "xcp"
-version = "0.3.0"
+version = "0.1.0"
 edition = "2021"
 resolver = "2"
 rust-version = "1.76"
@@ -158,6 +158,14 @@ image = "0.25.2"
 prost = "0.13.1"
 prost-types = "0.13.1"
 
+# benchmarking
+criterion = { version = "0.4", features = ["html_reports"] }
+
+[[bench]]
+name = "xcp_benchmark"
+harness = false
+
+
 [build-dependencies]
 cc = "1.0"
 build-info-build = "0.0.36"

benches/xcp_benchmark.rs

@@ -0,0 +1,276 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+#[allow(unused_imports)]
+use log::{debug, error, info, trace, warn};
+use std::{
+    fmt::Debug,
+    sync::{Arc, Mutex},
+    thread,
+    time::Duration,
+};
+
+use serde::{Deserialize, Serialize};
+use xcp::*;
+use xcp_type_description::prelude::*;
+
+use xcp_client::xcp_client::*;
+
+//-----------------------------------------------------------------------------
+// Calibration parameters
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, XcpTypeDescription)]
+struct CalPage {
+    #[type_description(comment = "Amplitude value")]
+    #[type_description(min = "0")]
+    #[type_description(max = "10000.0")]
+    ampl: f64,
+
+    delay: u32,
+}
+
+const CAL_PAGE: CalPage = CalPage { ampl: 123.456, delay: 100 };
+
+//-----------------------------------------------------------------------------
+// XCP client
+
+// Handle incomming DAQ data
+
+#[derive(Debug, Clone, Copy)]
+struct DaqDecoder {
+    event_count: u64,
+    event_lost_count: u64,
+}
+
+impl DaqDecoder {
+    pub fn new() -> DaqDecoder {
+        DaqDecoder { event_count: 0, event_lost_count: 0 }
+    }
+}
+
+impl XcpDaqDecoder for DaqDecoder {
+    fn decode(&mut self, lost: u32, _daq: u16, _odt: u8, _time: u32, _data: &[u8]) {
+        self.event_count += 1;
+        self.event_lost_count += lost as u64;
+    }
+}
+
+// Handle incomming SERV_TEXT data
+
+#[derive(Debug, Clone, Copy)]
+struct ServTextDecoder;
+
+impl ServTextDecoder {
+    pub fn new() -> ServTextDecoder {
+        ServTextDecoder {}
+    }
+}
+
+impl XcpTextDecoder for ServTextDecoder {
+    fn decode(&self, _data: &[u8]) {}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ClientMode {
+    Wait,
+    Calibrate,
+    Measure,
+    Stop,
+}
+
+// XCP client
+async fn xcp_client(dest_addr: std::net::SocketAddr, local_addr: std::net::SocketAddr, mode: Arc<parking_lot::Mutex<ClientMode>>) -> Result<(), Box<dyn std::error::Error>> {
+    println!("XCP client ");
+
+    // Create xcp_client
+    let mut xcp_client = XcpClient::new(dest_addr, local_addr);
+
+    // Connect to the XCP server
+    info!("XCP Connect");
+    let daq_decoder = Arc::new(Mutex::new(DaqDecoder::new()));
+    xcp_client.connect(Arc::clone(&daq_decoder), ServTextDecoder::new()).await?;
+
+    // Upload A2L file
+    info!("Load A2L file to file xcp_lite.a2l");
+    xcp_client.load_a2l("xcp_lite.a2l", true, true).await?;
+
+    // Create a calibration object for CalPage.ampl
+    info!("Create calibration object CalPage.ampl");
+    let ampl = xcp_client
+        .create_calibration_object("CalPage.ampl")
+        .await
+        .expect("Failed to create calibration object for CalPage.ampl");
+    let v = xcp_client.get_value_f64(ampl);
+    info!("CalPage.ampl = {}", v);
+
+    let mut last_mode = *mode.lock();
+
+    loop {
+        let current_mode = *mode.lock();
+        let first = current_mode != last_mode;
+
+        if first {
+            match current_mode {
+                ClientMode::Measure => {
+                    info!("Start Measurement");
+                    // Measurement of signal
+                    xcp_client.create_measurement_object("signal").expect("measurmeent signal not found");
+                    // Measure start
+                    xcp_client.start_measurement().await.expect("could not start measurement");
+                }
+
+                ClientMode::Calibrate => {
+                    info!("Start Calibration");
+                }
+
+                _ => {}
+            }
+
+            info!("Client mode switched from {:?} to {:?}", last_mode, current_mode);
+        }
+
+        last_mode = current_mode;
+
+        match current_mode {
+            ClientMode::Wait => {
+                tokio::time::sleep(Duration::from_micros(1000)).await;
+            }
+
+            ClientMode::Measure => {
+                tokio::time::sleep(Duration::from_micros(1000)).await;
+            }
+
+            ClientMode::Calibrate => {
+                // Do calibrations
+                const LOOPS: usize = 10000;
+                let mut v = 0.0;
+                let mut t: u128 = 0;
+                for _ in 0..LOOPS {
+                    v += 0.1;
+                    trace!("CalPage.ampl = {}", v);
+                    let t0 = tokio::time::Instant::now();
+                    xcp_client.set_value_f64(ampl, v).await.unwrap();
+                    t += t0.elapsed().as_nanos();
+                }
+                let t_avg = ((t / LOOPS as u128) as f64) / 1000.0; // us
+                info!("Calibration performance, avg duration = {:.1} us ", t_avg);
+                if t_avg > 100.0 {
+                    warn!("Calibration operation duration average time exceeds 100us!")
+                };
+            }
+            ClientMode::Stop => {
+                info!("Stop");
+                break;
+            }
+        }
+    }
+
+    // Stop measurement
+    xcp_client.stop_measurement().await?;
+    let event_count = daq_decoder.lock().unwrap().event_count;
+    let event_lost_count = daq_decoder.lock().unwrap().event_lost_count;
+    info!(
+        "Measurement stopped, event count = {}, lost event count = {} - {:.1}%",
+        event_count,
+        event_lost_count,
+        event_lost_count as f64 / event_count as f64 * 100.0
+    );
+
+    // Disconnect
+    xcp_client.disconnect().await?;
+
+    Ok(())
+}
+
+fn xcp_client_task(mode: Arc<parking_lot::Mutex<ClientMode>>) {
+    let dest_addr: std::net::SocketAddr = "127.0.0.1:5555".parse().unwrap();
+    let local_addr: std::net::SocketAddr = "0.0.0.0:0".parse().unwrap();
+    info!("dest_addr: {}", dest_addr);
+    info!("local_addr: {}", local_addr);
+
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    runtime.block_on(xcp_client(dest_addr, local_addr, mode)).unwrap()
+}
+
+//-----------------------------------------------------------------------------
+
+fn xcp_benchmark(c: &mut Criterion) {
+    println!("XCP Benchmark");
+
+    env_logger::Builder::new().filter_level(log::LevelFilter::Info).init();
+
+    // Start XCP server
+    let xcp = XcpBuilder::new("xcp_benchmark")
+        .set_log_level(XcpLogLevel::Info)
+        .set_epk("EPK_")
+        .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
+        .unwrap();
+
+    // Create a calibration segment
+    let cal_page = xcp.create_calseg("CalPage", &CAL_PAGE, true);
+
+    // Measurement signal
+    let mut signal: f64 = 0.0;
+
+    // Register a measurement event and bind it to the counter signal
+    let event = daq_create_event!("mainloop");
+    daq_register!(signal, event);
+
+    // Wait a moment
+    thread::sleep(Duration::from_millis(100));
+
+    // Start XCP client task
+    let mode = Arc::new(parking_lot::Mutex::new(ClientMode::Wait));
+    let mode_cloned = mode.clone();
+    let xcp_client_task = thread::spawn(move || {
+        xcp_client_task(mode_cloned);
+    });
+
+    // Wait a moment
+    thread::sleep(Duration::from_millis(100));
+
+    // Bench calibration segment sync
+    // Bench calibration operations (in xcp_client_task)
+    info!("Start calibration bench");
+    *mode.lock() = ClientMode::Calibrate;
+    let mut count = 0;
+    c.bench_function("sync", |b| {
+        b.iter(|| {
+            if cal_page.sync() {
+                count += 1;
+            }
+        })
+    });
+    *mode.lock() = ClientMode::Wait;
+    info!("Calibration bench done, changes observed: {}", count);
+
+    // Wait a moment
+    thread::sleep(Duration::from_millis(100));
+
+    // Bench measurement trigger
+    info!("Start measurement bench");
+    *mode.lock() = ClientMode::Measure;
+    c.bench_function("trigger", |b| {
+        b.iter(|| {
+            signal += 1.0;
+            event.trigger()
+        })
+    });
+    *mode.lock() = ClientMode::Wait;
+    thread::sleep(Duration::from_millis(100));
+    info!("Measurement bench done, count = {}", signal);
+
+    // Wait a moment
+    thread::sleep(Duration::from_millis(100));
+
+    // Wait for stop of XCP client
+    *mode.lock() = ClientMode::Stop;
+    xcp_client_task.join().unwrap();
+    info!("Client stopped");
+
+    // Stop XCP server
+    xcp.stop_server();
+    info!("Server stopped");
+}
+
+criterion_group!(benches, xcp_benchmark);
+criterion_main!(benches);

examples/hello_xcp/src/main.rs

@@ -45,7 +45,7 @@ fn main() {
         .start_server(XcpTransportLayer::Udp, [127, 0, 0, 1], 5555)
         .unwrap();
 
-    let calseg = xcp.create_calseg("calseg", &CAL_PAGE, true);
+    let calseg = xcp.create_calseg("CalPage", &CAL_PAGE, true);
 
     // Measurement signal
     let mut counter: u16 = calseg.min;
@@ -68,6 +68,6 @@ fn main() {
 
         thread::sleep(Duration::from_micros(calseg.delay as u64));
 
-        //xcp.write_a2l();
+        xcp.write_a2l().unwrap(); // Force writing the A2L file once (for inspection)
     }
 }

examples/rayon_demo/src/main.rs

@@ -60,7 +60,7 @@ fn write_image(filename: &str, pixels: &[u8]) {
     // Create rgb image buffer and write to file
     let mut imgbuf = ImageBuffer::new(X_RES as u32, Y_RES as u32);
     for (x, y, rgb_pixel) in imgbuf.enumerate_pixels_mut() {
-        *rgb_pixel = color_map[pixels[y as usize * X_RES as usize + x as usize] as usize];
+        *rgb_pixel = color_map[pixels[y as usize * X_RES + x as usize] as usize];
     }
     imgbuf.save(filename).unwrap();
 }
@@ -113,6 +113,7 @@ fn render(pixels: &mut [u8], row: usize, length: usize, upper_left: Complex<f64>
     event.trigger(); // measure line and timestamp of calculation start
 
     // Render line
+    // @@@@
     for column in 0..length {
         let point = pixel_to_point((column, row), upper_left, lower_right);
         pixels[column] = match escape_time(point, 255) {