Function perft 

pub fn perft(board: &mut Board, depth: u32) -> u64

Count the number of legal moves at each node to the given depth (perft).

This is the standard perft (performance test) function used to verify move-generator correctness against a reference engine.

Examples found in repository

examples/perft.rs (line 18)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: perft <fen> <depth>");
        std::process::exit(1);
    }

    let fen = &args[1];
    let depth: u32 = args[2]
        .parse()
        .expect("Depth must be a non-negative integer");

    match atomic_movegen::board::Board::from_fen(fen) {
        Ok(mut board) => {
            let nodes = atomic_movegen::perft(&mut board, depth);
            println!("{}", nodes);
        }
        Err(e) => {
            eprintln!("Error parsing FEN: {}", e);
            std::process::exit(1);
        }
    }
}

examples/perft_divide.rs (line 33)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: perft_divide <fen> <depth>");
        return;
    }
    let fen = &args[1];
    let depth: u32 = args[2].parse().unwrap_or(1);

    let mut board = Board::from_fen(fen).expect("Invalid FEN");

    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);
    moves
        .as_mut_slice()
        .sort_by_key(|m| (m.from_sq() as u16, m.to_sq() as u16));

    let mut total = 0u64;
    for &m in moves.as_slice() {
        let mut state = atomic_movegen::board::StateInfo::new();
        board.do_move(m, &mut state);
        let cnt = if depth <= 1 {
            1
        } else {
            perft(&mut board, depth - 1)
        };
        board.undo_move(m, &state);
        total += cnt;
        println!("{}{}: {}", sq_str(m.from_sq()), sq_str(m.to_sq()), cnt);
    }
    println!("\nNodes searched: {}", total);
}

examples/verify_perft.rs (line 181)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();

    // Parse optional max depth (first positional arg).
    let max_depth: u32 = if args.len() > 1 {
        args[1].parse().unwrap_or(6)
    } else {
        6
    };

    // Parse optional file path (second positional arg, or default).
    let path = if args.len() > 2 {
        &args[2]
    } else {
        "perft_values.md"
    };

    // Limit to 0 means "no limit".
    let max_depth = if max_depth == 0 { u32::MAX } else { max_depth };

    let cases = parse_perft_values(path);

    eprintln!(
        "=== Perft verification ===\n  Source:     {path}\n  Max depth:  {}\n  Test cases: {}\n",
        if max_depth == u32::MAX {
            "unlimited".to_string()
        } else {
            max_depth.to_string()
        },
        cases.len()
    );

    let mut passed = 0u64;
    let mut failed = 0u64;
    let mut detail_lines: Vec<String> = Vec::new();

    // Track timing for each test case.
    struct CaseTiming {
        number: usize,
        elapsed: std::time::Duration,
    }
    let mut timings: Vec<CaseTiming> = Vec::with_capacity(cases.len());
    let total_timer = Instant::now();

    for case in &cases {
        let mut board = match Board::from_fen(&case.fen) {
            Ok(b) => b,
            Err(e) => {
                detail_lines.push(format!(
                    "  Test #{}: INVALID FEN — {} ({})",
                    case.number, case.fen, e
                ));
                failed += 1;
                continue;
            }
        };

        // Determine which depths to actually run.
        let depths_to_test: Vec<(u32, u64)> = case
            .depths
            .iter()
            .copied()
            .filter(|(d, _)| *d <= max_depth)
            .collect();

        if depths_to_test.is_empty() {
            continue;
        }

        let mut ok = true;
        let case_timer = Instant::now();

        // Try each depth.
        for &(depth, expected) in &depths_to_test {
            let result = perft(&mut board, depth);
            if result != expected {
                detail_lines.push(format!(
                    "  Test #{} FAIL depth={}: expected {}, got {}",
                    case.number, depth, expected, result
                ));
                ok = false;
            }
        }

        let elapsed = case_timer.elapsed();
        timings.push(CaseTiming {
            number: case.number,
            elapsed,
        });

        if ok {
            passed += 1;
            // Print a compact one-liner with time.
            println!(
                "  Test #{:<4} PASS ({} depth{}) [{:.3} s]",
                case.number,
                depths_to_test.len(),
                if depths_to_test.len() == 1 { "" } else { "s" },
                elapsed.as_secs_f64(),
            );
        } else {
            failed += 1;
        }
    }

    let total_elapsed = total_timer.elapsed();

    // Print any failure detail lines.
    if !detail_lines.is_empty() {
        eprintln!("\n--- Failures ---");
        for line in &detail_lines {
            eprintln!("{line}");
        }
    }

    // Compute summary stats.
    let total_tests = passed + failed;
    let fast = timings.iter().min_by(|a, b| a.elapsed.cmp(&b.elapsed));
    let slow = timings.iter().max_by(|a, b| a.elapsed.cmp(&b.elapsed));
    let total_time: std::time::Duration = timings.iter().map(|t| t.elapsed).sum();
    let avg_time = if !timings.is_empty() {
        total_time / timings.len() as u32
    } else {
        std::time::Duration::ZERO
    };

    // Summary block.
    eprintln!();
    eprintln!("--- Summary ---");
    if let Some(f) = fast {
        eprintln!(
            "  Fastest:     Test #{} ({:.3} s)",
            f.number,
            f.elapsed.as_secs_f64()
        );
    }
    if let Some(s) = slow {
        eprintln!(
            "  Slowest:     Test #{} ({:.3} s)",
            s.number,
            s.elapsed.as_secs_f64()
        );
    }
    eprintln!("  Average:     {:.3} s per test", avg_time.as_secs_f64());
    eprintln!("  Total time:  {:.3} s", total_elapsed.as_secs_f64());
    eprintln!("  Result:      {passed}/{total_tests} passed, {failed}/{total_tests} failed");

    if failed > 0 {
        process::exit(1);
    }
}