Refine project for further improvements

Originally built to demonstrate Linux kernel facilities like tasklets
and kernel threads. Later ported the classical tic-tac-toe game engine
as a kernel module, enabling gaming among kernel threads. Now ready to
serve as a testbed codebase for further innovations.

Author: jserv

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (C) 2021, 2024 National Cheng Kung University, Taiwan.
+Copyright (C) 2024-2025 National Cheng Kung University, Taiwan.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,18 +1,18 @@
-TARGET = kmldrv
-kmldrv-objs = simrupt.o game.o wyhash.o xoroshiro.o mcts.o negamax.o zobrist.o
+TARGET = kxo
+kxo-objs = main.o game.o xoroshiro.o mcts.o negamax.o zobrist.o
 obj-m := $(TARGET).o
 
 ccflags-y := -std=gnu99 -Wno-declaration-after-statement
 KDIR ?= /lib/modules/$(shell uname -r)/build
 PWD := $(shell pwd)
 
 GIT_HOOKS := .git/hooks/applied
-all: kmod kmldrv-user
+all: kmod xo-user
 
-kmod: $(GIT_HOOKS) simrupt.c
+kmod: $(GIT_HOOKS) main.c
 	$(MAKE) -C $(KDIR) M=$(PWD) modules
 
-kmldrv-user: kmldrv-user.c
+xo-user: xo-user.c
 	$(CC) $(ccflags-y) -o $@ $<
 
 $(GIT_HOOKS):
@@ -22,4 +22,4 @@ $(GIT_HOOKS):
 
 clean:
 	$(MAKE) -C $(KDIR) M=$(PWD) clean
-	$(RM) kmldrv-user
+	$(RM) xo-user

README.md

@@ -1,72 +1,47 @@
-# KMLdrv: A device driver that performs tic-tac-toe game between kernel threads
+# kxo: A Tic-Tac-Toe Game Engine implemented as Linux kernel module
+
 ## Introduction
-`kmldrv` is a simple Linux kernel module which includes the concept of deferred
-work and kernel concepts as following:
-  - circular buffer
-  - mutex lock
-  - irq
-  - softirq
-  - tasklet
-  - workqueue
-  - kernel thread
+`kxo` is a Linux kernel module that implements the [tic-tac-toe game](https://en.wikipedia.org/wiki/Tic-tac-toe)
+(aka XO Game) as kernel threads.
+This educational module demonstrates several essential Linux kernel programming concepts:
+  - Circular buffer implementation
+  - Mutex lock synchronization
+  - IRQ handling
+  - SoftIRQ processing
+  - Tasklet scheduling
+  - Workqueue management
+  - Kernel thread creation and execution
 
-It can use different machine-learning algorithm and perform tic-tac-toe games between kernel threads. The demo video are in the link below:
- - [Kernel space tic-tac-toe game](https://www.youtube.com/watch?v=Y_xdLrDVGzk)
+The module supports multiple AI algorithms for game strategy, allowing kernel threads to compete against each other in tic-tac-toe matches.
+`kxo` implements two advanced algorithms for tic-tac-toe gameplay:
+- Monte Carlo Tree Search (MCTS): A probabilistic algorithm that uses random sampling to evaluate moves and determine optimal game strategies
+- Negamax Algorithm: A depth-first minimax variant that efficiently evaluates game positions by alternating between maximizing and minimizing players
 
-## Installation & Usage
-You can download the source code via the following command
-```
-$ git clone https://github.com/vax-r/KMLdrv.git
-```
+## Build and Run
 After the source code is downloaded, go into the directory and do as the following
 ```
 $ make
-make -C /lib/modules/6.5.0-28-generic/build M=/home/vax-r/linux2024/KMLdrv modules
-make[1]: Entering directory '/usr/src/linux-headers-6.5.0-28-generic'
-warning: the compiler differs from the one used to build the kernel
-  The kernel was built by: x86_64-linux-gnu-gcc-12 (Ubuntu 12.3.0-1ubuntu1~22.04) 12.3.0
-  You are using:           gcc-12 (Ubuntu 12.3.0-1ubuntu1~22.04) 12.3.0
-  CC [M]  /home/vax-r/linux2024/KMLdrv/simrupt.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/game.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/wyhash.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/xoroshiro.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/mcts.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/negamax.o
-  CC [M]  /home/vax-r/linux2024/KMLdrv/zobrist.o
-  LD [M]  /home/vax-r/linux2024/KMLdrv/kmldrv.o
-  MODPOST /home/vax-r/linux2024/KMLdrv/Module.symvers
-  CC [M]  /home/vax-r/linux2024/KMLdrv/kmldrv.mod.o
-  LD [M]  /home/vax-r/linux2024/KMLdrv/kmldrv.ko
-  BTF [M] /home/vax-r/linux2024/KMLdrv/kmldrv.ko
-make[1]: Leaving directory '/usr/src/linux-headers-6.5.0-28-generic'
-cc -std=gnu99 -Wno-declaration-after-statement -o kmldrv-user kmldrv-user.c
 ```
-Make sure the kernel object file is compiled correctly, then you can insert the kernel module
+
+Make sure the kernel object file (`kxo.ko`) is built correctly, then you can insert the kernel module
 ```
-$ sudo insmod kmldrv.ko
+$ sudo insmod kxo.ko
 ```
-Now you can enjoy the tic-tac-toe games performed between kernel threads through the following command
+
+`kxo` provides an interface for userspace interaction through the companion tool `kxo-user`.
+This utility offers the following functionality:
+- Display the current status of the `kxo` module (loaded/unloaded)
+- Real-time visualization of the tic-tac-toe game board
+- Control commands:
+  - `Ctrl + P`: Toggle pause/resume of the game board display
+  - `Ctrl + Q`: Terminate all tic-tac-toe games running in kernel space
+
+Simply run the command below after the kernel module is loaded:
 ```
-$ sudo ./kmldrv-user
+$ sudo ./kxo-user
 ```
-Enjoy the show !
-
-## Features
-### User space tool `kmldrv-user`
-`kmldrv` provide a interface for userspace program to interact with it, for example you can use the userspace tool `kmldrv-user`. It has the following ability
-- Display the status of `kmldrv`, to show whether its loaded or not
-- `Ctrl + P` : Stop/Resume the displaying of chess board
-- `Ctrl + Q` : Stop the tic-tac-toe games in kernel space
-### Machine Learning Algorithms
-Currently `kmldrv` supports two machine learning algorithms
-- Monte-Carlo Tree Search
-- Negamax AI Algorithm
-### PRNG support
-Currently `kmldrv` utilize two different PRNG (Pseudo-Random Number Generator) to generate random number
-- `xoroshift`
-- `wyhash`
 
 ## License
 
-`simrupt` is released under the MIT license. Use of this source code is governed
+`kxo` is released under the MIT license. Use of this source code is governed
 by a MIT-style license that can be found in the LICENSE file.

game.c

@@ -29,7 +29,7 @@ static char check_line_segment_win(const char *t, int i, int j, line_t line)
     return last;
 }
 
-char check_win(char *t)
+char check_win(const char *t)
 {
     for (int i_line = 0; i_line < 4; ++i_line) {
         line_t line = lines[i_line];

game.h

@@ -35,5 +35,5 @@ typedef unsigned fixed_point_t;
 extern const line_t lines[4];
 
 int *available_moves(const char *table);
-char check_win(char *t);
+char check_win(const char *t);
 fixed_point_t calculate_win_value(char win, char player);