beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/Scheduler.h

61 lines
1.7 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
#pragma once
#include <AK/Assertions.h>
Move runnable/non-runnable list control entirely over to Scheduler This way, we can change how the scheduler works without having to change Thread too.
2019-07-19 15:21:13 +00:00
#include <AK/Function.h>
#include <AK/IntrusiveList.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
#include <AK/Types.h>
Kernel: Use Forward.h headers more
2021-07-11 09:49:16 +00:00
#include <Kernel/Forward.h>
Kernel: Rename SpinLock => Spinlock
2021-08-21 23:37:17 +00:00
#include <Kernel/Locking/Spinlock.h>
Kernel: Move some time related code from Scheduler into TimeManagement Use the TimerQueue to expire blocking operations, which is one less thing the Scheduler needs to check on every iteration. Also, add a BlockTimeout class that will automatically handle relative or absolute timeouts as well as overriding timeouts (e.g. socket timeouts) more consistently. Also, rework the TimerQueue class to be able to fire events from any processor, which requires Timer to be RefCounted. Also allow creating id-less timers for use by blocking operations.
2020-11-15 18:58:19 +00:00
#include <Kernel/Time/TimeManagement.h>
Scheduler: Use monotonic time for blocking threads
2020-03-13 22:59:45 +00:00
#include <Kernel/UnixTypes.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Move timer tick handling into Scheduler.
2018-11-07 23:24:59 +00:00
Kernel: Rename RegisterDump => RegisterState
2020-02-15 23:15:37 +00:00
struct RegisterState;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
extern Thread* g_finalizer;
Kernel: Use a WaitQueue to implement finalizer wakeup This gets rid of the special "Lurking" thread state and replaces it with a generic WaitQueue :^)
2019-12-01 18:17:17 +00:00
extern WaitQueue* g_finalizer_wait_queue;
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
extern Atomic<bool> g_finalizer_has_work;
Kernel: Turn lock ranks into template parameters This step would ideally not have been necessary (increases amount of refactoring and templates necessary, which in turn increases build times), but it gives us a couple of nice properties: - SpinlockProtected inside Singleton (a very common combination) can now obtain any lock rank just via the template parameter. It was not previously possible to do this with SingletonInstanceCreator magic. - SpinlockProtected's lock rank is now mandatory; this is the majority of cases and allows us to see where we're still missing proper ranks. - The type already informs us what lock rank a lock has, which aids code readability and (possibly, if gdb cooperates) lock mismatch debugging. - The rank of a lock can no longer be dynamic, which is not something we wanted in the first place (or made use of). Locks randomly changing their rank sounds like a disaster waiting to happen. - In some places, we might be able to statically check that locks are taken in the right order (with the right lock rank checking implementation) as rank information is fully statically known. This refactoring even more exposes the fact that Mutex has no lock rank capabilites, which is not fixed here.
2022-11-09 10:39:58 +00:00
extern RecursiveSpinlock<LockRank::None> g_scheduler_lock;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
Everywhere: Make tracking cpu usage independent from system ticks This switches tracking CPU usage to more accurately measure time in user and kernel land using either the TSC or another time source. This will also come in handy when implementing a tickless kernel mode.
2021-07-15 03:46:32 +00:00
struct TotalTimeScheduled {
Everywhere: Improve CPU usage calculation As threads come and go, we can't simply account for how many time slices the threads at any given point may have been using. We need to also account for threads that have since disappeared. This means we also need to track how many time slices we have expired globally. However, because this doesn't account for context switches outside of the system timer tick values may still be under-reported. To solve this we will need to track more accurate time information on each context switch. This also fixes top's cpu usage calculation which was still based on the number of context switches. Fixes #6473
2021-07-14 18:05:59 +00:00
u64 total { 0 };
u64 total_kernel { 0 };
};
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
class Scheduler {
public:
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 13:27:22 +00:00
static void initialize();
static Thread* create_ap_idle_thread(u32 cpu);
static void set_idle_thread(Thread* idle_thread);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
static void timer_tick(RegisterState const&);
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
[[noreturn]] static void start();
Kernel: Remove unused bool return values from scheduler functions Turns out nobody actually cared whether the scheduler switched to a new thread or not (which is what we were returning.)
2022-01-30 13:29:37 +00:00
static void pick_next();
static void yield();
static void context_switch(Thread*);
Kernel: Don't dispatch signals in Processor::enter_current() Signal dispatch is already taken care of elsewhere, so there appears to be no need for the hack in enter_current(). This also allows us to remove the Thread::m_in_block flag, simplifying thread blocking logic somewhat. Verified with the original repro for #4336 which this was meant to fix.
2022-01-29 12:57:39 +00:00
static void enter_current(Thread& prev_thread);
Kernel: Use InterruptsState in Spinlock code This commit updates the lock function from Spinlock and RecursiveSpinlock to return the InterruptsState of the processor, instead of the processor flags. The unlock functions would only look at the interrupt flag of the processor flags, so we now use the InterruptsState enum to clarify the intent, and such that we can use the same Spinlock code for the aarch64 build. To not break the build, all the call sites are updated aswell.
2022-08-23 19:42:30 +00:00
static void leave_on_first_switch(InterruptsState);
Kernel: Prevent recursive calls into the scheduler Upon leaving a critical section (such as a SpinLock) we need to check if we're already asynchronously invoking the Scheduler. Otherwise we might end up triggering another context switch as soon as leaving the scheduler lock. Fixes #2883
2020-08-01 20:37:40 +00:00
static void prepare_after_exec();
static void prepare_for_idle_loop();
Add a /bin/top program for process table monitoring. It automagically computes %CPU usage based on the number of times a process has been scheduled between samples. The colonel task is used as idle timer. This is pretty cool. :^)
2019-02-04 09:28:12 +00:00
static Process* colonel();
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
static void idle_loop(void*);
Kernel: Implement software context switching and Processor structure Moving certain globals into a new Processor structure for each CPU allows us to eventually run an instance of the scheduler on each CPU.
2020-06-27 19:42:28 +00:00
static void invoke_async();
Kernel: Various context switch fixes These changes solve a number of problems with the software context swithcing: * The scheduler lock really should be held throughout context switches * Transitioning from the initial (idle) thread to another needs to hold the scheduler lock * Transitioning from a dying thread to another also needs to hold the scheduler lock * Dying threads cannot necessarily be finalized if they haven't switched out of it yet, so flag them as active while a processor is running it (the Running state may be switched to Dying while it still is actually running)
2020-07-05 20:32:07 +00:00
static void notify_finalizer();
Kernel: Implement thread priority queues Rather than walking all Thread instances and putting them into a vector to be sorted by priority, queue them into priority sorted linked lists as soon as they become ready to be executed.
2021-01-22 23:56:08 +00:00
static Thread& pull_next_runnable_thread();
Kernel: Avoid unnecessary context switch when no other thread is ready If no other thread is ready to be run we don't need to switch to the idle thread and wait for the next timer interrupt. We can just give the thread another timeslice and keep it running.
2021-07-12 02:12:42 +00:00
static Thread* peek_next_runnable_thread();
Kernel: Implement thread priority queues Rather than walking all Thread instances and putting them into a vector to be sorted by priority, queue them into priority sorted linked lists as soon as they become ready to be executed.
2021-01-22 23:56:08 +00:00
static bool dequeue_runnable_thread(Thread&, bool = false);
Kernel: Rename queue_runnable_thread() => enqueue_runnable_thread()
2021-08-08 12:19:55 +00:00
static void enqueue_runnable_thread(Thread&);
Kernel: Optionally dump scheduler state with stack traces This will dump stack traces of all threads when pressing Ctrl+Shift+Alt+F12
2021-07-15 20:54:19 +00:00
static void dump_scheduler_state(bool = false);
Kernel: Add Scheduler::is_initialized
2021-06-12 13:32:56 +00:00
static bool is_initialized();
Everywhere: Make tracking cpu usage independent from system ticks This switches tracking CPU usage to more accurately measure time in user and kernel land using either the TSC or another time source. This will also come in handy when implementing a tickless kernel mode.
2021-07-15 03:46:32 +00:00
static TotalTimeScheduled get_total_time_scheduled();
static void add_time_scheduled(u64, bool);
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
};
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Reference in a new issue Copy permalink