Implement a new AI algorithm and fix atomic bug

Implement another AI algorithm which is negamax, also provide it's
helper package zobrist. However, we've shrink the size of
HASH_TABLE_SIZE or it'll be too large to be kmalloc().

The atomic variable "turn" was a wrong implementation which will cause
numerous error message in kernel space, so we change "turn" to the type
of "char" and use memory barrier and the macros "READ_ONCE()",
"WRITE_ONCE()" to provide the data consistency between different
processor.

Author: vax-r

Makefile

@@ -1,5 +1,5 @@
 TARGET = kmldrv
-kmldrv-objs = simrupt.o game.o mcts.o
+kmldrv-objs = simrupt.o game.o wyhash.o mcts.o negamax.o zobrist.o
 obj-m := $(TARGET).o
 
 KDIR ?= /lib/modules/$(shell uname -r)/build

game.h

@@ -30,7 +30,7 @@ typedef unsigned fixed_point_t;
 #define DRAW_SIZE (N_GRIDS + BOARD_SIZE)
 #define DRAWBUFFER_SIZE                                                 \
     ((BOARD_SIZE * (BOARD_SIZE + 1) << 1) + (BOARD_SIZE * BOARD_SIZE) + \
-     ((BOARD_SIZE << 1) + 1))
+     ((BOARD_SIZE << 1) + 1) + 1)
 
 extern const line_t lines[4];
 

negamax.c

@@ -0,0 +1,99 @@
+#include <linux/slab.h>
+#include <linux/sort.h>
+#include <linux/string.h>
+
+#include "game.h"
+#include "negamax.h"
+#include "util.h"
+#include "zobrist.h"
+
+#define MAX_SEARCH_DEPTH 6
+
+static int history_score_sum[N_GRIDS];
+static int history_count[N_GRIDS];
+
+static u64 hash_value;
+
+static int cmp_moves(const void *a, const void *b)
+{
+    int *_a = (int *) a, *_b = (int *) b;
+    int score_a = 0, score_b = 0;
+
+    if (history_count[*_a])
+        score_a = history_score_sum[*_a] / history_count[*_a];
+    if (history_count[*_b])
+        score_b = history_score_sum[*_b] / history_count[*_b];
+    return score_b - score_a;
+}
+
+static move_t negamax(char *table, int depth, char player, int alpha, int beta)
+{
+    if (check_win(table) != ' ' || depth == 0) {
+        move_t result = {get_score(table, player), -1};
+        return result;
+    }
+    zobrist_entry_t *entry = zobrist_get(hash_value);
+    if (entry)
+        return (move_t){.score = entry->score, .move = entry->move};
+
+    int score;
+    move_t best_move = {-10000, -1};
+    int *moves = available_moves(table);
+    int n_moves = 0;
+    while (n_moves < N_GRIDS && moves[n_moves] != -1)
+        ++n_moves;
+
+    sort(moves, n_moves, sizeof(int), cmp_moves, NULL);
+
+    for (int i = 0; i < n_moves; i++) {
+        table[moves[i]] = player;
+        hash_value ^= zobrist_table[moves[i]][player == 'X'];
+        if (!i)
+            score = -negamax(table, depth - 1, player == 'X' ? 'O' : 'X', -beta,
+                             -alpha)
+                         .score;
+        else {
+            score = -negamax(table, depth - 1, player == 'X' ? 'O' : 'X',
+                             -alpha - 1, -alpha)
+                         .score;
+            if (alpha < score && score < beta)
+                score = -negamax(table, depth - 1, player == 'X' ? 'O' : 'X',
+                                 -beta, -score)
+                             .score;
+        }
+        history_count[moves[i]]++;
+        history_score_sum[moves[i]] += score;
+        if (score > best_move.score) {
+            best_move.score = score;
+            best_move.move = moves[i];
+        }
+        table[moves[i]] = ' ';
+        hash_value ^= zobrist_table[moves[i]][player == 'X'];
+        if (score > alpha)
+            alpha = score;
+        if (alpha >= beta)
+            break;
+    }
+
+    kfree((char *) moves);
+    zobrist_put(hash_value, best_move.score, best_move.move);
+    return best_move;
+}
+
+void negamax_init(void)
+{
+    zobrist_init();
+    hash_value = 0;
+}
+
+move_t negamax_predict(char *table, char player)
+{
+    memset(history_score_sum, 0, sizeof(history_score_sum));
+    memset(history_count, 0, sizeof(history_count));
+    move_t result;
+    for (int depth = 2; depth <= MAX_SEARCH_DEPTH; depth += 2) {
+        result = negamax(table, depth, player, -100000, 100000);
+        zobrist_clear();
+    }
+    return result;
+}

negamax.h

@@ -0,0 +1,8 @@
+#pragma once
+
+typedef struct {
+    int score, move;
+} move_t;
+
+void negamax_init(void);
+move_t negamax_predict(char *table, char player);

simrupt.c

@@ -12,6 +12,7 @@
 
 #include "game.h"
 #include "mcts.h"
+#include "negamax.h"
 
 MODULE_LICENSE("Dual MIT/GPL");
 MODULE_AUTHOR("National Cheng Kung University, Taiwan");
@@ -147,7 +148,7 @@ static void simrupt_work_func(struct work_struct *w)
     wake_up_interruptible(&rx_wait);
 }
 
-static atomic_t turn;
+static char turn;
 
 static void ai_one_work_func(struct work_struct *w)
 {
@@ -159,23 +160,23 @@ static void ai_one_work_func(struct work_struct *w)
     WARN_ON_ONCE(in_softirq());
     WARN_ON_ONCE(in_interrupt());
 
-    int expect = 0;
-    atomic_read_acquire(&turn);
-    if (!atomic_try_cmpxchg(&turn, &expect, 1))
+    READ_ONCE(turn);
+    if (turn == 'X')
         return;
 
     cpu = get_cpu();
     pr_info("simrupt: [CPU#%d] start doing %s\n", cpu, __func__);
     tv_start = ktime_get();
     mutex_lock(&producer_lock);
-    int move = mcts(table, 'O');
+    int move;
+    WRITE_ONCE(move, mcts(table, 'O'));
 
     smp_mb();
 
     if (move != -1)
         WRITE_ONCE(table[move], 'O');
 
-    atomic_set_release(&turn, 1);
+    WRITE_ONCE(turn, 'X');
     mutex_unlock(&producer_lock);
     tv_end = ktime_get();
 
@@ -195,23 +196,23 @@ static void ai_two_work_func(struct work_struct *w)
     WARN_ON_ONCE(in_softirq());
     WARN_ON_ONCE(in_interrupt());
 
-    int expect = 1;
-    atomic_read_acquire(&turn);
-    if (!atomic_try_cmpxchg(&turn, &expect, 0))
+    READ_ONCE(turn);
+    if (turn == 'O')
         return;
 
     cpu = get_cpu();
     pr_info("simrupt: [CPU#%d] start doing %s\n", cpu, __func__);
     tv_start = ktime_get();
     mutex_lock(&producer_lock);
-    int move = mcts(table, 'X');
+    int move;
+    WRITE_ONCE(move, negamax_predict(table, 'X').move);
 
     smp_mb();
 
     if (move != -1)
         WRITE_ONCE(table[move], 'X');
 
-    atomic_set_release(&turn, 0);
+    WRITE_ONCE(turn, 'O');
     mutex_unlock(&producer_lock);
     tv_end = ktime_get();
 
@@ -443,8 +444,9 @@ static int __init simrupt_init(void)
         goto error_cdev;
     }
 
+    negamax_init();
     memset(table, ' ', N_GRIDS);
-    atomic_set_release(&turn, 0);
+    turn = 'O';
     /* Setup the timer */
     timer_setup(&timer, timer_handler, 0);
     atomic_set(&open_cnt, 0);

wyhash.c

@@ -0,0 +1,21 @@
+#include <linux/string.h>
+#include <linux/timer.h>
+
+#include "wyhash.h"
+
+static inline u64 wyhash64_stateless(u64 *seed)
+{
+    *seed += 0x60bee2bee120fc15;
+    u128 tmp;
+    tmp = (u128) *seed * 0xa3b195354a39b70d;
+    u64 m1 = (tmp >> 64) ^ tmp;
+    tmp = (u128) m1 * 0x1b03738712fad5c9;
+    u64 m2 = (tmp >> 64) ^ tmp;
+    return m2;
+}
+
+u64 wyhash64(void)
+{
+    u64 seed = (u64) ktime_to_ns(ktime_get());
+    return wyhash64_stateless(&seed);
+}

wyhash.h

@@ -1,19 +1,2 @@
-#include <linux/string.h>
-#include <linux/timer.h>
 
-static inline u64 wyhash64_stateless(u64 *seed)
-{
-    *seed += 0x60bee2bee120fc15;
-    u128 tmp;
-    tmp = (u128) *seed * 0xa3b195354a39b70d;
-    u64 m1 = (tmp >> 64) ^ tmp;
-    tmp = (u128) m1 * 0x1b03738712fad5c9;
-    u64 m2 = (tmp >> 64) ^ tmp;
-    return m2;
-}
-
-u64 wyhash64(void)
-{
-    u64 seed = (u64) ktime_to_ns(ktime_get());
-    return wyhash64_stateless(&seed);
-}
+u64 wyhash64(void);

zobrist.c

@@ -0,0 +1,66 @@
+#include <linux/slab.h>
+
+#include "wyhash.h"
+#include "zobrist.h"
+
+u64 zobrist_table[N_GRIDS][2];
+
+#define HASH(key) ((key) % HASH_TABLE_SIZE)
+
+static struct hlist_head *hash_table;
+
+void zobrist_init(void)
+{
+    int i;
+    for (i = 0; i < N_GRIDS; i++) {
+        zobrist_table[i][0] = wyhash64();
+        zobrist_table[i][1] = wyhash64();
+    }
+    hash_table =
+        kmalloc(sizeof(struct hlist_head) * HASH_TABLE_SIZE, GFP_KERNEL);
+    if (!hash_table) {
+        pr_info("simrupt: Failed to allocate space for hash_table\n");
+        return;
+    }
+    for (i = 0; i < HASH_TABLE_SIZE; i++)
+        INIT_HLIST_HEAD(&hash_table[i]);
+}
+
+zobrist_entry_t *zobrist_get(u64 key)
+{
+    unsigned long long hash_key = HASH(key);
+
+    if (hlist_empty(&hash_table[hash_key]))
+        return NULL;
+
+    zobrist_entry_t *entry = NULL;
+
+    hlist_for_each_entry (entry, &hash_table[hash_key], ht_list) {
+        if (entry->key == key)
+            return entry;
+    }
+    return NULL;
+}
+
+void zobrist_put(u64 key, int score, int move)
+{
+    unsigned long long hash_key = HASH(key);
+    zobrist_entry_t *new_entry = kmalloc(sizeof(zobrist_entry_t), GFP_KERNEL);
+    new_entry->key = key;
+    new_entry->move = move;
+    new_entry->score = score;
+    hlist_add_head(&new_entry->ht_list, &hash_table[hash_key]);
+}
+
+void zobrist_clear(void)
+{
+    for (int i = 0; i < HASH_TABLE_SIZE; i++) {
+        while (!hlist_empty(&hash_table[i])) {
+            zobrist_entry_t *entry =
+                hlist_entry(hash_table[i].first, zobrist_entry_t, ht_list);
+            hlist_del(&entry->ht_list);
+            kfree(entry);
+        }
+        INIT_HLIST_HEAD(&hash_table[i]);
+    }
+}

zobrist.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <linux/list.h>
+
+#include "game.h"
+
+#define HASH_TABLE_SIZE (100003)
+
+extern u64 zobrist_table[N_GRIDS][2];
+
+typedef struct {
+    u64 key;
+    int score;
+    int move;
+    struct hlist_node ht_list;
+} zobrist_entry_t;
+
+void zobrist_init(void);
+zobrist_entry_t *zobrist_get(u64 key);
+void zobrist_put(u64 key, int score, int move);
+void zobrist_clear(void);