Merge pull request #18 from ewohltman/update-benchmarks

Update benchmarks

Author: ewohltman

.github/workflows/rust.yml .github/workflows/ci.yml.github/workflows/rust.yml renamed to .github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Rust
+name: CI
 on:
   push:
     branches: [ "main" ]
@@ -18,5 +18,5 @@ jobs:
         run: cargo clippy
       - name: Run tests
         run: cargo test
-      - name: Build release binary
+      - name: Build binary
         run: cargo build --release

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "genetic-sudoku"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 authors = ["Eric Wohltman <eric.wohltman@gmail.com>", "Bart Massey <bart@cs.pdx.edu>"]
 repository = "https://github.com/ewohltman/genetic-sudoku"
@@ -20,5 +20,5 @@ rand_pcg = "0.9.0"
 criterion = "0.5.1"
 
 [[bench]]
-name = "sudoku"
+name = "benches"
 harness = false

Cargo.toml

@@ -79,7 +79,7 @@ The Sudoku boards in `boards/mantere-koljonen` are from:
 > Computational Intelligence (WCCI 2008), 1-6 June, Hong Kong, China, pages
 > 4054-4061.
 
-as made available [here](http://lipas.uwasa.fi/~timan/sudoku/).
+Made available [here](http://lipas.uwasa.fi/~timan/sudoku/).
 
 Thanks much to the authors for collecting these.
 

README.md

@@ -0,0 +1,104 @@
+#![warn(
+    clippy::all,
+    // clippy::restriction,
+    clippy::pedantic,
+    clippy::nursery,
+    clippy::cargo
+)]
+
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
+use genetic_sudoku::genetics;
+use genetic_sudoku::genetics::{GAParams, MAX_POPULATION};
+use genetic_sudoku::sudoku::{Board, Row};
+use rand::prelude::StdRng;
+use rand::{Rng, SeedableRng, rng};
+use rand_pcg::Pcg64Mcg;
+
+const BOARD_SIZE_4: usize = 4;
+
+const BOARD_SIZE_9: usize = 9;
+
+const GENERATION: usize = 0;
+
+const POPULATION: usize = 100;
+
+const SELECTION_RATE: f32 = 0.5;
+
+const MUTATION_RATE: f32 = 0.05;
+
+const BAD_BOARD: Board<4> = Board([
+    Row([1, 2, 3, 4]),
+    Row([1, 2, 3, 4]),
+    Row([1, 2, 3, 4]),
+    Row([1, 2, 3, 4]),
+]);
+
+const EASY_4: Board<4> = Board([
+    Row([1, 0, 0, 4]),
+    Row([0, 4, 1, 2]),
+    Row([2, 0, 4, 3]),
+    Row([4, 3, 0, 0]),
+]);
+
+fn bench_count_row_duplicates(c: &mut Criterion) {
+    c.bench_function("count_row_duplicates", |b| {
+        b.iter(|| black_box(BAD_BOARD).count_row_duplicates());
+    });
+}
+
+fn bench_count_box_duplicates(c: &mut Criterion) {
+    c.bench_function("count_box_duplicates", |b| {
+        b.iter(|| black_box(BAD_BOARD).count_box_duplicates());
+    });
+}
+
+fn bench_generate_initial_population(c: &mut Criterion) {
+    let params = GAParams::new(POPULATION, SELECTION_RATE, MUTATION_RATE, None);
+
+    c.bench_function("generate_initial_population", |b| {
+        b.iter(|| genetics::generate_initial_population::<BOARD_SIZE_9, MAX_POPULATION>(&params));
+    });
+}
+
+fn bench_run_simulation(c: &mut Criterion) {
+    let params = GAParams::new(POPULATION, SELECTION_RATE, MUTATION_RATE, None);
+    let population = genetics::generate_initial_population::<BOARD_SIZE_4, MAX_POPULATION>(&params);
+
+    c.bench_function("run_simulation", |b| {
+        b.iter(|| {
+            genetics::run_simulation::<BOARD_SIZE_4, MAX_POPULATION>(
+                &params,
+                GENERATION,
+                &EASY_4,
+                population.clone(),
+            )
+        });
+    });
+}
+
+fn bench_rng(c: &mut Criterion) {
+    let mut rng = rng();
+
+    c.bench_function("rng", |b| {
+        b.iter(|| black_box(&mut rng).random::<f32>());
+    });
+}
+
+fn bench_pcg64mcg(c: &mut Criterion) {
+    let mut rng = Pcg64Mcg::from_rng(&mut StdRng::from_os_rng());
+
+    c.bench_function("Pcg64Mcg", |b| {
+        b.iter(|| black_box(&mut rng).random::<f32>());
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_count_row_duplicates,
+    bench_count_box_duplicates,
+    bench_generate_initial_population,
+    bench_run_simulation,
+    bench_rng,
+    bench_pcg64mcg,
+);
+criterion_main!(benches);

benches/benches.rs

@@ -3,6 +3,7 @@
 use super::errors::NoSolutionFound;
 use super::sudoku::{Board, Row};
 use arrayvec::ArrayVec;
+use rand::prelude::StdRng;
 use rand::{Rng, SeedableRng, distr::Uniform};
 use rand_pcg::Pcg64Mcg;
 use rayon::iter::Zip;
@@ -77,8 +78,7 @@ pub fn generate_initial_population<const N: usize, const M: usize>(
 ) -> Vec<Board<N>> {
     let max_digit = u8::try_from(N).expect("digit size exceeds 255");
     let values_range = Uniform::new_inclusive(1, max_digit).expect("invalid value range");
-    let mut os_rng = rand::prelude::StdRng::from_os_rng();
-    let mut rng = Pcg64Mcg::from_rng(&mut os_rng);
+    let mut rng = Pcg64Mcg::from_rng(&mut StdRng::from_os_rng());
     let mut boards: Vec<Board<N>> = Vec::with_capacity(M);
 
     for _ in 0..params.population {
@@ -220,8 +220,7 @@ fn make_children<const N: usize, const M: usize>(
     (0..params.num_children_per_parent_pairs)
         .into_par_iter()
         .map(|_| {
-            let mut x = rand::prelude::StdRng::from_os_rng();
-            let mut rng = Pcg64Mcg::from_rng(&mut x);
+            let mut rng = Pcg64Mcg::from_rng(&mut StdRng::from_os_rng());
             let mut child: ArrayVec<Row<N>, N> = ArrayVec::new_const();
 
             for i in 0..N {

benches/sudoku.rs

@@ -13,8 +13,6 @@ use std::time::{Duration, Instant};
 // The board size for puzzles. Change this for larger or smaller boards.
 const BOARD_SIZE: usize = 9;
 
-const MAX_GENERATIONS: usize = 100_000;
-
 const TIMEOUT: u64 = 600;
 
 #[derive(Parser, Debug)]
@@ -97,7 +95,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 Err(no_solution_found) => {
                     generation += 1;
 
-                    if generation >= MAX_GENERATIONS || Instant::now().ge(&timeout) {
+                    if Instant::now().ge(&timeout) {
                         println!("Generation: {generation} | Duration: {:?}", now.elapsed());
 
                         return Err(no_solution_found.into());

src/genetics.rs

@@ -3,6 +3,9 @@
 use arrayvec::ArrayVec;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
+use std::fs;
+use std::io::{Error, ErrorKind};
+use std::path::Path;
 
 #[derive(Debug, Default)]
 struct Scorer {
@@ -198,16 +201,12 @@ impl<const N: usize> Board<N> {
     ///
     /// Fails if file is nonexistent, unreadable, or of the wrong size.
     #[inline]
-    pub fn read<P: AsRef<std::path::Path>>(path: P) -> Result<Self, std::io::Error> {
-        let board = std::fs::read_to_string(path)?;
-        let format_error =
-            || std::io::Error::new(std::io::ErrorKind::InvalidData, "malformed sudoku board");
+    pub fn read<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
+        let board = fs::read_to_string(path)?;
+        let format_error = || Error::new(ErrorKind::InvalidData, "malformed sudoku board");
         let dim = board.lines().next().ok_or_else(format_error)?.len();
         if dim != N {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                "wrong board size",
-            ));
+            return Err(Error::new(ErrorKind::InvalidData, "wrong board size"));
         }
         let mut board_array: [Row<N>; N] = [<Row<N>>::default(); N];
         let mut chars = board.chars();