mirror of
https://github.com/subhobhai943/SUB-OS.git
synced 2026-10-25 16:52:29 +00:00
subhobhai943andClaude Opus 4.8
0a874341c6
Kernel threads were only ever switched cooperatively (sched_yield, task_exit); a thread that never yielded held the CPU forever. The Weave scheduler now preempts from the PIT tick, so CPU-bound threads are time-sliced. Deferred switch, not mid-handler: - sched_tick() no longer switches. It charges the running quantum and, when it is spent, only raises weave_need_resched. The switch happens at IRQ return in the new sched_preempt_on_return(), called from the x86_64 dispatcher after the PIC EOI. That keeps the tick path re-entrancy-safe (the EOI is already out, so the PIC keeps delivering) and lets the preempted thread unwind through the normal iretq on its own kernel stack. Interrupt-atomic scheduler state: - The plain weave_lock is not IRQ-safe, so a tick landing mid-mutation would deadlock. weave_lock sections now mask interrupts (arch_irq_save/restore, added to arch.h for all three arches) so the timer can never fire inside them, and weave_rotate holds them masked across the pick and the register swap so the switch is one indivisible step. Preemption-disable count: - sched_preempt_disable/enable gate the tick and the return-path switch so a preemptive switch cannot land while a plain (non-IRQ-safe) spinlock is held. printk wraps its critical section with it, closing the most common hazard; other locks are a documented follow-up. Fresh threads opt into interrupts at entry so they are preemptible from birth without changing the cooperative early-boot self-test, which still runs with interrupts masked and is unchanged (20 switches, 3/3 workers). Verified on x86_64 under QEMU: a new boot-time self-test arms preemption and two threads that NEVER yield are forced to share the CPU -- 20 involuntary switches, both advance and are woven down to the CPU-bound lanes -- then boot proceeds cleanly to ring-3 /sbin/init and the shell with zero faults. aarch64 and armv8i still build; preemption is wired into the x86_64 IRQ path only, so those stay cooperative for now (their switch asm already exists). Co-Authored-By: Claude Opus 4.8 <[email protected]> Claude-Session: https://claude.ai/code/session_0161Jh7uCEMLYEMNPsjC1LKf
61 lines
2.4 KiB
C
61 lines
2.4 KiB
C
#ifndef _KERNEL_SCHED_H
|
|
#define _KERNEL_SCHED_H
|
|
|
|
#include "task.h"
|
|
|
|
/*
|
|
* SUB-OS "Weave" scheduler
|
|
* ------------------------
|
|
* A distinctive tiered-rotation scheduler rather than a plain run queue. Every
|
|
* runnable task threads through one of WEAVE_NLANES priority lanes. The
|
|
* dispatcher always pulls from the lowest-numbered non-empty lane and rotates
|
|
* round-robin inside it, so latency-sensitive work stays near the front.
|
|
*
|
|
* The lane a task sits in is not fixed: a task that gives up the CPU
|
|
* voluntarily (sched_yield) is treated as interactive and woven UP a lane,
|
|
* while a task that burns its whole quantum and is preempted (sched_schedule)
|
|
* is woven DOWN. This lets throughput-bound threads and interactive threads
|
|
* coexist without either starving, and it is driven entirely by observed
|
|
* behaviour rather than a static nice value.
|
|
*
|
|
* The mechanism underneath is a real callee-saved context switch
|
|
* (sub_ctx_switch, per-arch assembly); this is genuine multitasking, not a
|
|
* state relabel.
|
|
*/
|
|
|
|
#define WEAVE_NLANES 4
|
|
|
|
void sched_init(void);
|
|
void sched_yield(void); /* voluntary: rewards the caller (woven up) */
|
|
void sched_schedule(void); /* involuntary/preemptive: caller woven down */
|
|
void sched_tick(void); /* timer hook: charges the running quantum */
|
|
void sched_add_task(task_t* task);
|
|
void sched_remove_task(task_t* task);
|
|
|
|
/* Let the currently-running context join or leave the run rotation. The kernel
|
|
* idle/boot thread uses these to briefly participate while it drives a batch
|
|
* of kernel threads to completion. */
|
|
void sched_join(void);
|
|
void sched_leave(void);
|
|
|
|
/* Arm or disarm preemptive switching from the timer tick. Cooperative
|
|
* switching (sched_yield / task_exit) always works; preemption is opt-in so
|
|
* early boot can run to completion deterministically. */
|
|
void sched_set_preempt(bool armed);
|
|
|
|
/* Preemption-disable count: code holding a plain (non-IRQ-safe) spinlock raises
|
|
* this so a preemptive switch cannot run while that lock is held. Nesting OK. */
|
|
void sched_preempt_disable(void);
|
|
void sched_preempt_enable(void);
|
|
|
|
/* Called from the arch IRQ dispatcher after the interrupt is acknowledged: if
|
|
* the timer tick asked for a reschedule and it is safe, switch away now. */
|
|
void sched_preempt_on_return(void);
|
|
|
|
/* Diagnostics + the boot-time self-tests (cooperative, then preemptive). */
|
|
void sched_dump(void);
|
|
void weave_selftest(void);
|
|
void weave_preempt_selftest(void);
|
|
|
|
#endif // _KERNEL_SCHED_H
|