Calculate load average of AI algorithm

Introduce the calculation of load average for mcts algorithm, taking the
active nodes in the current mcts exeuction context as calculation units.
The function "mcts_calc_load()" takes reference from the method of
counting cpu load average in linux kernel, the concept is EWMA.

Utilize EWMA to calculate the load average of MCTS algorithm so we can
know how much recources the algorithm context is consuming.

Author: vax-r

kmldrv-user.c

@@ -65,13 +65,16 @@ static void listen_keyboard_handler(void)
         case 16:
             read(attr_fd, buf, 6);
             buf[0] = (buf[0] - '0') ? '0' : '1';
-            read_attr = !read_attr;
+            read_attr ^= 1;
             write(attr_fd, buf, 6);
+            printf("Stopping to display the chess board...\n");
             break;
         case 17:
             read(attr_fd, buf, 6);
             buf[4] = '1';
+            read_attr = false;
             write(attr_fd, buf, 6);
+            printf("Stopping the kernel space tic-tac-toe game...\n");
             break;
         }
     }

mcts.c

@@ -1,11 +1,11 @@
+#include <linux/sched/loadavg.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 
 #include "game.h"
 #include "mcts.h"
 #include "util.h"
 // #include "wyhash.h"
-#include "xoroshiro.h"
 
 struct node {
     int move;
@@ -16,7 +16,7 @@ struct node {
     struct node *children[N_GRIDS];
 };
 
-static struct state_array xoro_obj;
+static struct mcts_info mcts_obj;
 
 static struct node *new_node(int move, char player, struct node *parent)
 {
@@ -125,7 +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);
+    xoro_jump(&(mcts_obj.xoro_obj));
     while (1) {
         int *moves = available_moves(temp_table);
         if (moves[0] == -1) {
@@ -136,7 +136,7 @@ static fixed_point_t simulate(char *table, char player)
         while (n_moves < N_GRIDS && moves[n_moves] != -1)
             ++n_moves;
         // int move = moves[wyhash64() % n_moves];
-        int move = moves[xoro_next(&xoro_obj) % n_moves];
+        int move = moves[xoro_next(&(mcts_obj.xoro_obj)) % n_moves];
         kfree(moves);
         temp_table[move] = current_player;
         char win;
@@ -157,7 +157,7 @@ static void backpropagate(struct node *node, fixed_point_t score)
     }
 }
 
-static void expand(struct node *node, char *table)
+static int expand(struct node *node, char *table)
 {
     int *moves = available_moves(table);
     int n_moves = 0;
@@ -167,12 +167,14 @@ static void expand(struct node *node, char *table)
         node->children[i] = new_node(moves[i], node->player ^ 'O' ^ 'X', node);
     }
     kfree(moves);
+    return n_moves;
 }
 
 int mcts(char *table, char player)
 {
     char win;
     struct node *root = new_node(-1, player, NULL);
+    mcts_obj.nr_active_nodes = 1;
     for (int i = 0; i < ITERATIONS; i++) {
         struct node *node = root;
         char temp_table[N_GRIDS];
@@ -190,7 +192,7 @@ int mcts(char *table, char player)
                 break;
             }
             if (node->children[0] == NULL)
-                expand(node, temp_table);
+                mcts_obj.nr_active_nodes += expand(node, temp_table);
             node = select_move(node);
             if (!node)
                 return -1;
@@ -210,7 +212,13 @@ int mcts(char *table, char player)
     return best_move;
 }
 
+unsigned long count_active_nodes(void)
+{
+    return mcts_obj.nr_active_nodes;
+}
+
 void mcts_init(void)
 {
-    xoro_init(&xoro_obj);
+    xoro_init(&(mcts_obj.xoro_obj));
+    mcts_obj.nr_active_nodes = 0;
 }

mcts.h

@@ -1,7 +1,15 @@
 #pragma once
 
+#include "xoroshiro.h"
+
 #define ITERATIONS 100000
 #define EXPLORATION_FACTOR fixed_sqrt(1U << (FIXED_SCALE_BITS + 1))
 
+struct mcts_info {
+    struct state_array xoro_obj;
+    int nr_active_nodes;
+};
+
+unsigned long count_active_nodes(void);
 int mcts(char *table, char player);
 void mcts_init(void);

simrupt.c

@@ -7,6 +7,7 @@
 #include <linux/interrupt.h>
 #include <linux/kfifo.h>
 #include <linux/module.h>
+#include <linux/sched/loadavg.h>
 #include <linux/slab.h>
 #include <linux/sysfs.h>
 #include <linux/version.h>
@@ -117,7 +118,7 @@ static DEFINE_MUTEX(consumer_lock);
  */
 static struct circ_buf fast_buf;
 
-
+static unsigned long mcts_avennode[3];
 static char table[N_GRIDS];
 
 /* Draw the board into draw_buffer */
@@ -191,6 +192,23 @@ static void drawboard_work_func(struct work_struct *w)
     wake_up_interruptible(&rx_wait);
 }
 
+static void mcts_calc_load(struct work_struct *w)
+{
+    unsigned long active_nodes;
+
+    active_nodes = count_active_nodes() * FIXED_1;
+    mcts_avennode[0] = calc_load(mcts_avennode[0], EXP_1, active_nodes);
+    mcts_avennode[1] = calc_load(mcts_avennode[1], EXP_5, active_nodes);
+    mcts_avennode[2] = calc_load(mcts_avennode[2], EXP_15, active_nodes);
+
+    int a = mcts_avennode[0] + (FIXED_1 / 200);
+    int b = mcts_avennode[1] + (FIXED_1 / 200);
+    int c = mcts_avennode[2] + (FIXED_1 / 200);
+
+    pr_info("kmldrv: [MCTS LoadAvg] %d.%02d %d.%02d %d.%02d\n", LOAD_INT(a),
+            LOAD_FRAC(a), LOAD_INT(b), LOAD_FRAC(b), LOAD_INT(c), LOAD_FRAC(c));
+}
+
 static char turn;
 static int finish;
 
@@ -271,6 +289,7 @@ static struct workqueue_struct *kmldrv_workqueue;
 static DECLARE_WORK(drawboard_work, drawboard_work_func);
 static DECLARE_WORK(ai_one_work, ai_one_work_func);
 static DECLARE_WORK(ai_two_work, ai_two_work_func);
+static DECLARE_WORK(mcts_calc_load_work, mcts_calc_load);
 
 /* Tasklet handler.
  *
@@ -301,6 +320,7 @@ static void game_tasklet_func(unsigned long __data)
         smp_wmb();
         queue_work(kmldrv_workqueue, &ai_two_work);
     }
+    queue_work(kmldrv_workqueue, &mcts_calc_load_work);
     queue_work(kmldrv_workqueue, &drawboard_work);
     tv_end = ktime_get();