40ms -> 23ms, by inlining the neighbour calculation, also fixed the t…

…est suite

readme.md

@@ -16,6 +16,14 @@ Requires:
 
 - https://www.libsdl.org/
 
+### Running the tests
+
+`make test`
+
+Requires:
+
+- https://github.com/catchorg/Catch2
+
 ### Running a benchmark
 
 `make benchmark`

results/benchmark.txt

@@ -1,5 +1,5 @@
 ----------------------------------------------------------------------------
 Benchmark                                  Time             CPU   Iterations
 ----------------------------------------------------------------------------
-BM_NextBoard/min_time:5.000             38.6 ms         38.5 ms          181
-BM_RenderNextBoard/min_time:5.000       40.7 ms         40.7 ms          171
+BM_NextBoard/min_time:5.000             23.1 ms         23.1 ms          301
+BM_RenderNextBoard/min_time:5.000       25.3 ms         25.2 ms          275

src/board/generate.cpp

@@ -1,14 +1,14 @@
 #include "generate.h"
 #include "breeder.h"
 #include <filesystem>
+#include <memory>
 #include <random>
 #include <stdexcept>
-#include <memory>
 #include <tuple>
 
 Board randomBoard(int width, int height) {
-  auto board = std::shared_ptr<bool[]>(new bool[width*height]);
-  for (int i = 0; i < height*width; ++i)
+  auto board = std::shared_ptr<bool[]>(new bool[width * height]);
+  for (int i = 0; i < height * width; ++i)
     board[i] = rand() % 2;
   return {board, width, height};
 }
@@ -25,7 +25,7 @@ Board benchmarkBoard(int width, int height) {
         "Did not meet minimum height required for the benchmark board");
 
   srand(0);
-  auto board = std::shared_ptr<bool[]>(new bool[width*height]);
+  auto board = std::shared_ptr<bool[]>(new bool[width * height]);
   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x) {
       const int i = y * width + x;

src/board/generate.h

@@ -1,7 +1,10 @@
 #pragma once
 
 #include "board.h"
+#include <vector>
 
 Board randomBoard(int width, int height);
 
 Board benchmarkBoard(int width, int height);
+
+Board fromVector(std::vector<std::vector<bool>> board);

src/board/next.cpp

@@ -6,28 +6,6 @@
 #include <tuple>
 #include <vector>
 
-const NeighbourPositions getNeighbourPositions(const int px, const int py,
-                                               const int width,
-                                               const int height) {
-  NeighbourPositions positions = {};
-  int i = 0;
-  for (int y = -1; y <= 1; y++)
-    for (int x = -1; x <= 1; x++) {
-      if (y == 0 && x == 0)
-        continue;
-
-      auto xx = (px + x) % width;
-      if (xx < 0)
-        xx = xx + width;
-      auto yy = (py + y) % height;
-      if (yy < 0)
-        yy = yy + height;
-
-      positions[i++] = yy * width + xx;
-    }
-  return positions;
-}
-
 Board nextBoard(Board board) {
   const auto &[input, width, height] = board;
   if (height == 0)
@@ -43,17 +21,27 @@ Board nextBoard(Board board) {
 
       auto alive = input[i];
 
-      auto neighboursPositions = getNeighbourPositions(x, y, width, height);
       int neighboursCount = 0;
-      for (int n = 0; n < 8; n++) {
-        if (input[neighboursPositions[n]])
-          neighboursCount++;
-
-        // Optimisation (exit early if we know it's a dead cell)
-        if (neighboursCount > 3) {
-          break;
+      for (int y2 = -1; y2 <= 1; y2++)
+        for (int x2 = -1; x2 <= 1; x2++) {
+          if (y2 == 0 && x2 == 0)
+            continue;
+
+          auto xx = (x2 + x) % width;
+          if (xx < 0)
+            xx = xx + width;
+          auto yy = (y2 + y) % height;
+          if (yy < 0)
+            yy = yy + height;
+
+          if (input[yy * width + xx])
+            neighboursCount++;
+
+          // Optimisation (exit early if we know it's a dead cell)
+          if (neighboursCount > 3) {
+            break;
+          }
         }
-      }
 
       if (alive && (neighboursCount < 2 || neighboursCount > 3))
         output[i] = false;