Add disk space guard, shared cache toggle, binary rename

- Add ZS_NO_SHARED_CACHE env var to skip shared wheel cache
- Check available disk (<2GB free) before populating shared cache
- Add --no-deps to uv pip install for daemon-managed wheels
- Rename output binary to zerostart-linux-x86_64
- Add libc dep for statvfs disk space check
- Add DMTCP checkpoint experiment scripts (deferred feature)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lightsofapollo

crates/Cargo.lock

@@ -57,6 +57,9 @@ hex = "0.4"
 toml = "0.8"
 pyo3 = { version = "0.28", features = ["extension-module"], optional = true }
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 [features]
 default = []
 iouring = ["io-uring"]

crates/zs-fast-wheel/Cargo.toml

@@ -411,6 +411,7 @@ fn uv_install(venv: &std::path::Path, specs: &[String]) -> Result<()> {
     let mut args = vec![
         "pip".to_string(),
         "install".to_string(),
+        "--no-deps".to_string(),
         "--python".to_string(),
         python.display().to_string(),
     ];
@@ -776,31 +777,38 @@ async fn main() -> Result<()> {
             };
 
             if !plan.daemon_wheels.is_empty() {
+                let no_shared_cache = std::env::var("ZS_NO_SHARED_CACHE").is_ok();
+
                 // Check shared cache in parallel — restore cached wheels via hardlinks
-                let sp_for_cache = site_packages.clone();
-                let wheels_for_cache = plan.daemon_wheels.clone();
-                let cache_results: Vec<bool> = tokio::task::spawn_blocking(move || {
-                    use rayon::prelude::*;
-                    wheels_for_cache
-                        .par_iter()
-                        .map(|spec| restore_from_shared_cache(spec, &sp_for_cache))
-                        .collect()
-                })
-                .await?;
-
-                let mut uncached_wheels = Vec::new();
-                let mut cached_count = 0u32;
-
-                for (spec, was_cached) in plan.daemon_wheels.iter().zip(cache_results.iter()) {
-                    if *was_cached {
-                        cached_count += 1;
-                        if verbose {
-                            eprintln!("  {} (shared cache hit)", spec.distribution);
+                let (uncached_wheels, cached_count) = if no_shared_cache {
+                    (plan.daemon_wheels.clone(), 0u32)
+                } else {
+                    let sp_for_cache = site_packages.clone();
+                    let wheels_for_cache = plan.daemon_wheels.clone();
+                    let cache_results: Vec<bool> = tokio::task::spawn_blocking(move || {
+                        use rayon::prelude::*;
+                        wheels_for_cache
+                            .par_iter()
+                            .map(|spec| restore_from_shared_cache(spec, &sp_for_cache))
+                            .collect()
+                    })
+                    .await?;
+
+                    let mut uncached = Vec::new();
+                    let mut count = 0u32;
+
+                    for (spec, was_cached) in plan.daemon_wheels.iter().zip(cache_results.iter()) {
+                        if *was_cached {
+                            count += 1;
+                            if verbose {
+                                eprintln!("  {} (shared cache hit)", spec.distribution);
+                            }
+                        } else {
+                            uncached.push(spec.clone());
                         }
-                    } else {
-                        uncached_wheels.push(spec.clone());
                     }
-                }
+                    (uncached, count)
+                };
 
                 if verbose {
                     if cached_count > 0 {
@@ -843,13 +851,27 @@ async fn main() -> Result<()> {
                     }
 
                     // Populate shared cache for newly extracted wheels
-                    let sp_for_cache = site_packages.clone();
-                    tokio::task::spawn_blocking(move || {
-                        for spec in &wheels_to_cache {
-                            populate_shared_cache(spec, &sp_for_cache);
-                        }
-                    })
-                    .await?;
+                    // Skip if ZS_NO_SHARED_CACHE=1 or disk is tight (<2GB free)
+                    if std::env::var("ZS_NO_SHARED_CACHE").is_ok() {
+                        tracing::info!("Shared cache disabled via ZS_NO_SHARED_CACHE");
+                    } else {
+                        let sp_for_cache = site_packages.clone();
+                        tokio::task::spawn_blocking(move || {
+                            if let Ok(avail) = available_disk_mb(&sp_for_cache) {
+                                if avail < 2048 {
+                                    tracing::warn!(
+                                        "Skipping shared cache — only {}MB free",
+                                        avail
+                                    );
+                                    return;
+                                }
+                            }
+                            for spec in &wheels_to_cache {
+                                populate_shared_cache(spec, &sp_for_cache);
+                            }
+                        })
+                        .await?;
+                    }
                 }
             }
 
@@ -998,6 +1020,27 @@ async fn main() -> Result<()> {
     }
 }
 
+/// Check available disk space in MB for the filesystem containing `path`.
+fn available_disk_mb(path: &Path) -> Result<u64> {
+    #[cfg(unix)]
+    {
+        use std::ffi::CString;
+        let c_path = CString::new(path.to_string_lossy().as_bytes())
+            .context("invalid path for statvfs")?;
+        let mut stat: libc::statvfs = unsafe { std::mem::zeroed() };
+        let ret = unsafe { libc::statvfs(c_path.as_ptr(), &mut stat) };
+        if ret != 0 {
+            anyhow::bail!("statvfs failed");
+        }
+        Ok((stat.f_bavail as u64 * stat.f_frsize as u64) / (1024 * 1024))
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = path;
+        Ok(u64::MAX) // assume unlimited on non-unix
+    }
+}
+
 /// Recursively compute directory size in bytes.
 fn dir_size(path: &Path) -> u64 {
     if !path.exists() {

crates/zs-fast-wheel/src/main.rs

@@ -21,7 +21,10 @@ cd crates
 cargo zigbuild --target "$TARGET" --release -p zs-fast-wheel
 cd ..
 
-cp "crates/target/$TARGET/release/zs-fast-wheel" "$OUTDIR/zs-fast-wheel-linux-x86_64"
+cp "crates/target/$TARGET/release/zerostart" "$OUTDIR/zerostart-linux-x86_64"
+chmod +x "$OUTDIR/zerostart-linux-x86_64"
+# Also copy with old name for backwards compat
+cp "crates/target/$TARGET/release/zerostart" "$OUTDIR/zs-fast-wheel-linux-x86_64"
 chmod +x "$OUTDIR/zs-fast-wheel-linux-x86_64"
 
 echo ""

scripts/cross-compile.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+set -x
+
+pkill -f dmtcp_coordinator 2>/dev/null || true
+sleep 0.5
+
+rm -rf /tmp/ckpt_test
+mkdir -p /tmp/ckpt_test
+cd /tmp/ckpt_test
+
+# Start coordinator
+dmtcp_coordinator --daemon -p 7779 --exit-on-last 2>&1
+sleep 1
+
+# Launch a simple sleeping Python
+cat > /tmp/simple.py << 'EOF'
+import time, os
+print(f"PID={os.getpid()}, running...")
+time.sleep(999)
+EOF
+
+dmtcp_launch -p 7779 python3 /tmp/simple.py &
+DPID=$!
+sleep 3
+
+# Status
+echo "=== STATUS ==="
+dmtcp_command -p 7779 -s 2>&1
+
+# Checkpoint
+echo "=== CHECKPOINT ==="
+dmtcp_command -p 7779 -c 2>&1
+sleep 2
+
+# Find checkpoint files
+echo "=== CHECKPOINT FILES ==="
+find /tmp -maxdepth 3 -name "ckpt_*" 2>/dev/null
+find /tmp/ckpt_test -type f 2>/dev/null
+find /root -maxdepth 2 -name "ckpt_*" 2>/dev/null
+find / -maxdepth 3 -name "ckpt_*.dmtcp" 2>/dev/null | head -5
+ls -la /tmp/ckpt_test/ 2>/dev/null
+
+# Also check the gpu workspace
+find /gpu-cli-workspaces -maxdepth 3 -name "ckpt_*" 2>/dev/null | head -5
+
+# Kill
+dmtcp_command -p 7779 -k 2>&1 || true
+wait $DPID 2>/dev/null || true
+
+echo "=== DONE ==="