restructured, flips working, benchmarking flips, got some basic terminal rendering

benches/generation.rs

@@ -0,0 +1,199 @@
+use std::hint::black_box;
+
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use othello::{board::BitBoard, game::Team};
+
+const JONS: [&str; 20] = [
+    "///3bw/3wb",
+    "///////6bw",
+    "///////wb",
+    "wwwwwwww/wwwwwwww/////",
+    "//1b2w/1bwwww/1bwbww/1bwwww/1b3/",
+    "///3bw/2bbw/3b//",
+    "///////bww",
+    "////bwwwww1b///",
+    "www/wbw/www////",
+    "///3b/2bwb/3b//",
+    "5bw//////",
+    "///////wb",
+    "7w/6b/5b",
+    "w/1b/2b",
+    "/////5w/6w/7b",
+    "/////2w/1w/b",
+    "b/w/w/w//b//",
+    "////bwwwww1b///",
+    "///3w///",
+    "///////",
+];
+
+const JON_NAMES: [&str; 20] = [
+    "starting_position",
+    "near_endgame",
+    "corner_setup_a1",
+    "white_dominance",
+    "complex_midgame",
+    "after_first_move",
+    "edge_capture",
+    "long_horizontal",
+    "surrounded_black",
+    "white_surrounded",
+    "corner_setup_h8",
+    "corner_setup_h1",
+    "diagonal_line",
+    "short_diagonal",
+    "anti_diagonal",
+    "anti_diagonal_short",
+    "vertical_capture",
+    "long_horizontal_alt",
+    "single_piece",
+    "empty_board",
+];
+
+fn bench_available_black(c: &mut Criterion) {
+    let mut group = c.benchmark_group("available_black");
+
+    for (i, jon) in JONS.iter().enumerate() {
+        let bb = BitBoard::from_jon(jon).expect("Valid JON");
+        group.bench_with_input(
+            BenchmarkId::new("position", JON_NAMES[i]),
+            &bb,
+            |b, board| {
+                b.iter(|| black_box(board.available(black_box(Team::Black))));
+            },
+        );
+    }
+
+    group.finish();
+}
+
+fn bench_available_white(c: &mut Criterion) {
+    let mut group = c.benchmark_group("available_white");
+
+    for (i, jon) in JONS.iter().enumerate() {
+        let bb = BitBoard::from_jon(jon).expect("Valid JON");
+        group.bench_with_input(
+            BenchmarkId::new("position", JON_NAMES[i]),
+            &bb,
+            |b, board| {
+                b.iter(|| black_box(board.available(black_box(Team::White))));
+            },
+        );
+    }
+
+    group.finish();
+}
+
+fn bench_available_both_teams(c: &mut Criterion) {
+    let mut group = c.benchmark_group("available_both_teams");
+
+    for (i, jon) in JONS.iter().enumerate() {
+        let bb = BitBoard::from_jon(jon).expect("Valid JON");
+        group.bench_with_input(
+            BenchmarkId::new("position", JON_NAMES[i]),
+            &bb,
+            |b, board| {
+                b.iter(|| {
+                    let black_moves = black_box(board.available(Team::Black));
+                    let white_moves = black_box(board.available(Team::White));
+                    black_box((black_moves, white_moves))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+fn bench_available_starting_only(c: &mut Criterion) {
+    let bb = BitBoard::default();
+
+    c.bench_function("starting_position_black", |b| {
+        b.iter(|| black_box(bb.available(black_box(Team::Black))));
+    });
+
+    c.bench_function("starting_position_white", |b| {
+        b.iter(|| black_box(bb.available(black_box(Team::White))));
+    });
+}
+
+fn bench_available_worst_case(c: &mut Criterion) {
+    // Positions that might be slower due to more pieces or complexity
+    let worst_cases = [
+        ("complex_midgame", "//1b2w/1bwwww/1bwbww/1bwwww/1b3/"),
+        ("white_dominance", "wwwwwwww/wwwwwwww/////"),
+        ("long_capture", "////bwwwww1b///"),
+    ];
+
+    let mut group = c.benchmark_group("available_worst_case");
+
+    for (name, jon) in worst_cases.iter() {
+        let bb = BitBoard::from_jon(jon).expect("Valid JON");
+        group.bench_with_input(BenchmarkId::new("black", name), &bb, |b, board| {
+            b.iter(|| black_box(board.available(Team::Black)));
+        });
+        group.bench_with_input(BenchmarkId::new("white", name), &bb, |b, board| {
+            b.iter(|| black_box(board.available(Team::White)));
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_available_best_case(c: &mut Criterion) {
+    // Positions that should be fast (empty board, single piece, etc.)
+    let best_cases = [
+        ("empty_board", "///////"),
+        ("single_piece", "///3w///"),
+        ("corner_only", "///////wb"),
+    ];
+
+    let mut group = c.benchmark_group("available_best_case");
+
+    for (name, jon) in best_cases.iter() {
+        let bb = BitBoard::from_jon(jon).expect("Valid JON");
+        group.bench_with_input(BenchmarkId::new("black", name), &bb, |b, board| {
+            b.iter(|| black_box(board.available(Team::Black)));
+        });
+        group.bench_with_input(BenchmarkId::new("white", name), &bb, |b, board| {
+            b.iter(|| black_box(board.available(Team::White)));
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_available_all_positions_sequential(c: &mut Criterion) {
+    let boards: Vec<BitBoard> = JONS
+        .iter()
+        .map(|jon| BitBoard::from_jon(jon).expect("Valid JON"))
+        .collect();
+
+    c.bench_function("all_positions_black_sequential", |b| {
+        b.iter(|| {
+            for board in &boards {
+                black_box(board.available(Team::Black));
+            }
+        });
+    });
+
+    c.bench_function("all_positions_white_sequential", |b| {
+        b.iter(|| {
+            for board in &boards {
+                black_box(board.available(Team::White));
+            }
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_available_black,
+    bench_available_white,
+    bench_available_both_teams,
+    bench_available_starting_only,
+    bench_available_worst_case,
+    bench_available_best_case,
+    bench_available_all_positions_sequential,
+);
+
+criterion_main!(benches);