Add split_mix_64 utility

.gitignore

@@ -1,4 +1,6 @@
 .cache
+.DS_Store
 compile_commands.json
 outputs
 xorshift
+xorshift.dSYM

compile

@@ -6,4 +6,12 @@ CFLAGS="-g -Wall -Werror "
 XORSHIFT_SRC="xorshift.c ppm.c"
 XORSHIFT_OUT=xorshift
 
+echo "Cleaning outputs dir..."
+rm -rf "./outputs/*"
+
+echo -e "\nBuilding xorshift generators..."
 (set -x ; $CC $CFLAGS $XORSHIFT_SRC -o $XORSHIFT_OUT)
+
+echo -e "\nTesting xorshift generators..."
+./xorshift
+echo "Generated"

ppm.c

@@ -3,20 +3,21 @@
 #include <stdio.h>
 #include <string.h>
 
-void write_p6_ppm(const char *filepath, u64 width, u64 height, Pixel *data) {
+void write_p6_ppm(const char *filepath, Image *img) {
   FILE *fp = fopen(filepath, "wb");
   if (!fp) {
     return;
   }
 
   char header[1024] = {0};
-  sprintf(header, "P6\n%lu %lu\n255\n", width, height);
+  sprintf(header, "P6\n%llu %llu\n255\n", (unsigned long long)img->width,
+          (unsigned long long)img->height);
 
   u64 length = strlen(header);
   fwrite(&header, length, 1, fp);
 
-  u64 pixel_count = width * height;
-  fwrite(data, sizeof(Pixel), pixel_count, fp);
+  u64 pixel_count = img->width * img->height;
+  fwrite(img->data, sizeof(Pixel), pixel_count, fp);
 
   fclose(fp);
 }

ppm.h

@@ -6,4 +6,10 @@ typedef struct {
   u8 b;
 } Pixel;
 
-void write_p6_ppm(const char *filepath, u64 width, u64 height, Pixel *data);
+typedef struct {
+	u64 width;
+	u64 height;
+	Pixel *data;
+} Image;
+
+void write_p6_ppm(const char *filepath, Image *img);

xorshift.c

@@ -1,19 +1,32 @@
 #include "aliases.h"
 #include "ppm.h"
-#include <bits/time.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
+typedef struct {
+  u64 seed;
+} SplitMix64State;
+
 typedef struct {
   u64 x;
   u64 y;
   u64 z;
   u64 w;
-} XORShiftBasic;
+} XOR256State;
 
-u64 xor_shift_basic_generate(XORShiftBasic *state);
+typedef u64(RandGenFunc)(void *s);
+
+void test_xorshift_256(Image *img);
+u64 xorshift_256_generate(void *s);
+void test_xoshiro_256ss(Image *img);
+u64 xoshiro_256ss_generate(void *s);
+void test_xoshiro_256p(Image *img);
+u64 xoshiro_256p_generate(void *s);
+u64 rol64(u64 x, u64 bits);
+XOR256State init_xor_256_state();
+void write_image_data(Image *img, RandGenFunc *gen_rand, void *s);
+u64 split_mix_64(SplitMix64State *state);
 
 int main(int argc, char *argv[]) {
   struct timespec ts = {0};
@@ -21,37 +34,33 @@ int main(int argc, char *argv[]) {
 
   srand48(ts.tv_nsec);
 
-  XORShiftBasic state = {
-      .x = lrand48(),
-      .y = lrand48(),
-      .z = lrand48(),
-      .w = lrand48(),
-  };
-
   u64 w = 1024;
   u64 h = 1024;
   u64 length = w * h;
-
   Pixel data[length];
-  for (u64 y = 0; y < h; ++y) {
-    for (u64 x = 0; x < w; ++x) {
-      u64 i = y * w + x;
 
-      u8 pixel = xor_shift_basic_generate(&state) % UINT8_MAX;
-      data[i] = (Pixel){
-          .r = pixel,
-          .g = pixel,
-          .b = pixel,
-      };
-    }
-  }
+  Image img = {
+      .width = w,
+      .height = h,
+      .data = data,
+  };
 
-  write_p6_ppm("./outputs/xorshift.ppm", w, h, data);
+  test_xorshift_256(&img);
+  test_xoshiro_256ss(&img);
+  test_xoshiro_256p(&img);
 
   return EXIT_SUCCESS;
 }
 
-u64 xor_shift_basic_generate(XORShiftBasic *state) {
+void test_xorshift_256(Image *img) {
+  XOR256State state = init_xor_256_state();
+  write_image_data(img, xorshift_256_generate, (void *)&state);
+  write_p6_ppm("./outputs/xorshift256.ppm", img);
+}
+
+u64 xorshift_256_generate(void *s) {
+  XOR256State *state = (XOR256State *)s;
+
   u64 t = state->x ^ (state->x << 11);
 
   state->x = state->y;
@@ -61,3 +70,87 @@ u64 xor_shift_basic_generate(XORShiftBasic *state) {
 
   return state->w;
 }
+
+void test_xoshiro_256ss(Image *img) {
+  XOR256State state = init_xor_256_state();
+  write_image_data(img, xoshiro_256ss_generate, (void *)&state);
+  write_p6_ppm("./outputs/xoshiro256ss.ppm", img);
+}
+
+u64 xoshiro_256ss_generate(void *s) {
+  XOR256State *state = (XOR256State *)s;
+
+  const u64 result = rol64(state->z * 5, 7) * 9;
+  const u64 t = state->z << 17;
+
+  state->y ^= state->w;
+  state->x ^= state->z;
+  state->z ^= state->y;
+  state->w ^= state->x;
+
+  state->y ^= t;
+  state->x = rol64(state->x, 45);
+
+  return result;
+}
+
+void test_xoshiro_256p(Image *img) {
+  XOR256State state = init_xor_256_state();
+  write_image_data(img, xoshiro_256p_generate, (void *)&state);
+  write_p6_ppm("./outputs/xoshiro256p.ppm", img);
+}
+
+u64 xoshiro_256p_generate(void *s) {
+  XOR256State *state = (XOR256State *)s;
+
+  const u64 result = state->w + state->x;
+  const u64 t = state->z << 17;
+
+  state->y ^= state->w;
+  state->x ^= state->z;
+  state->z ^= state->y;
+  state->w ^= state->x;
+
+  state->y ^= t;
+  state->x = rol64(state->x, 45);
+
+  return result;
+}
+
+u64 rol64(u64 x, u64 bits) { return (x << bits) | (x >> (64 - bits)); }
+
+XOR256State init_xor_256_state() {
+  SplitMix64State sm64 = {.seed = lrand48()};
+
+  return (XOR256State){
+      .x = split_mix_64(&sm64),
+      .y = split_mix_64(&sm64),
+      .z = split_mix_64(&sm64),
+      .w = split_mix_64(&sm64),
+  };
+}
+
+void write_image_data(Image *img, RandGenFunc *gen_rand, void *s) {
+  for (u64 y = 0; y < img->height; ++y) {
+    for (u64 x = 0; x < img->width; ++x) {
+      u64 i = y * img->width + x;
+
+      u8 pixel = gen_rand(s) % UINT8_MAX;
+      img->data[i] = (Pixel){
+          .r = pixel,
+          .g = pixel,
+          .b = pixel,
+      };
+    }
+  }
+}
+
+u64 split_mix_64(SplitMix64State *state) {
+  state->seed += 0x9E3779B97f4A7C15;
+
+  u64 result = state->seed;
+  result = (result ^ (result >> 30)) * 0xBF58476D1CE4E5B9;
+  result = (result ^ (result >> 27)) * 0x94D049BB133111EB;
+
+  return result ^ (result >> 31);
+}