Add sched_t to kcb for O(1) scheduler support

Previously, the scheduler performed a linear search through the global
task list (kcb->tasks) to find the next TASK_READY task. This approach
limited scalability as the search iterations increased with the number
of tasks, resulting in higher scheduling latency.

To support an O(1) scheduler and improve extensibility, a sched_t
structure is introduced and integrated into kcb. The new structure
contains:

- ready_queues: Holds all runnable tasks, including TASK_RUNNING and
  TASK_READY. The scheduler selects tasks directly from these queues.
- ready_bitmap: Records the state of each ready queue. Using the bitmap,
  the scheduler can locate the highest-priority runnable task in O(1)
  time complexity.
- rr_cursors: Round-robin cursors that track the next task node in each
  ready queue. Each priority level maintains its own RR cursor. The top
  priority cursor is assigned to kcb->task_current, which is advanced
  circularly after each scheduling cycle.
- hart_id: Identifies the scheduler instance per hart (0 for single-hart
  configurations).
- task_idle: The system idle task, executed when no runnable tasks exist.

In the current design, kcb binds only one sched_t instance (hart0) for
single-hart systems, but this structure can be extended for multi-hart
scheduling in the future.

Author: vicLin8712

include/sys/task.h

@@ -84,6 +84,21 @@ typedef struct tcb {
     void *rt_prio; /* Opaque pointer for custom real-time scheduler hook */
 } tcb_t;
 
+/* Scheduler attribution */
+typedef struct sched {
+    uint8_t ready_bitmap; /* 8-bit priority bitmap */
+    list_t
+        *ready_queues[TASK_PRIORITY_LEVELS]; /* Separate queue per priority */
+    uint16_t queue_counts[TASK_PRIORITY_LEVELS]; /* O(1) size tracking */
+
+    /* Weighted Round-Robin State per Priority Level */
+    list_node_t *rr_cursors[TASK_PRIORITY_LEVELS]; /* Round-robin position */
+
+    /* Hart-Specific Data */
+    uint8_t hart_id; /* RISC-V hart identifier */
+
+} sched_t;
+
 /* Kernel Control Block (KCB)
  *
  * Singleton structure holding global kernel state, including task lists,
@@ -104,6 +119,9 @@ typedef struct {
     /* Timer Management */
     list_t *timer_list;      /* List of active software timers */
     volatile uint32_t ticks; /* Global system tick, incremented by timer */
+
+    /* per-hart scheduler management */
+    sched_t *harts;
 } kcb_t;
 
 /* Global pointer to the singleton Kernel Control Block */

kernel/task.c

@@ -15,6 +15,14 @@
 static int32_t noop_rtsched(void);
 void _timer_tick_handler(void);
 
+/* Hart scheduler */
+static sched_t hart0 = {
+    .ready_bitmap = 0,
+    .ready_queues = {NULL},
+    .rr_cursors = {NULL},
+    .hart_id = 0,
+};
+
 /* Kernel-wide control block (KCB) */
 static kcb_t kernel_state = {
     .tasks = NULL,
@@ -25,6 +33,7 @@ static kcb_t kernel_state = {
     .task_count = 0,
     .ticks = 0,
     .preemptive = true, /* Default to preemptive mode */
+    .harts = &hart0,    /* Initial hart */
 };
 kcb_t *kcb = &kernel_state;