I am attempting to do sequential and parallel dfs using stl multithreading. I have created a threadpool and I pass the tasks (processing a node) into that threadpool. Not only is it slower than the sequential, its execution time doesn’t change based on the threadcount passed in on construction. What am I doing wrong?

Also am I accidently coping things I shouldn’t?

New to Rust.

use std::sync::{Arc, Mutex};
use num_cpus;
use threadpool::ThreadPool as BaseThreadPool;

pub struct GraphMatrix {
    adjacency_matrix: Vec<Vec<bool>>,
}

pub fn process_node_dfs(node_index: usize, adjacency_matrix: Arc<Vec<Vec<bool>>>, pool: BaseThreadPool, result: Arc<Mutex<Vec<usize>>>, visited: Arc<Mutex<HashSet<usize>>>) {
    let edges = &adjacency_matrix[node_index];

    result.lock().unwrap().push(node_index);

    for neighbour_index in 0..edges.len() {
        let mut visitedGuard: std::sync::MutexGuard<HashSet<usize>> = visited.lock().unwrap();
        if visitedGuard.contains(&neighbour_index) {
            std::mem::drop(visitedGuard);
            continue;
        } 
        else {
            visitedGuard.insert(neighbour_index);
        }
        std::mem::drop(visitedGuard);

        let adjacency_matrix_clone: Arc<Vec<Vec<bool>>> = Arc::clone(&adjacency_matrix);
        let visited_clone = Arc::clone(&visited);
        let result_clone = Arc::clone(&result);
        pool.execute(move || process_node_dfs(neighbour_index, adjacency_matrix_clone, pool.clone(), result_clone, visited_clone));
    }
}
impl GraphMatrix {
    
    pub fn parallel_dfs(&self, start_node: usize) -> Vec<usize> {
        let mut result: Arc<Mutex<Vec<usize>>> = Arc::new(Mutex::new(Vec::new()));
        let mut visited: Arc<Mutex<HashSet<usize>>> = Arc::new(Mutex::new(HashSet::new()));
        let pool: BaseThreadPool =BaseThreadPool::new(6);
        
        visited.lock().unwrap().insert(start_node);
        
        let adjacency_matrix_clone: Arc<Vec<Vec<bool>>> = Arc::new(self.adjacency_matrix.clone()); // Terrible
        let pool_clone = Arc::clone(&pool);
        let visited_clone = Arc::clone(&visited);
        let result_clone = Arc::clone(&result);
        pool.execute({
            let pool = pool.clone(); 
            move || process_node_dfs(start_node, adjacency_matrix_clone, pool, result_clone, visited_clone)});
        pool.join();
    
        return result.lock().unwrap().clone();
    }
}