sys/interrupts: reschedule thread when exiting interrupt

Instead of rescheduling a thread only during the timer interrupt,
always try to reschedule a thread when exiting an interrupt.

This time is the best time to do this since an expensive context
switch to kernel mode has been performed already. The user can
afford to wait for a bit more.

This commit removes the scheduling logic from the timer interrupt
handler, as well as the running field in struct thread, and relies
on the timer's frequency to define the maximum timeslice given
to each processes.

While at it remove HZ, and rename CLOCK_PER_SECOND to TICKS_PER_SECOND
since those are timer ticks and not clock cycles.

Author: d4ilyrun

include/kernel/process.h

@@ -145,11 +145,6 @@ typedef struct thread {
 
     /** Information relative to the current state of the thread */
     union {
-        /** For running threads only */
-        struct {
-            /** End of the currently running thread's timeslice */
-            clock_t preempt;
-        } running;
         /** For sleeping threads only */
         struct {
             clock_t wakeup; /*!< Time when it should wakeup (in ticks) */
@@ -160,7 +155,8 @@ typedef struct thread {
 
 /** @enum thread_flags */
 typedef enum thread_flags {
-    THREAD_KERNEL = BIT(0), ///< This thread runs in kernel mode
+    THREAD_KERNEL           = BIT(0), ///< This is a kernel thread
+    THREAD_RESCHED          = BIT(1), ///< Reschedule when exiting interrupt
 } process_flags_t;
 
 /***/

include/kernel/time.h

@@ -8,8 +8,14 @@
 #ifndef KERNEL_TIME_H
 #define KERNEL_TIME_H
 
-/* The number of clock ticks in a second (1KHz). */
-#define CLOCK_PER_SECOND 1000
+/*
+ * The number of clock ticks in a second (100Hz, 1 tick = 100ms).
+ *
+ * This is also used as the maximum time a thread is allowed to run for
+ * before being rescheduled (thread will be forcefully rescheduled
+ * when a timer interrupt eventually occurs).
+ */
+#define TICKS_PER_SECOND 100
 
 /** @brief Used for conversions from seconds to another time unit @{ */
 #define SEC(_x) (_x)

include/kernel/timer.h

@@ -20,18 +20,15 @@
 #include <kernel/time.h>
 #include <kernel/types.h>
 
-/** The frequency used for the timer (in Hz) */
-#define HZ CLOCK_PER_SECOND
-
 /** @brief Compute the number of ticks in a given time frame @{ */
-#define SEC_TO_TICKS(_time) SEC((_time) * HZ)
+#define SEC_TO_TICKS(_time) SEC((_time) * TICKS_PER_SECOND)
 #define MS_TO_TICKS(_time) MS_TO_SEC(SEC_TO_TICKS(_time))
 #define US_TO_TICKS(_time) US_TO_SEC(SEC_TO_TICKS(_time))
 #define NS_TO_TICKS(_time) NS_TO_SEC(SEC_TO_TICKS(_time))
 /** @} */
 
 /** @brief Convert a number of ticks into a regular time unit @{ */
-#define TICKS_TO_SEC(_ticks) SEC((_ticks) / HZ)
+#define TICKS_TO_SEC(_ticks) SEC((_ticks) / TICKS_PER_SECOND)
 #define TICKS_TO_MS(_ticks) MS(TICKS_TO_SEC(_ticks))
 #define TICKS_TO_US(_ticks) US(TICKS_TO_SEC(_ticks))
 #define TICKS_TO_NS(_ticks) NS(TICKS_TO_SEC(_ticks))

kernel/arch/i686/mmu.c

@@ -783,6 +783,12 @@ static INTERRUPT_HANDLER_FUNCTION(page_fault)
 
     UNUSED(data);
 
+    /*
+     * Starting a new process can generate a lot of page faults. Avoid
+     * rescheduling for page faults to speed up process startup.
+     */
+    current->flags &= ~THREAD_RESCHED;
+
     if (!error.present || is_cow) {
         as = IS_KERNEL_ADDRESS(faulty_address) ? &kernel_address_space
                                                : current->process->as;

kernel/arch/i686/timer.c

@@ -15,11 +15,11 @@
 
 #define LOG_DOMAIN "timer"
 
-#include <kernel/timer.h>
 #include <kernel/error.h>
 #include <kernel/interrupts.h>
 #include <kernel/logger.h>
 #include <kernel/sched.h>
+#include <kernel/timer.h>
 
 #include <kernel/arch/i686/devices/pic.h>
 #include <kernel/arch/i686/devices/pit.h>
@@ -55,25 +55,11 @@ static INTERRUPT_HANDLER_FUNCTION(irq_timer)
 
     pic_eoi(IRQ_TIMER);
 
-    if (!scheduler_initialized)
-        return INTERRUPT_HANDLED;
-
-    // TODO: Use a separate and more modern timer for scheduler (LAPIC, HPET)
-    //
-    // We could be setting the next timer interrupt dynamically to match the
-    // next due task, but:
-    // * this is our main timekeeping source, and it would make it less accurate
-    // * the PIT is too slow to re-program dynamically like this
-
-    // TODO: Don't mingle IRQ and scheduling
-
     /*
      * Unblock waiting threads whose deadline has been reached, and preempt
      * the current thread if we reached the end of its timeslice.
      */
     sched_unblock_waiting_before(timer_ticks_counter);
-    if (current->running.preempt <= timer_ticks_counter)
-        schedule();
 
     return INTERRUPT_HANDLED;
 }

kernel/main.c

@@ -190,7 +190,7 @@ void kernel_main(struct multiboot_info *mbt, unsigned int magic)
      * IRQs and controllers are setup, we can safely enable interrupts.
      */
     interrupts_enable();
-    timer_start(HZ);
+    timer_start(TICKS_PER_SECOND);
 
     mbt_info = kmalloc(mbt_tmp.mbt.total_size, KMALLOC_KERNEL);
     memcpy(mbt_info, mbt_tmp.raw, mbt_tmp.mbt.total_size);

kernel/sys/interrupts.c

@@ -5,6 +5,7 @@
 #include <kernel/interrupts.h>
 #include <kernel/kmalloc.h>
 #include <kernel/logger.h>
+#include <kernel/sched.h>
 
 #include <libalgo/linked_list.h>
 
@@ -42,7 +43,22 @@ interrupt_chip_interrupt_handle(const struct interrupt_chip *chip,
  */
 error_t interrupt_handle(unsigned int nr)
 {
-    return interrupt_chip_interrupt_handle(&interrupt_root_chip, nr);
+    error_t err;
+
+    current->flags |= THREAD_RESCHED;
+
+    err = interrupt_chip_interrupt_handle(&interrupt_root_chip, nr);
+
+    /*
+     * Try to reschedule the current thread. This is the best time to do so.
+     *
+     * TODO: Make sure that a user thread does not return to userland with
+     *       preemption disabled.
+     */
+    if (current->flags & THREAD_RESCHED)
+        schedule();
+
+    return err;
 }
 
 /*

kernel/sys/sched.c

@@ -14,9 +14,6 @@ bool scheduler_initialized = false;
 
 static DECLARE_LLIST(sleeping_tasks);
 
-/** The maximum timeslice given to a thread by the scheduler */
-#define SCHED_TIMESLICE MS_TO_TICKS(2ULL) // 2MS
-
 typedef struct scheduler {
 
     /** The runqueue
@@ -50,6 +47,9 @@ static void schedule_locked(bool preempt, bool reschedule)
 {
     node_t *next_node;
 
+    if (unlikely(!scheduler_initialized))
+        return;
+
     if (atomic_read(&scheduler.sync.preemption_level) > 1 && !preempt)
         return;
 
@@ -79,11 +79,8 @@ static void schedule_locked(bool preempt, bool reschedule)
         }
     }
 
-    next->running.preempt = timer_gettick() + SCHED_TIMESLICE;
-
-    if (!thread_switch(next)) {
+    if (!thread_switch(next))
         schedule_locked(preempt, false);
-    }
 }
 
 void schedule(void)