minot-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{minot_cli-0.5.0 → minot_cli-0.5.2}/Cargo.lock

@@ -527,6 +527,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bytesize"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3"
+
 [[package]]
 name = "camino"
 version = "1.2.2"
@@ -2487,9 +2493,10 @@ dependencies = [
 
 [[package]]
 name = "minot"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
+ "bytesize",
  "chrono",
  "clap",
  "clap_complete",
@@ -2583,7 +2590,7 @@ dependencies = [
 
 [[package]]
 name = "mt_bagread"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "camino",
@@ -2603,7 +2610,7 @@ dependencies = [
 
 [[package]]
 name = "mt_mtc"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "ariadne",
@@ -2616,7 +2623,7 @@ dependencies = [
 
 [[package]]
 name = "mt_net"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "rkyv 0.8.15",
@@ -2626,7 +2633,7 @@ dependencies = [
 
 [[package]]
 name = "mt_rat"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2641,7 +2648,7 @@ dependencies = [
 
 [[package]]
 name = "mt_sea"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2657,7 +2664,7 @@ dependencies = [
 
 [[package]]
 name = "mt_wind"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3781,7 +3788,7 @@ dependencies = [
 
 [[package]]
 name = "ratpub"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "async-trait",

{minot_cli-0.5.0 → minot_cli-0.5.2}/Cargo.toml

@@ -4,15 +4,13 @@ members = ["minot", "ratpub", "mt_bagread", "mt_mtc", "mt_sea", "mt_wind", "mt_n
 resolver = "3"
 
 [workspace.package]
-version = "0.5.0"
+version = "0.5.2"
 keywords = ["robotics"]
 license = "MIT OR Apache-2.0"
 repository = "https://codeberg.org/stelzo/minot"
 edition = "2024"
 authors = ["Christopher Sieh <stelzo@steado.de>"]
-categories = [
-  "science::robotics",
-]
+categories = ["science::robotics"]
 documentation = "https://uos.github.io/minot"
 homepage = "https://uos.github.io/minot"
 rust-version = "1.85"
@@ -30,12 +28,12 @@ exclude = [
 ]
 
 [workspace.dependencies]
-mt_sea = { path = "mt_sea", version = "0.5.0", default-features = false }
-ratpub = { path = "ratpub", version = "0.5.0" }
-mt_bagread = { path = "mt_bagread", version = "0.5.0" }
-mt_net = { path = "mt_net", version = "0.5.0" }
-mt_wind = { path = "mt_wind", version = "0.5.0" }
-mt_mtc = { path = "mt_mtc", version = "0.5.0" }
+mt_sea = { path = "mt_sea", version = "0.5.2" }
+ratpub = { path = "ratpub", version = "0.5.2" }
+mt_bagread = { path = "mt_bagread", version = "0.5.2" }
+mt_net = { path = "mt_net", version = "0.5.2" }
+mt_wind = { path = "mt_wind", version = "0.5.2" }
+mt_mtc = { path = "mt_mtc", version = "0.5.2" }
 
 # Tools
 anyhow = "1.0"
@@ -51,7 +49,7 @@ futures = "0.3.31"
 ratatui = "0.29.0"
 rosbag2-rs = "0.2.1"
 chrono = "0.4.40"
-tui-logger = "0.16.0" # out of date but needed for 1.85 compatibility
+tui-logger = "0.16.0"
 regex = "1.12"
 once_cell = "1.21"
 rust_decimal = "1.37.1"
@@ -64,6 +62,7 @@ serde_yml = "0.0.12"
 cdr = "0.2.4"
 rand = "0.8"
 cdr-encoding = "0.10"
+bytesize = "2.3"
 
 # IO
 futures-lite = "2.6"
@@ -97,10 +96,10 @@ ros2-interfaces-jazzy-rkyv = { version = "0.0.5", features = [
 roslibrust = { version = "0.18", features = ["ros1", "macro"] }
 
 [profile.release]
-lto = "fat"         # Link Time Optimization
-codegen-units = 1   # Slower compile times but compiler sees all generated code and can optimize over everything across modules. Also decreases binary size.
-strip = "symbols"   # Significantly reduce binary size
-opt-level = "s"     # Optimize for size but keep some performance
+lto = "fat"       # Link Time Optimization
+codegen-units = 1 # Slower compile times but compiler sees all generated code and can optimize over everything across modules. Also decreases binary size.
+strip = "symbols" # Significantly reduce binary size
+opt-level = "s"   # Optimize for size but keep some performance
 debug = 0
 
 [profile.colcon]

{minot_cli-0.5.0 → minot_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minot-cli
-Version: 0.5.0
+Version: 0.5.2
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{minot_cli-0.5.0 → minot_cli-0.5.2}/minot/Cargo.toml

@@ -38,6 +38,7 @@ clap_complete.workspace = true
 regex.workspace = true
 once_cell.workspace = true
 rust_decimal.workspace = true
+bytesize.workspace = true
 
 [[bin]]
 name = "minot"
@@ -47,12 +48,11 @@ path = "src/minot.rs"
 name = "minot-coord"
 path = "src/coord.rs"
 
-# Note: All following features only embed existing nodes that can be built and run separately through the network.
 [features]
-default = ["embed-coord", "shared-memory"]
+default = ["embed-coord"]
 
-# Enable shared memory for zero-copy transfer of large messages (same-machine only)
-shared-memory = ["mt_sea/shm", "mt_wind?/shared-memory"]
+# Experimental: Enable shared memory for zero-copy transfer of large messages (same-machine only)
+shm = ["mt_sea/shm", "mt_wind?/shm"]
 
 # Use the official C API for ROS2 publishing (r2r crate). Enable for maximum compatibility at the cost of needing an actively sourced ROS2 installation.
 embed-ros2-c = ["embed-ros2-c-turbine"]
@@ -77,6 +77,30 @@ embed-ros1-turbine = ["dep:mt_wind", "mt_wind/ros1-native"]
 embed-ratpub-turbine = ["dep:mt_wind", "mt_wind/ratpub"]
 
 [package.metadata.docs.rs]
-features = ["embed-coord", "embed-ratpub", "embed-ros1-native", "embed-ros2-c", "embed-ros2-c-humble", "embed-ros2-native"]
+features = [
+  "embed-coord",
+  "embed-ratpub",
+  "embed-ros1-native",
+  "embed-ros2-c",
+  "embed-ros2-c-humble",
+  "embed-ros2-native",
+]
 default-target = "x86_64-unknown-linux-gnu"
 rustdoc-args = ["--cfg", "docsrs"]
+
+[package.metadata.deb]
+name = "minot"
+section = "science"
+priority = "optional"
+assets = [
+  [
+    "target/release/minot",
+    "usr/bin/minot",
+    "755",
+  ],
+  [
+    "target/release/minot-coord",
+    "usr/bin/minot-coord",
+    "755",
+  ],
+]

{minot_cli-0.5.0 → minot_cli-0.5.2}/minot/src/app.rs

@@ -1892,7 +1892,7 @@ impl App {
                                 if wind_data.is_empty() {
                                     if bagmsgs.end_of_bag {
                                         // Truly no more data in bagfile - abort remaining actions
-                                        info!(
+                                        warn!(
                                             "reached end of bagfile with no more matching messages"
                                         );
                                         return;

{minot_cli-0.5.0 → minot_cli-0.5.2}/minot/src/coord.rs

@@ -700,7 +700,8 @@ pub fn get_clients(eval: &Evaluated) -> anyhow::Result<HashSet<String>> {
 pub async fn main() -> anyhow::Result<()> {
     mt_sea::init_logging();
 
-    let filepath = Args::parse().file;
+    let args = Args::parse();
+    let filepath = args.file;
 
     let eval = if let Some(fp) = filepath {
         let rules_file = std::fs::canonicalize(&fp)?;

{minot_cli-0.5.0 → minot_cli-0.5.2}/minot/src/minot.rs

@@ -39,12 +39,32 @@ const EMBED_RATPUB_TURBINE_NAME: &'static str = "embedded_ratpub_turbine";
 #[derive(Debug, Clone, Subcommand)]
 pub enum ServeCommand {}
 
+#[cfg(feature = "shm")]
+use bytesize::ByteSize;
+
 #[derive(Parser, Debug)]
 #[command(version, about, author, long_about = None)]
 /// Minot — A versatile toolset for debugging and verifying stateful robot perception software.
 pub(crate) struct Args {
     #[command(subcommand)]
     pub command: Commands,
+
+    /// Disable POSIX shared memory for zero-copy transfer.
+    /// SHM is enabled by default for better performance with large messages.
+    #[cfg(feature = "shm")]
+    #[arg(long, global = true)]
+    pub no_shm: bool,
+
+    /// Size of the shared memory buffer pool (e.g., "7mb", "64MiB", "1gb").
+    /// Default is 7MB which is within typical Linux /dev/shm limits.
+    #[cfg(feature = "shm")]
+    #[arg(long, global = true, default_value = "7mb", value_parser = parse_bytesize)]
+    pub shm_size: ByteSize,
+}
+
+#[cfg(feature = "shm")]
+fn parse_bytesize(s: &str) -> Result<ByteSize, String> {
+    s.parse::<ByteSize>().map_err(|e| e.to_string())
 }
 
 #[derive(Debug, Clone, Parser)]
@@ -115,8 +135,11 @@ async fn tui(path: PathBuf) -> Result<(), Box<dyn std::error::Error>> {
         Ok(log::LevelFilter::Info)
     }?;
     tui_logger::init_logger(log_level).unwrap();
-    // tui_logger::set_env_filter_from_string(&log_level);
     tui_logger::set_default_level(log_level);
+    tui_logger::set_level_for_target("zenoh", log::LevelFilter::Warn);
+    tui_logger::set_level_for_target("zenoh_transport", log::LevelFilter::Warn);
+    tui_logger::set_level_for_target("zenoh_link", log::LevelFilter::Warn);
+    tui_logger::set_level_for_target("zenoh_protocol", log::LevelFilter::Warn);
 
     #[cfg(feature = "embed-coord")]
     {
@@ -671,9 +694,11 @@ struct StdioLogger {
 
 impl log::Log for StdioLogger {
     fn enabled(&self, metadata: &log::Metadata) -> bool {
-        // We can filter levels here, but it's easier
-        // to just set the global `log::set_max_level`.
-        // This logger will respect that global level.
+        // Filter out verbose zenoh logs (only show warnings and errors)
+        let target = metadata.target();
+        if target.starts_with("zenoh") && metadata.level() > log::Level::Warn {
+            return false;
+        }
         metadata.level() <= log::max_level()
     }
 
@@ -704,7 +729,12 @@ fn init_stdio_logger(
 ) -> Result<(), log::SetLoggerError> {
     let logger = StdioLogger { sender };
     log::set_boxed_logger(Box::new(logger))?;
-    log::set_max_level(level);
+    // Respect RUST_LOG if set, otherwise use the provided default
+    let effective_level = std::env::var("RUST_LOG")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(level);
+    log::set_max_level(effective_level);
     Ok(())
 }
 
@@ -1346,6 +1376,17 @@ fn start_logging_thread(rx: std::sync::mpsc::Receiver<String>) {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
 
+    // Set SHM environment variables for mt_sea to read
+    // SHM is enabled by default, --no-shm disables it
+    // SAFETY: We're setting env vars at the start of main before spawning any threads
+    #[cfg(feature = "shm")]
+    unsafe {
+        if args.no_shm {
+            std::env::set_var("MINOT_SHM_DISABLED", "1");
+        }
+        std::env::set_var("MINOT_SHM_SIZE", args.shm_size.as_u64().to_string());
+    }
+
     match args.command {
         Commands::Tui(tui_args) => tui(tui_args.file).await,
         Commands::Serve => serve().await,

{minot_cli-0.5.0 → minot_cli-0.5.2}/minot/src/runner.rs

@@ -1,5 +1,5 @@
 use anyhow::anyhow;
-use log::{info, warn};
+use log::{debug, error, info, warn};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::process::Stdio;
@@ -8,6 +8,36 @@ use tokio::process::Command;
 
 type BoxError = Box<dyn std::error::Error>;
 
+/// Initialize a stderr logger for the runner process with a minimal format
+/// that pelorus can parse: `[LEVEL] target: message`
+fn init_runner_logger() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info,zenoh=warn"))
+        .format(|buf, record| {
+            use std::io::Write;
+            writeln!(
+                buf,
+                "[{}] {}: {}",
+                record.level(),
+                record.target(),
+                record.args()
+            )
+        })
+        .target(env_logger::Target::Stderr)
+        .init();
+}
+
+/// Re-emit a log record received from serve's JSON protocol at the correct level.
+fn forward_serve_log(level: &str, target: &str, message: &str) {
+    match level {
+        "ERROR" => error!(target: target, "{}", message),
+        "WARN" => warn!(target: target, "{}", message),
+        "INFO" => info!(target: target, "{}", message),
+        "DEBUG" => debug!(target: target, "{}", message),
+        "TRACE" => log::trace!(target: target, "{}", message),
+        _ => info!(target: target, "{}", message),
+    }
+}
+
 #[derive(Serialize, Debug)]
 #[serde(tag = "type")]
 #[allow(dead_code)]
@@ -58,6 +88,8 @@ struct ServerResponse {
 }
 
 pub async fn run(file_path: PathBuf, minot_path: PathBuf, sync: bool) -> Result<(), BoxError> {
+    init_runner_logger();
+
     let file_content = std::fs::read_to_string(&file_path)
         .map_err(|e| format!("Failed to read file {:?}: {}", file_path, e))?;
 
@@ -172,17 +204,17 @@ pub async fn run(file_path: PathBuf, minot_path: PathBuf, sync: bool) -> Result<
                     message,
                     target,
                 } => {
-                    println!("[{}] {}: {}", level, target, message);
+                    forward_serve_log(&level, &target, &message);
                 }
                 ServerMessage::CommandResponse(resp) => {
-                    info!("Received command response: {:?}", resp);
+                    debug!("Received command response: {:?}", resp);
                 }
                 ServerMessage::ServerReady => {
                     warn!("Received unexpected ServerReady");
                 }
             }
         } else {
-            print!("{}", line);
+            eprint!("{}", line);
         }
     }
 
@@ -222,18 +254,18 @@ where
                     message,
                     target,
                 } => {
-                    println!("[{}] {}: {}", level, target, message);
+                    forward_serve_log(level, target, message);
                 }
                 _ => {
                     if predicate(&msg) {
                         return Ok(msg);
                     } else {
-                        warn!("Ignored unexpected message while waiting: {:?}", msg);
+                        debug!("Ignored unexpected message while waiting: {:?}", msg);
                     }
                 }
             }
         } else {
-            print!("{}", line);
+            eprint!("{}", line);
         }
     }
 }

{minot_cli-0.5.0 → minot_cli-0.5.2}/mt_sea/Cargo.toml

@@ -15,7 +15,7 @@ exclude.workspace = true
 readme = "README.md"
 
 [features]
-default = ["shm"]
+default = []
 shm = ["zenoh/shared-memory"]
 
 [dependencies]

{minot_cli-0.5.0 → minot_cli-0.5.2}/mt_sea/src/client.rs

@@ -6,6 +6,8 @@ use mt_net::COMPARE_NODE_NAME;
 use rkyv::{api::high::from_bytes, to_bytes, util::AlignedVec};
 use zenoh::Wait;
 
+#[cfg(feature = "shm")]
+use std::sync::RwLock as StdRwLock;
 #[cfg(feature = "shm")]
 use zenoh::shm::{
     BlockOn, GarbageCollect, PosixShmProviderBackend, ShmProvider, ShmProviderBuilder,
@@ -20,13 +22,28 @@ pub type CoordSender = tokio::sync::broadcast::Sender<(Packet, Option<std::net::
 pub type RecvBuffer = HashMap<u32, Vec<(Vec<u8>, VariableType, String)>>;
 
 #[cfg(feature = "shm")]
-/// SHM buffer pool size (64 MB)
-const SHM_BUFFER_SIZE: usize = 64 * 1024 * 1024;
+/// Within typical Linux /dev/shm limits
+const DEFAULT_SHM_BUFFER_SIZE: usize = 7 * 1024 * 1024;
 
 #[cfg(feature = "shm")]
-/// Messages larger than this use SHM, smaller use network (8 KB threshold)
 const SHM_SIZE_THRESHOLD: usize = 8 * 1024;
 
+#[cfg(feature = "shm")]
+fn is_shm_enabled() -> bool {
+    !std::env::var("MINOT_SHM_DISABLED")
+        .map(|v| v == "1" || v.to_lowercase() == "true")
+        .unwrap_or(false)
+}
+
+/// Get SHM buffer size from environment variable, falling back to default
+#[cfg(feature = "shm")]
+fn get_shm_buffer_size() -> usize {
+    std::env::var("MINOT_SHM_SIZE")
+        .ok()
+        .and_then(|v| v.parse::<usize>().ok())
+        .unwrap_or(DEFAULT_SHM_BUFFER_SIZE)
+}
+
 /// Copy bytes into an aligned buffer for rkyv deserialization
 fn align_bytes(bytes: &[u8]) -> AlignedVec {
     let mut aligned = AlignedVec::with_capacity(bytes.len());
@@ -34,6 +51,13 @@ fn align_bytes(bytes: &[u8]) -> AlignedVec {
     aligned
 }
 
+/// SHM state with dynamic resizing capability
+#[cfg(feature = "shm")]
+struct ShmState {
+    provider: std::sync::Arc<ShmProvider<PosixShmProviderBackend>>,
+    capacity: usize,
+}
+
 pub struct Client {
     pub coordinator_receive: std::sync::Arc<std::sync::RwLock<Option<CoordSender>>>,
     pub coordinator_send:
@@ -42,14 +66,14 @@ pub struct Client {
     rm_rules_on_disconnect: bool,
     pub updated_raw_recv: tokio::sync::broadcast::Sender<u32>,
     pub raw_recv_buff: std::sync::Arc<std::sync::RwLock<RecvBuffer>>,
-    /// Dedicated channel for wind packets - uses MPSC to avoid race conditions.
-    /// Wind packets are forwarded here from the coordinator receiver and buffered until consumed.
     pub wind_receiver: std::sync::Arc<tokio::sync::Mutex<tokio::sync::mpsc::Receiver<Packet>>>,
     wind_sender: tokio::sync::mpsc::Sender<Packet>,
     session: std::sync::Arc<zenoh::Session>,
     domain_id: u16,
     #[cfg(feature = "shm")]
-    shm_provider: std::sync::Arc<ShmProvider<PosixShmProviderBackend>>,
+    shm_state: StdRwLock<Option<ShmState>>,
+    #[cfg(feature = "shm")]
+    shm_initialized: std::sync::atomic::AtomicBool,
 }
 
 impl std::fmt::Debug for Client {
@@ -62,7 +86,279 @@ impl std::fmt::Debug for Client {
     }
 }
 
+#[cfg(feature = "shm")]
+fn create_shm_provider(size: usize) -> Result<ShmState, String> {
+    match ShmProviderBuilder::default_backend(size).wait() {
+        Ok(provider) => Ok(ShmState {
+            provider: std::sync::Arc::new(provider),
+            capacity: size,
+        }),
+        Err(e) => Err(e.to_string()),
+    }
+}
+
+#[cfg(feature = "shm")]
+fn format_shm_error(err_str: &str, requested_size: usize) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        let shm_mb = requested_size / (1024 * 1024);
+        if err_str.contains("ENOMEM")
+            || err_str.contains("Cannot allocate")
+            || err_str.contains("No space")
+        {
+            format!(
+                "Insufficient shared memory. Requested {} bytes.\n\
+                Possible fixes:\n\
+                - Increase /dev/shm size: `sudo mount -o remount,size={}M /dev/shm`\n\
+                - Or set ulimit: `ulimit -l unlimited` (may require root)\n\
+                - Or add to /etc/fstab: `tmpfs /dev/shm tmpfs defaults,size={}M 0 0`\n\
+                - Or disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`",
+                requested_size,
+                shm_mb.max(16),
+                shm_mb.max(16)
+            )
+        } else if err_str.contains("EACCES") || err_str.contains("Permission denied") {
+            "Permission denied.\n\
+            Possible fixes:\n\
+            - Check /dev/shm permissions: `ls -la /dev/shm`\n\
+            - Ensure user has write access to /dev/shm\n\
+            - Or disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`"
+                .to_string()
+        } else {
+            format!(
+                "Error: {}\nTo disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`",
+                err_str
+            )
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        if err_str.contains("ENOMEM")
+            || err_str.contains("Cannot allocate")
+            || err_str.contains("No space")
+        {
+            format!(
+                "Insufficient shared memory. Requested {} bytes.\n\
+                Possible fixes:\n\
+                - Increase shmmax: `sudo sysctl -w kern.sysv.shmmax={}`\n\
+                - Increase shmall: `sudo sysctl -w kern.sysv.shmall={}`\n\
+                - Or disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`\n\
+                Note: macOS has stricter SHM limits than Linux.",
+                requested_size,
+                requested_size,
+                requested_size / 4096
+            )
+        } else if err_str.contains("EACCES") || err_str.contains("Permission denied") {
+            "Permission denied.\n\
+            Possible fixes:\n\
+            - Check System Preferences > Security & Privacy settings\n\
+            - Or disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`"
+                .to_string()
+        } else {
+            format!(
+                "Error: {}\nTo disable SHM: `--no-shm` or `MINOT_SHM_DISABLED=1`",
+                err_str
+            )
+        }
+    }
+}
+
 impl Client {
+    /// Get or create SHM provider, initializing on first call
+    #[cfg(feature = "shm")]
+    fn get_or_init_shm(&self) -> Option<std::sync::Arc<ShmProvider<PosixShmProviderBackend>>> {
+        if !is_shm_enabled() {
+            return None;
+        }
+
+        // Fast path: already initialized
+        if self
+            .shm_initialized
+            .load(std::sync::atomic::Ordering::Acquire)
+        {
+            return self
+                .shm_state
+                .read()
+                .ok()?
+                .as_ref()
+                .map(|s| s.provider.clone());
+        }
+
+        // Slow path: initialize
+        let mut state = self.shm_state.write().ok()?;
+        if state.is_none() {
+            let initial_size = get_shm_buffer_size();
+            match create_shm_provider(initial_size) {
+                Ok(shm_state) => {
+                    info!(
+                        "SHM enabled with initial buffer size: {} bytes",
+                        initial_size
+                    );
+                    *state = Some(shm_state);
+                    self.shm_initialized
+                        .store(true, std::sync::atomic::Ordering::Release);
+                }
+                Err(e) => {
+                    warn!(
+                        "Failed to create SHM provider: {}\nFalling back to network transport.",
+                        format_shm_error(&e, initial_size)
+                    );
+                    return None;
+                }
+            }
+        }
+        state.as_ref().map(|s| s.provider.clone())
+    }
+
+    /// Try to grow the SHM pool to accommodate a larger message
+    #[cfg(feature = "shm")]
+    fn try_grow_shm(
+        &self,
+        required_size: usize,
+    ) -> Option<std::sync::Arc<ShmProvider<PosixShmProviderBackend>>> {
+        let mut state = self.shm_state.write().ok()?;
+
+        let current_capacity = state.as_ref().map(|s| s.capacity).unwrap_or(0);
+
+        // Double the required size (like Vec growth strategy)
+        let new_capacity = (required_size * 2).max(current_capacity * 2);
+
+        debug!(
+            "Growing SHM pool from {} to {} bytes",
+            current_capacity, new_capacity
+        );
+
+        match create_shm_provider(new_capacity) {
+            Ok(new_state) => {
+                info!("SHM pool grown to {} bytes", new_capacity);
+                *state = Some(new_state);
+                state.as_ref().map(|s| s.provider.clone())
+            }
+            Err(e) => {
+                warn!(
+                    "Cannot grow SHM pool to {} bytes: {}\nFalling back to network transport for large messages.",
+                    new_capacity,
+                    format_shm_error(&e, new_capacity)
+                );
+                None
+            }
+        }
+    }
+
+    /// Get current SHM capacity
+    #[cfg(feature = "shm")]
+    fn shm_capacity(&self) -> usize {
+        self.shm_state
+            .read()
+            .ok()
+            .and_then(|s| s.as_ref().map(|state| state.capacity))
+            .unwrap_or(0)
+    }
+
+    /// Try to send via SHM with automatic pool growth. Returns:
+    /// - Some(Ok(())) if sent successfully via SHM
+    /// - Some(Err(e)) if there was an error during sending
+    /// - None if SHM is unavailable and caller should fall back to network
+    #[cfg(feature = "shm")]
+    #[allow(clippy::too_many_arguments)]
+    async fn try_shm_send(
+        &self,
+        total_len: usize,
+        id_bytes: &[u8; 4],
+        variable_type: VariableType,
+        padded_name: &[u8; 64],
+        data: &[u8],
+        data_key: &str,
+        id: u32,
+    ) -> Option<anyhow::Result<()>> {
+        // Get or initialize SHM provider
+        let mut shm_provider = self.get_or_init_shm()?;
+
+        // Try allocation, growing pool if needed (up to 2 attempts)
+        for attempt in 0..2 {
+            let shm_result = shm_provider
+                .alloc(total_len)
+                .with_policy::<BlockOn<GarbageCollect>>()
+                .await;
+
+            match shm_result {
+                Ok(mut shm_buf) => {
+                    // Copy data into SHM buffer
+                    shm_buf[0..4].copy_from_slice(id_bytes);
+                    shm_buf[4] = variable_type.into();
+                    shm_buf[5..69].copy_from_slice(padded_name);
+                    shm_buf[69..total_len].copy_from_slice(data);
+
+                    let shm_immut: zenoh::shm::ZShm = shm_buf.into();
+                    debug!("Sending {} bytes via SHM to {}", total_len, data_key);
+
+                    // Send with retry loop
+                    loop {
+                        let replies =
+                            match self.session.get(data_key).payload(shm_immut.clone()).wait() {
+                                Ok(r) => r,
+                                Err(e) => {
+                                    return Some(Err(anyhow!("Failed to send data query: {}", e)));
+                                }
+                            };
+
+                        match replies.recv_async().await {
+                            Ok(reply) => match reply.result() {
+                                Ok(_sample) => {
+                                    debug!(
+                                        "Sent data id {} to {} via SHM (ACK received)",
+                                        id, data_key
+                                    );
+                                    return Some(Ok(()));
+                                }
+                                Err(err) => {
+                                    let err_payload = err.payload().to_bytes();
+                                    let err_msg = String::from_utf8_lossy(&err_payload);
+                                    warn!("Receiver error for id {}: {}", id, err_msg);
+                                    tokio::task::yield_now().await;
+                                    continue;
+                                }
+                            },
+                            Err(_) => {
+                                tokio::task::yield_now().await;
+                                continue;
+                            }
+                        }
+                    }
+                }
+                Err(_) if attempt == 0 => {
+                    // First attempt failed - try to grow the pool
+                    let current_capacity = self.shm_capacity();
+                    if total_len > current_capacity {
+                        debug!(
+                            "Message ({} bytes) exceeds current SHM capacity ({} bytes), growing pool",
+                            total_len, current_capacity
+                        );
+                        if let Some(new_provider) = self.try_grow_shm(total_len) {
+                            shm_provider = new_provider;
+                            continue; // Retry with larger pool
+                        }
+                    }
+                    // Couldn't grow, fall back to network
+                    warn!(
+                        "SHM allocation failed for {} bytes, falling back to network transport",
+                        total_len
+                    );
+                    return None;
+                }
+                Err(_) => {
+                    // Second attempt also failed
+                    warn!(
+                        "SHM allocation failed after pool growth, falling back to network transport"
+                    );
+                    return None;
+                }
+            }
+        }
+        None
+    }
+
     pub async fn init(ship_kind: ShipKind, rm_rules_on_disconnect: bool) -> Self {
         let domain_id = get_domain_id();
         if domain_id > 0 {
@@ -76,14 +372,6 @@ impl Client {
             .expect("Failed to open Zenoh session");
         let session = std::sync::Arc::new(session);
 
-        #[cfg(feature = "shm")]
-        let shm_provider = {
-            let provider = ShmProviderBuilder::default_backend(SHM_BUFFER_SIZE)
-                .wait()
-                .expect("Failed to create SHM provider");
-            std::sync::Arc::new(provider)
-        };
-
         let (updated_raw_recv, _) = tokio::sync::broadcast::channel(100);
         let raw_recv_buff: std::sync::Arc<std::sync::RwLock<RecvBuffer>> =
             std::sync::Arc::new(std::sync::RwLock::new(HashMap::new()));
@@ -218,7 +506,9 @@ impl Client {
             session,
             domain_id,
             #[cfg(feature = "shm")]
-            shm_provider,
+            shm_state: StdRwLock::new(None),
+            #[cfg(feature = "shm")]
+            shm_initialized: std::sync::atomic::AtomicBool::new(false),
         }
     }
 
@@ -441,63 +731,22 @@ impl Client {
 
         #[cfg(feature = "shm")]
         if total_len >= SHM_SIZE_THRESHOLD {
-            // Try to allocate SHM buffer for zero-copy transfer
-            let shm_result = self
-                .shm_provider
-                .alloc(total_len)
-                .with_policy::<BlockOn<GarbageCollect>>()
-                .await;
-
-            if let Ok(mut shm_buf) = shm_result {
-                // Copy data into SHM buffer
-                shm_buf[0..4].copy_from_slice(&id_bytes);
-                shm_buf[4] = variable_type.into();
-                shm_buf[5..69].copy_from_slice(&padded_name);
-                shm_buf[69..total_len].copy_from_slice(&data);
-
-                // Convert to immutable SHM buffer (can be cloned for retries)
-                let shm_immut: zenoh::shm::ZShm = shm_buf.into();
-
-                debug!("Sending {} bytes via SHM to {}", total_len, data_key);
-
-                // Use query with SHM payload
-                loop {
-                    let replies = self
-                        .session
-                        .get(&data_key)
-                        .payload(shm_immut.clone())
-                        .wait()
-                        .map_err(|e| anyhow!("Failed to send data query: {}", e))?;
-
-                    match replies.recv_async().await {
-                        Ok(reply) => match reply.result() {
-                            Ok(_sample) => {
-                                debug!(
-                                    "Sent data id {} to {} via SHM (ACK received)",
-                                    id, data_key
-                                );
-                                return Ok(());
-                            }
-                            Err(err) => {
-                                let err_payload = err.payload().to_bytes();
-                                let err_msg = String::from_utf8_lossy(&err_payload);
-                                warn!("Receiver error for id {}: {}", id, err_msg);
-                                tokio::task::yield_now().await;
-                                continue;
-                            }
-                        },
-                        Err(_) => {
-                            tokio::task::yield_now().await;
-                            continue;
-                        }
-                    }
-                }
+            // Try SHM transfer with dynamic pool growth
+            if let Some(result) = self
+                .try_shm_send(
+                    total_len,
+                    &id_bytes,
+                    variable_type,
+                    &padded_name,
+                    &data,
+                    &data_key,
+                    id,
+                )
+                .await
+            {
+                return result;
             }
-            // Fall through to network transfer if SHM alloc failed
-            debug!(
-                "SHM allocation failed, falling back to network for {} bytes",
-                total_len
-            );
+            // If try_shm_send returns None, fall through to network
         }
 
         // Network transfer (small messages, SHM disabled, or SHM fallback)

{minot_cli-0.5.0 → minot_cli-0.5.2}/mt_wind/Cargo.toml

@@ -35,8 +35,8 @@ cdr-encoding.workspace = true
 ratpub = { workspace = true, optional = true }
 
 [features]
-default = ["ratpub", "shared-memory"]
-shared-memory = ["mt_sea/shm", "ratpub?/shared-memory"]
+default = ["ratpub"]
+shm = ["mt_sea/shm", "ratpub?/shm"]
 humble = ["mt_bagread/humble"]
 ros2-c = ["dep:r2r", "dep:ros2-interfaces-jazzy-serde"]
 ros2-native = ["dep:ros2-client", "dep:ros2-interfaces-jazzy-serde"]

{minot_cli-0.5.0 → minot_cli-0.5.2}/ratpub/Cargo.toml

@@ -28,8 +28,8 @@ ros2-interfaces-jazzy-rkyv.workspace = true
 futures-lite = { workspace = true, optional = true }
 
 [features]
-default = ["shared-memory"]
-shared-memory = ["mt_sea/shm"]
+default = []
+shm = ["mt_sea/shm"]
 smol = ["dep:futures-lite"]
 
 [[example]]