more scheduler rewrite work

Author: ilobilo

kernel/interfaces/arch/aarch64/system/cpu.cppm

@@ -76,5 +76,10 @@ export namespace cpu
         return mrs<"tpidr_el0">();
     }
 
-    std::uintptr_t self_addr() { return read_el1_base(); }
+    std::uintptr_t self_addr()
+    {
+        std::uintptr_t addr;
+        asm volatile ("mrs %0, tpidr_el1; ldr %0, [%0]" : "=r"(addr) :: "memory");
+        return addr;
+    }
 } // export namespace cpu

kernel/interfaces/arch/aarch64/system/sched/arch.cppm

@@ -21,12 +21,9 @@ export namespace sched::arch
 
     thread_t *current_thread();
 
-    void context_switch(thread_t *prev, thread_t *next);
-
-    void init_thread(
-        thread_t *thread, std::uintptr_t ip, std::uintptr_t arg,
-        std::uintptr_t stack_top, bool is_kernel
-    );
+    void init_core(thread_t *initial);
+    void init_thread(thread_t *thread, std::uintptr_t ip, std::uintptr_t arg, bool is_kernel);
 
+    void context_switch(thread_t *prev, thread_t *next);
     [[noreturn]] void return_to_user(std::uintptr_t ip, std::uintptr_t stack);
 } // export namespace sched::arch

kernel/interfaces/arch/x86_64/system/cpu.cppm

@@ -228,7 +228,7 @@ export namespace cpu
 
     namespace gs
     {
-        std::uintptr_t read()
+        std::uintptr_t read_self()
         {
             std::uintptr_t addr;
             asm volatile ("mov %0, gs:[0]" : "=r"(addr) :: "memory");
@@ -245,20 +245,15 @@ export namespace cpu
             return msr::read(0xC0000102);
         }
 
-        void write_user(std::uintptr_t addr)
+        void write(std::uintptr_t addr)
         {
             msr::write(0xC0000101, addr);
         }
 
-        std::uintptr_t read_user()
+        std::uintptr_t read()
         {
             return msr::read(0xC0000101);
         }
-
-        bool is_set()
-        {
-            return read_user() != 0;
-        }
     } // namespace gs
 
     namespace fs
@@ -274,5 +269,5 @@ export namespace cpu
         }
     } // namespace gs
 
-    std::uintptr_t self_addr() { return gs::read(); }
+    std::uintptr_t self_addr() { return gs::read_self(); }
 } // export namespace cpu

kernel/interfaces/arch/x86_64/system/sched/arch.cppm

@@ -35,12 +35,9 @@ export namespace sched::arch
 
     thread_t *current_thread();
 
-    void context_switch(thread_t *prev, thread_t *next);
-
-    void init_thread(
-        thread_t *thread, std::uintptr_t ip, std::uintptr_t arg,
-        std::uintptr_t stack_top, bool is_kernel
-    );
+    void init_core(thread_t *initial);
+    void init_thread(thread_t *thread, std::uintptr_t ip, std::uintptr_t arg, bool is_kernel);
 
+    void context_switch(thread_t *prev, thread_t *next);
     [[noreturn]] void return_to_user(std::uintptr_t ip, std::uintptr_t stack);
 } // export namespace sched::arch

kernel/interfaces/system/sched/process.cppm

@@ -34,7 +34,6 @@ export namespace sched
     struct process_t
     {
         pid_t pid;
-        pid_t ppid;
 
         process_t *parent;
 
@@ -49,33 +48,33 @@ export namespace sched
         session_t *session;
 
         std::shared_ptr<vmm::vmspace> vmspace;
+
+        struct vfs_state
+        {
+            vfs::path root;
+            vfs::path cwd;
+            mode_t umask = static_cast<mode_t>(s_iwgrp | s_iwoth);
+        };
+        std::shared_ptr<vfs_state> vfs;
         std::shared_ptr<vfs::fdtable> fds;
 
+        std::shared_ptr<cred_t> cred;
+
+        std::shared_ptr<signal_action_t> sigactions;
+        signal_queue_t sigqueue;
+
         lib::locker<
             lib::map::flat_hash<
                 pid_t,
                 thread_t *
             >, lib::spinlock
         > threads;
 
-        std::atomic<std::size_t> alive_threads;
-
-        std::shared_ptr<cred_t> cred;
-
-        std::shared_ptr<signal_action_t> sigactions;
-        signal_queue_t sigqueue;
+        std::atomic<std::size_t> alive_threads = 0;
 
         int exit_code = 0;
         bool is_zombie = false;
 
-        struct vfs_state
-        {
-            vfs::path root;
-            vfs::path cwd;
-            mode_t umask = static_cast<mode_t>(s_iwgrp | s_iwoth);
-        };
-        std::shared_ptr<vfs_state> vfs;
-
         lib::spinlock lock;
     };
 

kernel/interfaces/system/sched/run_queue.cppm

@@ -36,49 +36,54 @@ namespace sched
 
 export namespace sched
 {
-    struct cfs_run_queue_t
+    struct run_queue_t
     {
+        lib::spinlock lock;
+
         lib::rbtree<
-            entity_t, &entity_t::hook,
+            thread_t, &thread_t::hook,
             compare<
-                entity_t,
+                thread_t,
                 std::uint64_t,
-                &entity_t::vruntime
+                &thread_t::vruntime
             >
         > queue;
 
-        entity_t *current;
-
         std::uint64_t total_weight;
         std::uint64_t _min_vruntime;
 
-        inline std::size_t num_entities() const
-        {
-            return queue.size();
-        }
+        std::size_t cpu_idx;
+        std::uint64_t nr_running;
 
-        cfs_run_queue_t()
-            : queue { }, current { nullptr }, total_weight { 0 }, _min_vruntime { 0 } { }
+        thread_t *current;
+        thread_t *idle;
 
-        // enqueue when entity becomes runnable
-        void enqueue(entity_t *entity);
-        // dequeue when entity leaves runnable state
-        void dequeue(entity_t *entity);
+        std::uint64_t nr_switches;
+
+        std::uint64_t load_update;
+        std::uint64_t load_active;
 
-        // pick the next entity to run (least amount of vruntime)
+        bool needs_resched;
+
+        // enqueue when thread becomes runnable
+        void enqueue(thread_t *thread);
+        // dequeue when thread leaves runnable state
+        void dequeue(thread_t *thread);
+
+        // pick the next thread to run (least amount of vruntime)
         // nullptr if empty
-        entity_t *pick_next();
+        thread_t *pick_next();
 
-        // update current entity vruntime
+        // update current thread vruntime
         void update_current(std::uint64_t now);
 
         // adjust vruntime
-        void adjust(entity_t *entity, bool initial);
+        void adjust(thread_t *thread, bool initial);
 
-        // check if current should be preempted with entity
-        bool check_preempt_wakeup(entity_t *entity);
+        // check if current should be preempted with thread
+        bool check_preempt_wakeup(thread_t *thread);
 
-        // calculate fair timeslice for an entity
+        // calculate fair timeslice for a thread
         std::uint64_t calc_timeslice(std::uint64_t weight);
 
         std::uint64_t calc_vruntime(
@@ -88,24 +93,4 @@ export namespace sched
 
         void update_min_vruntime();
     };
-
-    struct run_queue_t
-    {
-        lib::spinlock_preempt lock;
-
-        std::size_t cpu_idx;
-        std::uint64_t nr_running;
-
-        thread_t *current;
-        thread_t *idle;
-
-        cfs_run_queue_t cfs;
-
-        std::uint64_t nr_switches;
-
-        std::uint64_t load_update;
-        std::uint64_t load_active;
-
-        bool needs_resched;
-    };
 } // export namespace sched

kernel/interfaces/system/sched/scheduler.cppm

@@ -12,6 +12,7 @@ export import :wait_queue;
 export import :work_queue;
 
 import :arch;
+import boot;
 
 // implemented in :arch
 namespace sched::arch
@@ -22,18 +23,18 @@ namespace sched::arch
     // makes sure that thread doesn't migrate to another core
     thread_t *current_thread();
 
-    void context_switch(thread_t *prev, thread_t *next);
-
-    void init_thread(
-        thread_t *thread, std::uintptr_t ip, std::uintptr_t arg,
-        std::uintptr_t stack_top, bool is_kernel
-    );
+    void init_core(thread_t *initial);
+    void init_thread(thread_t *thread, std::uintptr_t ip, std::uintptr_t arg, bool is_kernel);
 
+    void context_switch(thread_t *prev, thread_t *next);
     [[noreturn]] void return_to_user(std::uintptr_t ip, std::uintptr_t stack);
 } // namespace sched::arch
 
 export namespace sched
 {
+    constexpr std::size_t kstack_size = boot::kstack_size;
+    constexpr std::size_t ustack_size = boot::ustack_size;
+
     // called from bsp
     void init();
 
@@ -72,11 +73,14 @@ export namespace sched
     // called on yield, block, timer or wake up
     void schedule();
 
-    // create and run a new kernel thread under pid 0
-    thread_t *create_kthread(nice_t nice, std::uintptr_t ip, std::uintptr_t arg);
+    // create a new kernel thread under pid 0
+    thread_t *create_kthread(std::uintptr_t ip, std::uintptr_t arg, nice_t nice = default_nice);
 
     // create a user thread
-    thread_t *create_thread(process_t *proc, int nice, std::uintptr_t entry, std::uintptr_t stack);
+    thread_t *create_uthread(process_t *proc, std::uintptr_t entry, std::uintptr_t stack, nice_t nice = default_nice);
+
+    // enqueue a new thread on current cpu
+    void enqueue_new(thread_t *thread);
 
     bool wake_up(thread_t *thread, bool preempt = true);
 

kernel/interfaces/system/sched/thread.cppm

@@ -2,6 +2,8 @@
 
 export module system.sched:thread;
 
+import system.sched.thread_base;
+
 import system.cpu.local;
 import magic_enum;
 import lib;
@@ -34,32 +36,16 @@ export namespace sched
 
     using namespace magic_enum::bitwise_operators;
 
-    struct entity_t
-    {
-        std::uint64_t vruntime = 0;
-        std::uint64_t total_runtime = 0;
-        std::uint64_t prev_runtime = 0;
-        std::uint64_t sched_time = 0;
-
-        nice_t nice = default_nice;
-        std::uint64_t weight = nice_to_weight(nice);
-        std::uint64_t inv_weight = nice_to_inv_weight(nice);
-
-        bool on_rq = false;
-
-        lib::rbtree_hook<entity_t> hook;
-    };
-
     struct process_t;
-    struct thread_t
+    struct thread_t : thread_base_t
     {
         // accessed from assembly
         cpu::processor *running_on;
         std::uintptr_t ustack_top;
         std::uintptr_t kstack_top;
         thread_t *self;
 
-        std::atomic<std::ssize_t> preempt_count;
+        std::atomic<std::ssize_t> preempt_count = 0;
 
         // sizes are fixed
         std::uintptr_t ustack_base;
@@ -72,7 +58,18 @@ export namespace sched
         thread_flags flags = thread_flags::none;
         int exit_code = 0;
 
-        entity_t entity;
+        std::uint64_t vruntime = 0;
+        std::uint64_t total_runtime = 0;
+        std::uint64_t prev_runtime = 0;
+        std::uint64_t sched_time = 0;
+
+        nice_t nice;
+        std::uint64_t weight;
+        std::uint64_t inv_weight;
+
+        bool in_rq = false;
+        lib::rbtree_hook<thread_t> hook;
+
         arch::context *ctx;
         arch::data adata;
 

kernel/interfaces/system/sched/thread_base.cppm

@@ -0,0 +1,8 @@
+// Copyright (C) 2024-2026  ilobilo
+
+export module system.sched.thread_base;
+
+export namespace sched
+{
+    struct thread_base_t { };
+} // export namespace sched