O(1) scheduler

include/lib/list.h

@@ -100,6 +100,24 @@ static inline list_node_t *list_pushback(list_t *list, void *data)
     return node;
 }
 
+/* Pushback list node into list */
+static inline void list_pushback_node(list_t *list, list_node_t *target)
+{
+    if (unlikely(!list || !target || target->next))
+        return;
+
+    target->next = list->tail;
+
+    /* Insert before tail sentinel */
+    list_node_t *prev = list->head;
+    while (prev->next != list->tail)
+        prev = prev->next;
+
+    prev->next = target;
+    list->length++;
+    return;
+}
+
 static inline void *list_pop(list_t *list)
 {
     if (unlikely(list_is_empty(list)))
@@ -134,6 +152,25 @@ static inline void *list_remove(list_t *list, list_node_t *target)
     return data;
 }
 
+/* Remove a node from list without freeing */
+static inline void list_remove_node(list_t *list, list_node_t *target)
+{
+    if (unlikely(!list || !target || list_is_empty(list)))
+        return;
+
+    list_node_t *prev = list->head;
+    while (prev->next != list->tail && prev->next != target)
+        prev = prev->next;
+
+    if (unlikely(prev->next != target))
+        return; /* node not found */
+
+    prev->next = target->next;
+    target->next = NULL;
+    list->length--;
+    return;
+}
+
 /* Iteration */
 
 /* Callback should return non-NULL to stop early, NULL to continue */

include/sys/task.h

@@ -86,6 +86,10 @@ typedef struct tcb {
 
     /* Stack Protection */
     uint32_t canary; /* Random stack canary for overflow detection */
+
+    /* State transition support */
+    /* Ready queue membership node (only one per task) */
+    list_node_t rq_node;
 } tcb_t;
 
 /* Kernel Control Block (KCB)
@@ -108,14 +112,24 @@ typedef struct {
     /* Timer Management */
     list_t *timer_list;      /* List of active software timers */
     volatile uint32_t ticks; /* Global system tick, incremented by timer */
+
+    /* Scheduling attribution */
+    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 */
+
+    /* System idle task */
+    list_node_t task_idle;
 } kcb_t;
 
 /* Global pointer to the singleton Kernel Control Block */
 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 \
@@ -288,6 +302,9 @@ uint64_t mo_uptime(void);
  */
 void _sched_block(queue_t *wait_q);
 
+/* Support mutex data structure */
+void _sched_block_mutex(list_t *waiters);
+
 /* Application Entry Point */
 
 /* The main entry point for the user application.
@@ -299,3 +316,20 @@ void _sched_block(queue_t *wait_q);
  * Returns 'true' to enable preemptive scheduling, or 'false' for cooperative
  */
 int32_t app_main(void);
+
+/* Initialize the idle task
+ *
+ * This function statically creates and initializes the idle task structure.
+ * It should be called once during system startup.
+ *
+ * The idle task is a permanent system task that runs when no other
+ * ready tasks exist. It is never enqueued into any ready queue and
+ * cannot be suspended, canceled, or priority modified.
+ *
+ * Only one idle task exists per hart. Its priority is fixed to the
+ * lowest level and its time slice is zero.
+ */
+void idle_task_init(void);
+
+/* Wake up and enqueue task into ready queue */
+void sched_wakeup_task(tcb_t *);

kernel/main.c

@@ -31,6 +31,13 @@ int32_t main(void)
     uint32_t entropy = read_csr(mcycle) ^ (uint32_t) _read_us();
     srand(entropy);
 
+    /* Initialize idle task */
+    /* Initialize the first current task as idle sentinel node.
+     * This ensures a valid entry point before any real task runs.
+     */
+    idle_task_init();
+    kcb->task_current = &kcb->task_idle;
+
     /* Initialize deferred logging system.
      * Must be done after heap init but before app_main() to ensure
      * application tasks can use thread-safe printf.
@@ -47,32 +54,23 @@ int32_t main(void)
     printf("Scheduler mode: %s\n",
            kcb->preemptive ? "Preemptive" : "Cooperative");
 
-    /* Verify that the application created at least one task.
-     * If 'kcb->task_current' is still NULL, it means mo_task_spawn was never
-     * successfully called.
-     */
-    if (!kcb->task_current)
-        panic(ERR_NO_TASKS);
-
     /* Save the kernel's context. This is a formality to establish a base
      * execution context before launching the first real task.
      */
     setjmp(kcb->context);
 
-    /* Launch the first task.
-     * 'kcb->task_current' was set by the first call to mo_task_spawn.
-     * This function transfers control and does not return.
+    /* Launch the first task (idle task), then scheduler will select highest
+     * priority task. This function transfers control and does not return.
      */
-    tcb_t *first_task = kcb->task_current->data;
-    if (!first_task)
-        panic(ERR_NO_TASKS);
+    tcb_t *idle = kcb->task_current->data;
+    idle->state = TASK_RUNNING;
 
     /* Mark scheduler as started - enables timer IRQ in NOSCHED_LEAVE.
      * Must be set before hal_dispatch_init() which enables preemption.
      */
     scheduler_started = true;
 
-    hal_dispatch_init(first_task->context);
+    hal_dispatch_init(idle->context);
 
     /* This line should be unreachable. */
     panic(ERR_UNKNOWN);

kernel/mutex.c

@@ -64,24 +64,6 @@ static bool remove_self_from_waiters(list_t *waiters)
     return false;
 }
 
-/* Atomic block operation with enhanced error checking */
-static void mutex_block_atomic(list_t *waiters)
-{
-    if (unlikely(!waiters || !kcb || !kcb->task_current ||
-                 !kcb->task_current->data))
-        panic(ERR_SEM_OPERATION);
-
-    tcb_t *self = kcb->task_current->data;
-
-    /* Add to waiters list */
-    if (unlikely(!list_pushback(waiters, self)))
-        panic(ERR_SEM_OPERATION);
-
-    /* Block and yield atomically */
-    self->state = TASK_BLOCKED;
-    _yield(); /* This releases NOSCHED when we context switch */
-}
-
 int32_t mo_mutex_init(mutex_t *m)
 {
     if (unlikely(!m))
@@ -162,7 +144,7 @@ int32_t mo_mutex_lock(mutex_t *m)
     }
 
     /* Slow path: mutex is owned, must block atomically */
-    mutex_block_atomic(m->waiters);
+    _sched_block_mutex(m->waiters);
 
     /* When we return here, we've been woken by mo_mutex_unlock()
      * and ownership has been transferred to us. */
@@ -283,7 +265,7 @@ int32_t mo_mutex_unlock(mutex_t *m)
             /* Validate task state before waking */
             if (likely(next_owner->state == TASK_BLOCKED)) {
                 m->owner_tid = next_owner->id;
-                next_owner->state = TASK_READY;
+                sched_wakeup_task(next_owner);
                 /* Clear any pending timeout since we're granting ownership */
                 next_owner->delay = 0;
             } else {

kernel/semaphore.c

@@ -176,7 +176,7 @@ void mo_sem_signal(sem_t *s)
         if (likely(awakened_task)) {
             /* Validate awakened task state consistency */
             if (likely(awakened_task->state == TASK_BLOCKED)) {
-                awakened_task->state = TASK_READY;
+                sched_wakeup_task(awakened_task);
                 should_yield = true;
             } else {
                 /* Task state inconsistency - this should not happen */