Refactor scheduler to RR cursor-based O(1) design

Previously, the scheduler iterated through the global task list
(kcb->tasks) to find the next TASK_READY task, resulting in O(N)
selection time. This approach limited scalability and caused
inconsistent task rotation under heavy load.

The new scheduling process:
1. Check the ready bitmap and find the highest priority level.
2. Select the RR cursor node from the corresponding ready queue.
3. Advance the selected cursor node circularly.

Why RR cursor instead of pop/enqueue rotation:
- Fewer operations on the ready queue: compared to the pop/enqueue
  approach, which requires two function calls per switch, the RR
  cursor method only advances one pointer per scheduling cycle.
- Cache friendly: always accesses the same cursor node, improving
  cache locality on hot paths.
- Cycle deterministic: RR cursor design allows deterministic task
  rotation and enables potential future extensions such as cycle
  accounting or fairness-based algorithms.

This change introduces a fully O(1) scheduler design based on
per-priority ready queues and round-robin (RR) cursors. Each ready
queue maintains its own cursor, allowing the scheduler to select
the next runnable task in constant time.

Author: vicLin8712

include/sys/task.h

@@ -128,8 +128,6 @@ typedef struct {
 extern kcb_t *kcb;
 
 /* System Configuration Constants */
-#define SCHED_IMAX \
-    500 /* Safety limit for scheduler iterations to prevent livelock */
 #define MIN_TASK_STACK_SIZE \
     256 /* Minimum stack size to prevent stack overflow */
 #define TASK_CACHE_SIZE \

kernel/task.c

@@ -445,20 +445,20 @@ void sched_wakeup_task(tcb_t *task)
     }
 }
 
-/* Efficient Round-Robin Task Selection with O(n) Complexity
+/* Efficient Round-Robin Task Selection (Cursor-Based, O(1) Complexity)
  *
- * Selects the next ready task using circular traversal of the master task list.
+ * Selects the next ready task by advancing the per-priority round-robin
+ * cursor (rr_cursor) circularly using list API list_cnext().
  *
- * Complexity: O(n) where n = number of tasks
- * - Best case: O(1) when next task in sequence is ready
- * - Worst case: O(n) when only one task is ready and it's the last checked
- * - Typical case: O(k) where k << n (number of non-ready tasks to skip)
+ * Complexity: O(1)
+ * - Always constant-time selection, regardless of total task count.
+ * - No need to traverse the task list.
  *
  * Performance characteristics:
- * - Excellent for small-to-medium task counts (< 50 tasks)
- * - Simple and reliable implementation
- * - Good cache locality due to sequential list traversal
- * - Priority-aware time slice allocation
+ * - Ideal for systems with frequent context switches or many tasks.
+ * - Excellent cache locality: only touches nodes in the active ready queue.
+ * - Priority-aware: highest non-empty ready queue is chosen via bitmap lookup.
+ * - Each priority level maintains its own rr_cursor to ensure fair rotation.
  */
 uint16_t sched_select_next_task(void)
 {
@@ -471,31 +471,28 @@ uint16_t sched_select_next_task(void)
     if (current_task->state == TASK_RUNNING)
         current_task->state = TASK_READY;
 
-    /* Round-robin search: find next ready task in the master task list */
-    list_node_t *start_node = kcb->task_current;
-    list_node_t *node = start_node;
-    int iterations = 0; /* Safety counter to prevent infinite loops */
-
-    do {
-        /* Move to next task (circular) */
-        node = list_cnext(kcb->tasks, node);
-        if (!node || !node->data)
-            continue;
-
-        tcb_t *task = node->data;
+    /* Check out bitmap */
+    uint32_t bitmap = kcb->harts->ready_bitmap;
+    if (unlikely(!bitmap))
+        panic(ERR_NO_TASKS);
 
-        /* Skip non-ready tasks */
-        if (task->state != TASK_READY)
-            continue;
+    /* Find top priority ready queue */
+    int top_prio_level = 0;
+    for (; !(bitmap & 1U); top_prio_level++, bitmap >>= 1)
+        ;
 
-        /* Found a ready task */
-        kcb->task_current = node;
-        task->state = TASK_RUNNING;
-        task->time_slice = get_priority_timeslice(task->prio_level);
+    /* Advance top priority rr_cursor to next task node */
+    list_node_t **cursor = &kcb->harts->rr_cursors[top_prio_level];
+    list_t *rq = kcb->harts->ready_queues[top_prio_level];
+    if (unlikely(!rq || !*cursor))
+        panic(ERR_NO_TASKS);
 
-        return task->id;
+    kcb->task_current = *cursor;
+    *cursor = list_cnext(rq, *cursor);
+    ((tcb_t *) (kcb->task_current->data))->state = TASK_RUNNING;
 
-    } while (node != start_node && ++iterations < SCHED_IMAX);
+    if (kcb->task_current)
+        return ((tcb_t *) (kcb->task_current->data))->id;
 
     /* No ready tasks found - this should not happen in normal operation */
     panic(ERR_NO_TASKS);