chess-vector-engine 0.5.1

Open source chess engine with hybrid vector-based position analysis, advanced tactical search, and NNUE neural network evaluation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use chess_vector_engine::core_evaluation::{CoreEvaluator, CacheStats};
use chess::Board;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::str::FromStr;

fn benchmark_core_evaluation(c: &mut Criterion) {
    // Test positions of varying complexity
    let test_positions = vec![
        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", // Starting position
        "rnbqkbnr/pppp1ppp/8/4p3/4P3/8/PPPP1PPP/RNBQKBNR w KQkq e6 0 2", // King's pawn opening
        "rnbqkb1r/pppp1ppp/5n2/4p3/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 4 3", // Italian game
        "r1bqkb1r/pppp1ppp/2n2n2/4p3/2B1P3/3P1N2/PPP2PPP/RNBQK2R b KQkq - 0 4", // Middle game
        "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1", // Endgame position
    ];

    let boards: Vec<Board> = test_positions
        .iter()
        .map(|fen| Board::from_str(fen).expect("Valid FEN"))
        .collect();

    // Benchmark without optimizations (fresh evaluator each time)
    c.bench_function("core_evaluation_without_cache", |b| {
        b.iter(|| {
            let mut evaluator = CoreEvaluator::new();
            
            // Add some training data
            for (i, board) in boards.iter().enumerate() {
                evaluator.learn_from_position(board, i as f32 * 0.1);
            }
            
            // Evaluate all positions
            for board in &boards {
                black_box(evaluator.evaluate_position(board));
            }
        })
    });

    // Benchmark with optimizations (cached evaluator)
    c.bench_function("core_evaluation_with_cache", |b| {
        let mut evaluator = CoreEvaluator::new_with_cache_config(1000, 60);
        
        // Pre-populate with training data
        for (i, board) in boards.iter().enumerate() {
            evaluator.learn_from_position(board, i as f32 * 0.1);
        }
        
        b.iter(|| {
            // Evaluate all positions (should benefit from caching)
            for board in &boards {
                black_box(evaluator.evaluate_position(&board));
            }
        })
    });

    // Benchmark cache performance specifically
    c.bench_function("cache_hit_performance", |b| {
        let mut evaluator = CoreEvaluator::new_with_cache_config(1000, 60);
        
        // Pre-populate with training data and cache
        for (i, board) in boards.iter().enumerate() {
            evaluator.learn_from_position(board, i as f32 * 0.1);
            evaluator.evaluate_position(board); // Prime the cache
        }
        
        b.iter(|| {
            // These should all be cache hits
            for board in &boards {
                black_box(evaluator.evaluate_position(&board));
            }
        })
    });

    // Benchmark position encoding performance
    c.bench_function("position_encoding", |b| {
        let evaluator = CoreEvaluator::new();
        
        b.iter(|| {
            for board in &boards {
                // This tests the optimized position encoder
                let similarity_insights = evaluator.similarity_engine.find_strategic_insights(black_box(board));
                black_box(similarity_insights);
            }
        })
    });
}

fn benchmark_cache_management(c: &mut Criterion) {
    let boards: Vec<Board> = (0..100)
        .map(|i| {
            // Create varied positions by making random legal moves
            let fen = format!("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKB{}R w KQkq - 0 1", i % 2);
            Board::from_str(&fen).unwrap_or_else(|_| Board::default())
        })
        .collect();

    c.bench_function("cache_with_eviction", |b| {
        b.iter(|| {
            let mut evaluator = CoreEvaluator::new_with_cache_config(50, 1); // Small cache, short TTL
            
            // Force cache evictions by exceeding cache size
            for (i, board) in boards.iter().enumerate() {
                evaluator.learn_from_position(board, i as f32 * 0.01);
                black_box(evaluator.evaluate_position(board));
            }
            
            let stats = evaluator.get_cache_stats();
            black_box(stats);
        })
    });

    c.bench_function("cache_statistics", |b| {
        let mut evaluator = CoreEvaluator::new_with_cache_config(1000, 60);
        
        // Populate cache
        for (i, board) in boards.iter().enumerate() {
            evaluator.learn_from_position(board, i as f32 * 0.01);
            evaluator.evaluate_position(board);
        }
        
        b.iter(|| {
            let stats = evaluator.get_cache_stats();
            black_box(stats);
        })
    });
}

criterion_group!(
    benches,
    benchmark_core_evaluation,
    benchmark_cache_management
);
criterion_main!(benches);