Refactor: Replace unbounded thread spawning with rayon parallel iterators (#300)

Several locations spawn unbounded threads during environment discovery,
which can cause thread exhaustion on systems with many conda
environments or symlinks.

## Changes

- **pet-conda/lib.rs**: `get_conda_environments()` now uses `par_iter()`
instead of spawning one thread per path
- **pet-conda/environment_locations.rs**:
`get_conda_environment_paths()` uses `par_iter()` for environment
enumeration
- **pet-homebrew/sym_links.rs**: `get_known_symlinks()` uses
`par_iter()` for symlink resolution

Added `rayon = "1.11.0"` to both crates.

## Before/After

```rust
// Before: unbounded thread spawning
let mut threads = vec![];
for path in paths {
    threads.push(thread::spawn(move || get_conda_environment_info(&path, &mgr)));
}
// join all...

// After: bounded parallel iteration via rayon
paths.par_iter()
    .filter_map(|path| get_conda_environment_info(path, manager))
    .collect()
```

`crates/pet/src/find.rs` left unchanged—it uses `thread::scope` with a
fixed number of locators/directories, which is already bounded.

<!-- START COPILOT ORIGINAL PROMPT -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Refactor: Consider using thread pool instead of unbounded
thread spawning</issue_title>
> <issue_description>## Summary
> Several locations spawn an unbounded number of threads during
environment discovery. On systems with many Python environments (e.g.,
many conda envs or large PATH), this could lead to thread exhaustion or
excessive context switching.
> 
> ## Affected Locations
> 
> ### 1. `crates/pet-conda/src/lib.rs` (lines 368-378)
> ```rust
> fn get_conda_environments(paths: &Vec<PathBuf>, manager:
&Option<CondaManager>) -> Vec<CondaEnvironment> {
>     let mut threads = vec![];
>     for path in paths {
>         let path = path.clone();
>         let mgr = manager.clone();
>         threads.push(thread::spawn(move || {
>             // ...
>         }));
>     }
>     // ...
> }
> ```
> 
> ### 2. `crates/pet-homebrew/src/sym_links.rs` (lines 33-55)
> ```rust
> let threads = symlinks
>     .iter()
>     .map(|symlink| {
>         std::thread::spawn(move || {
>             // ...
>         })
>     })
>     .collect::<Vec<_>>();
> ```
> 
> ### 3. `crates/pet/src/find.rs`
> Multiple `thread::scope` with spawns for each path/locator.
> 
> ## Proposed Solutions
> 
> ### Option 1: Use `rayon` for parallel iteration
> ```rust
> use rayon::prelude::*;
> 
> fn get_conda_environments(paths: &[PathBuf], manager:
&Option<CondaManager>) -> Vec<CondaEnvironment> {
>     paths.par_iter()
>         .filter_map(|path| get_conda_environment_info(path, manager))
>         .collect()
> }
> ```
> 
> ### Option 2: Use bounded thread pool
> ```rust
> use std::sync::mpsc;
> use threadpool::ThreadPool;
> 
> let pool = ThreadPool::new(num_cpus::get());
> for path in paths {
>     pool.execute(move || {
>         // ...
>     });
> }
> pool.join();
> ```
> 
> ### Option 3: Use `thread::scope` with chunking
> ```rust
> thread::scope(|s| {
>     for chunk in paths.chunks(num_cpus::get()) {
>         s.spawn(|| {
>             for path in chunk {
>                 // process path
>             }
>         });
>     }
> });
> ```
> 
> ## Benefits
> - Controlled parallelism based on CPU count
> - Better resource management
> - Avoid thread exhaustion on systems with hundreds of environments
> - `rayon` provides work-stealing for better load balancing
> 
> ## Considerations
> - `rayon` adds a dependency but is widely used and well-maintained
> - `thread::scope` (used in many places already) is good for structured
concurrency
> - The impact depends on typical environment counts
> 
> ## Priority
> Low - Current implementation works but could cause issues at
scale.</issue_description>
> 
> <agent_instructions>Fix the issue. See if the recommendation makes
sense and create a fix.</agent_instructions>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

- Fixes #288

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: karthiknadig <[email protected]>

Author: Copilot

Cargo.lock

@@ -19,6 +19,7 @@ regex = "1.10.4"
 pet-reporter = { path = "../pet-reporter" }
 env_logger = "0.10.2"
 yaml-rust2 = "0.8.1"
+rayon = "1.11.0"
 
 [features]
 ci = []

crates/pet-conda/Cargo.toml

@@ -9,6 +9,7 @@ use crate::{
 use log::trace;
 use pet_fs::path::{expand_path, norm_case};
 use pet_python_utils::platform_dirs::Platformdirs;
+use rayon::prelude::*;
 use std::{
     env, fs,
     path::{Path, PathBuf},
@@ -43,19 +44,11 @@ pub fn get_conda_environment_paths(
     env_paths.dedup();
     // For each env, check if we have a conda install directory in them and
     // & then iterate through the list of envs in the envs directory.
-    // let env_paths = vec![];
-    let mut threads = vec![];
-    for path in env_paths.iter().filter(|f| f.exists()) {
-        let path = path.clone();
-        threads.push(thread::spawn(move || get_environments(&path)));
-    }
-
-    let mut result = vec![];
-    for thread in threads {
-        if let Ok(envs) = thread.join() {
-            result.extend(envs);
-        }
-    }
+    let mut result: Vec<PathBuf> = env_paths
+        .par_iter()
+        .filter(|f| f.exists())
+        .flat_map(|path| get_environments(path))
+        .collect();
 
     result.sort();
     result.dedup();

crates/pet-conda/src/environment_locations.rs

@@ -18,6 +18,7 @@ use pet_core::{
     Locator, LocatorKind,
 };
 use pet_fs::path::norm_case;
+use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
@@ -380,24 +381,8 @@ fn get_conda_environments(
     paths: &Vec<PathBuf>,
     manager: &Option<CondaManager>,
 ) -> Vec<CondaEnvironment> {
-    let mut threads = vec![];
-    for path in paths {
-        let path = path.clone();
-        let mgr = manager.clone();
-        threads.push(thread::spawn(move || {
-            if let Some(env) = get_conda_environment_info(&path, &mgr) {
-                vec![env]
-            } else {
-                vec![]
-            }
-        }));
-    }
-
-    let mut envs: Vec<CondaEnvironment> = vec![];
-    for thread in threads {
-        if let Ok(mut result) = thread.join() {
-            envs.append(&mut result);
-        }
-    }
-    envs
+    paths
+        .par_iter()
+        .filter_map(|path| get_conda_environment_info(path, manager))
+        .collect()
 }

crates/pet-conda/src/lib.rs

@@ -18,3 +18,4 @@ lazy_static = "1.4.0"
 pet-core = { path = "../pet-core" }
 log = "0.4.21"
 regex = "1.10.4"
+rayon = "1.11.0"

crates/pet-homebrew/Cargo.toml

@@ -4,6 +4,7 @@
 use lazy_static::lazy_static;
 use pet_fs::path::resolve_symlink;
 use pet_python_utils::executable::find_executables;
+use rayon::prelude::*;
 use regex::Regex;
 use std::{
     fs,
@@ -30,32 +31,26 @@ pub fn get_known_symlinks(
     // Go through all the exes in all of the above bin directories and verify we have a list of all of them.
     // They too could be symlinks, e.g. we could have `/opt/homebrew/bin/python3` & also `/opt/homebrew/bin/python`
     // And possible they are all symlnks to the same exe.
-    let threads = symlinks
-        .iter()
-        .map(|symlink| {
-            let symlink = symlink.clone();
-            let known_symlinks = symlinks.clone();
-            std::thread::spawn(move || {
-                if let Some(bin) = symlink.parent() {
-                    let mut symlinks = vec![];
-                    for possible_symlink in find_executables(bin) {
-                        if let Some(symlink) = resolve_symlink(&possible_symlink) {
-                            if known_symlinks.contains(&symlink) {
-                                symlinks.push(possible_symlink);
-                            }
+    let known_symlinks = symlinks.clone();
+    let other_symlinks: Vec<PathBuf> = symlinks
+        .par_iter()
+        .flat_map(|symlink| {
+            if let Some(bin) = symlink.parent() {
+                find_executables(bin)
+                    .into_iter()
+                    .filter(|possible_symlink| {
+                        if let Some(resolved) = resolve_symlink(possible_symlink) {
+                            known_symlinks.contains(&resolved)
+                        } else {
+                            false
                         }
-                    }
-                    symlinks
-                } else {
-                    vec![]
-                }
-            })
+                    })
+                    .collect::<Vec<_>>()
+            } else {
+                vec![]
+            }
         })
-        .collect::<Vec<_>>();
-    let other_symlinks = threads
-        .into_iter()
-        .flat_map(|t| t.join().unwrap())
-        .collect::<Vec<_>>();
+        .collect();
     symlinks.extend(other_symlinks);
 
     symlinks.sort();