README.md added

benches/README.md

@@ -0,0 +1,38 @@
+
+
+# Benchmarking the 2 performance critical functions DaqEvent::trigger and CalSeg::sync
+
+## DaqEvent::trigger
+
+memcpy versus this:
+
+'''
+            if (n==8) {
+                *(uint64_t*)d = *(uint64_t*)&base[OdtEntryAddr(e)];
+                d += 8;
+            }
+            else if (n==4) {
+                *(uint32_t*)d = *(uint32_t*)&base[OdtEntryAddr(e)];
+                d += 4;
+            }
+            else if (n<4) {
+                uint8_t *s = &base[OdtEntryAddr(e)];
+                do { *d++ = *s++; } while (--n); 
+            } 
+            else
+            {
+                memcpy((uint8_t*)d, &base[OdtEntryAddr(e)], n);
+                d += n;
+            }
+            e++;
+'''
+
+
+![trigger bench](image.png)
+
+
+
+## CalSeg::Sync
+
+
+![sync bench](image-1.png)

benches/xcp_benchmark.rs

@@ -1,7 +1,17 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+// cargo bench -- --save-baseline parking_lot
+// cargo bench -- --baseline parking_lot
+// cargo bench -- --save-baseline parking_lot
+// cargo bench -- --load-baseline new --baseline parking_lot
+// --warm-up-time 0
+// --nresamples <nresamples>
+//
+//
+
+#![allow(unused_assignments)]
+#![allow(unused_imports)]
 
-#[allow(unused_imports)]
 use log::{debug, error, info, trace, warn};
+
 use std::{
     fmt::Debug,
     sync::{Arc, Mutex},
@@ -11,10 +21,10 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 use xcp::*;
-use xcp_type_description::prelude::*;
-
 use xcp_client::xcp_client::*;
+use xcp_type_description::prelude::*;
 
+use criterion::{criterion_group, criterion_main, Criterion};
 //-----------------------------------------------------------------------------
 // Calibration parameters
 
@@ -112,8 +122,15 @@ async fn xcp_client(dest_addr: std::net::SocketAddr, local_addr: std::net::Socke
             match current_mode {
                 ClientMode::Measure => {
                     info!("Start Measurement");
-                    // Measurement of signal
-                    xcp_client.create_measurement_object("signal").expect("measurmeent signal not found");
+                    // Measurement signals
+                    xcp_client.create_measurement_object("signal1").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal2").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal3").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal4").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal5").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal6").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal7").expect("measurement signal not found");
+                    xcp_client.create_measurement_object("signal8").expect("measurement signal not found");
                     // Measure start
                     xcp_client.start_measurement().await.expect("could not start measurement");
                 }
@@ -209,11 +226,25 @@ fn xcp_benchmark(c: &mut Criterion) {
     let cal_page = xcp.create_calseg("CalPage", &CAL_PAGE, true);
 
     // Measurement signal
-    let mut signal: f64 = 0.0;
+    let mut signal1: u32 = 0;
+    let mut signal2: u64 = 0;
+    let mut signal3: u8 = 0;
+    let mut signal4: u16 = 0;
+    let mut signal5: u64 = 0;
+    let mut signal6: u32 = 0;
+    let mut signal7: u16 = 0;
+    let mut signal8: u64 = 0;
 
     // Register a measurement event and bind it to the counter signal
     let event = daq_create_event!("mainloop");
-    daq_register!(signal, event);
+    daq_register!(signal1, event);
+    daq_register!(signal2, event);
+    daq_register!(signal3, event);
+    daq_register!(signal4, event);
+    daq_register!(signal5, event);
+    daq_register!(signal6, event);
+    daq_register!(signal7, event);
+    daq_register!(signal8, event);
 
     // Wait a moment
     thread::sleep(Duration::from_millis(100));
@@ -247,17 +278,26 @@ fn xcp_benchmark(c: &mut Criterion) {
     thread::sleep(Duration::from_millis(100));
 
     // Bench measurement trigger
+    signal1 += 1;
+    signal2 += 1;
+    signal3 += 1;
+    signal4 += 1;
+    signal5 += 1;
+    signal6 += 1;
+    signal7 += 1;
+    signal8 += 1;
     info!("Start measurement bench");
+    let mut count: u32 = 0;
     *mode.lock() = ClientMode::Measure;
     c.bench_function("trigger", |b| {
         b.iter(|| {
-            signal += 1.0;
+            count += 1;
             event.trigger()
         })
     });
     *mode.lock() = ClientMode::Wait;
     thread::sleep(Duration::from_millis(100));
-    info!("Measurement bench done, count = {}", signal);
+    info!("Measurement bench done, count = {}", count);
 
     // Wait a moment
     thread::sleep(Duration::from_millis(100));

xcplib/src/xcpLite.c

@@ -893,9 +893,24 @@ static void XcpTriggerDaq(uint16_t daq, const uint8_t* base, uint64_t clock) {
 #ifdef XCP_ENABLE_PACKED_MODE
                 if (sc>1) n *= sc; // packed mode
 #endif
+
+              if (n==8) {
+                *(uint64_t*)d = *(uint64_t*)&base[OdtEntryAddr(e)];
+                d += 8;
+              }
+              else if (n==4) {
+                *(uint32_t*)d = *(uint32_t*)&base[OdtEntryAddr(e)];
+                d += 4;
+              }
+              else if (n<4) {
+                uint8_t *s = &base[OdtEntryAddr(e)];
+                do { *d++ = *s++; } while (--n); 
+              } else
+              {
                 memcpy((uint8_t*)d, &base[OdtEntryAddr(e)], n);
                 d += n;
-                e++;
+              }
+              e++;
             } // ODT entry
         }
         // Dynamic length

xcplib/src/xcpTlQueue.c

@@ -297,7 +297,7 @@ const uint8_t * XcpTlTransmitQueuePeekMsg( uint16_t* msg_len ) {
         assert(entry1->dlc<=XCPTL_MAX_DTO_SIZE); // Max DTO size
 
         if (gXcpTlQueue.overruns) { // Add the number of overruns
-            DBG_PRINTF3("XcpTlTransmitQueuePeekMsg: overruns=%u\n", gXcpTlQueue.overruns);
+            DBG_PRINTF4("XcpTlTransmitQueuePeekMsg: overruns=%u\n", gXcpTlQueue.overruns);
             gXcpTlQueue.ctr += gXcpTlQueue.overruns;
             gXcpTlQueue.overruns = 0;
         }