Make perf knobs configurable via env vars

- ZS_PARALLEL_DOWNLOADS (default 16, was hardcoded 8)
- ZS_EXTRACT_THREADS (default num_cpus*2, was num_cpus)
- ZS_CHUNK_MB (default 16MB, was hardcoded 8MB)
- Parallelize shared cache checks via rayon

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

Author: lightsofapollo

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

@@ -146,6 +146,24 @@ fn num_cpus() -> usize {
         .unwrap_or(4)
 }
 
+/// Read a usize env var with a default. Used for tuning knobs.
+fn env_usize(name: &str, default: usize) -> usize {
+    std::env::var(name)
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(default)
+}
+
+/// Parallel downloads (default 16). Set ZS_PARALLEL_DOWNLOADS to tune.
+fn configured_parallel_downloads() -> usize {
+    env_usize("ZS_PARALLEL_DOWNLOADS", 16)
+}
+
+/// Extraction threads (default num_cpus * 2). Set ZS_EXTRACT_THREADS to tune.
+fn configured_extract_threads() -> usize {
+    env_usize("ZS_EXTRACT_THREADS", num_cpus() * 2)
+}
+
 /// Compute the environment key (must match Python's _env_key).
 fn env_key(requirements: &[String]) -> String {
     let mut sorted = requirements.to_vec();
@@ -645,12 +663,23 @@ async fn main() -> Result<()> {
             };
 
             if !plan.daemon_wheels.is_empty() {
-                // Check shared cache — restore cached wheels via hardlinks, only download uncached
+                // 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 in &plan.daemon_wheels {
-                    if restore_from_shared_cache(spec, &site_packages) {
+                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);
@@ -676,10 +705,15 @@ async fn main() -> Result<()> {
                 }
 
                 if !uncached_wheels.is_empty() {
+                    let pd = configured_parallel_downloads();
+                    let et = configured_extract_threads();
+                    if verbose {
+                        eprintln!("Config: parallel_downloads={pd}, extract_threads={et}");
+                    }
                     let config = DaemonConfig {
                         site_packages: site_packages.clone(),
-                        parallel_downloads: 8,
-                        extract_threads: num_cpus(),
+                        parallel_downloads: pd,
+                        extract_threads: et,
                     };
 
                     let wheels_to_cache: Vec<WheelSpec> = uncached_wheels.clone();

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

@@ -36,13 +36,21 @@ const CD_SIGNATURE: u32 = 0x02014b50;
 /// Large file threshold — entries above this get their own Range request
 const LARGE_THRESHOLD: u64 = 1024 * 1024; // 1MB
 
-/// Target chunk size for batching small files into single Range requests
-const CHUNK_TARGET_BYTES: u64 = 8 * 1024 * 1024; // 8MB chunks
+/// Target chunk size for batching small files into single Range requests.
+/// Override with ZS_CHUNK_MB env var (default 16MB).
+fn chunk_target_bytes() -> u64 {
+    std::env::var("ZS_CHUNK_MB")
+        .ok()
+        .and_then(|v| v.parse::<u64>().ok())
+        .unwrap_or(16)
+        * 1024
+        * 1024
+}
 
 /// Stream-extract a wheel from a URL with overlapped download+decompress:
 /// 1. Range request the central directory (small, fast)
 /// 2. Parse entries to get file offsets and sizes
-/// 3. Group small files into contiguous chunks (~8MB each)
+/// 3. Group small files into contiguous chunks (ZS_CHUNK_MB, default 16MB)
 /// 4. Large files get individual Range requests
 /// 5. Download chunks in parallel, extract files from each chunk as it arrives
 pub async fn stream_extract_wheel(
@@ -151,7 +159,7 @@ pub async fn stream_extract_wheel(
 
 /// Group entries into chunks for efficient Range requests.
 /// Large files (>1MB) get their own chunk. Small files are batched
-/// into contiguous byte ranges up to CHUNK_TARGET_BYTES.
+/// into contiguous byte ranges up to chunk_target_bytes().
 fn build_chunks(entries: &[ZipEntry], total_size: u64) -> Vec<Chunk> {
     // Sort by file offset (entries are usually already sorted, but be safe)
     let mut sorted: Vec<&ZipEntry> = entries.iter().collect();
@@ -195,7 +203,7 @@ fn build_chunks(entries: &[ZipEntry], total_size: u64) -> Vec<Chunk> {
             current_end = entry_end;
             current_entries.push(entry.clone());
         } else if entry_start <= current_end + 4096
-            && (entry_end - current_start) < CHUNK_TARGET_BYTES
+            && (entry_end - current_start) < chunk_target_bytes()
         {
             // Contiguous and within chunk size — add to batch
             current_end = current_end.max(entry_end);