Implement xoroshiro random number generator

Implementation of xoroshiro, another kind of PRNG. About the detailed
concept of the algorithm please refer to the paper "Scrambled Linear
Pseudorandom Number Generators".

We implement this algorithm in order to replace the wyhash algorithm
used in MCTS simulation step. Note that we're using the ++scrambler in
the xoro_next() function.

Author: vax-r

Makefile

@@ -1,5 +1,5 @@
 TARGET = kmldrv
-kmldrv-objs = simrupt.o game.o wyhash.o mcts.o negamax.o zobrist.o
+kmldrv-objs = simrupt.o game.o wyhash.o xoroshiro.o mcts.o negamax.o zobrist.o
 obj-m := $(TARGET).o
 
 ccflags-y := -std=gnu99 -Wno-declaration-after-statement

mcts.c

@@ -4,7 +4,8 @@
 #include "game.h"
 #include "mcts.h"
 #include "util.h"
-#include "wyhash.h"
+// #include "wyhash.h"
+#include "xoroshiro.h"
 
 struct node {
     int move;
@@ -15,6 +16,8 @@ struct node {
     struct node *children[N_GRIDS];
 };
 
+static struct state_array xoro_obj;
+
 static struct node *new_node(int move, char player, struct node *parent)
 {
     struct node *node = kzalloc(sizeof(struct node), GFP_KERNEL);
@@ -122,6 +125,7 @@ static fixed_point_t simulate(char *table, char player)
     char current_player = player;
     char temp_table[N_GRIDS];
     memcpy(temp_table, table, N_GRIDS);
+    xoro_jump(&xoro_obj);
     while (1) {
         int *moves = available_moves(temp_table);
         if (moves[0] == -1) {
@@ -131,7 +135,8 @@ static fixed_point_t simulate(char *table, char player)
         int n_moves = 0;
         while (n_moves < N_GRIDS && moves[n_moves] != -1)
             ++n_moves;
-        int move = moves[wyhash64() % n_moves];
+        // int move = moves[wyhash64() % n_moves];
+        int move = moves[xoro_next(&xoro_obj) % n_moves];
         kfree(moves);
         temp_table[move] = current_player;
         char win;
@@ -204,3 +209,8 @@ int mcts(char *table, char player)
     free_node(root);
     return best_move;
 }
+
+void mcts_init(void)
+{
+    xoro_init(&xoro_obj);
+}

mcts.h

@@ -3,4 +3,5 @@
 #define ITERATIONS 100000
 #define EXPLORATION_FACTOR fixed_sqrt(1U << (FIXED_SCALE_BITS + 1))
 
-int mcts(char *table, char player);
+int mcts(char *table, char player);
+void mcts_init(void);

simrupt.c

@@ -515,6 +515,7 @@ static int __init kmldrv_init(void)
     }
 
     negamax_init();
+    mcts_init();
     memset(table, ' ', N_GRIDS);
     turn = 'O';
     finish = 1;

xoroshiro.c

@@ -0,0 +1,52 @@
+
+#include "xoroshiro.h"
+
+static inline u64 rotl(const u64 x, int k)
+{
+    return (x << k) | (x >> (64 - k));
+}
+
+static inline void seed(struct state_array *obj, u64 s0, u64 s1)
+{
+    obj->array[0] = s0;
+    obj->array[1] = s1;
+}
+
+u64 xoro_next(struct state_array *obj)
+{
+    const u64 s0 = obj->array[0];
+    u64 s1 = obj->array[1];
+    const u64 result = rotl(s0 + s1, 24) + s0;
+
+    s1 ^= s0;
+    obj->array[0] = rotl(s0, 24) ^ s1 ^ (s1 << 16);
+    obj->array[1] = rotl(s1, 37);
+
+    return result;
+}
+
+void xoro_jump(struct state_array *obj)
+{
+    static const u64 JUMP[] = {0xdf900294d8f554a5, 0x170865df4b3201fc};
+
+    u64 s0 = 0;
+    u64 s1 = 0;
+    int i, b;
+    for (i = 0; i < sizeof(JUMP) / sizeof(*JUMP); i++) {
+        for (b = 0; b < 64; b++) {
+            if (JUMP[i] & (u64) (1) << b) {
+                s0 ^= obj->array[0];
+                s1 ^= obj->array[1];
+            }
+            xoro_next(obj);
+        }
+    }
+
+    obj->array[0] = s0;
+    obj->array[1] = s1;
+}
+
+void xoro_init(struct state_array *obj)
+{
+    seed(obj, 314159265, 1618033989);
+}

xoroshiro.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <linux/slab.h>
+
+struct state_array {
+    u64 array[2];
+};
+
+u64 xoro_next(struct state_array *obj);
+void xoro_jump(struct state_array *obj);
+void xoro_init(struct state_array *obj);