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

57 lines
1.6 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: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
#include <Kernel/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
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
class Process;
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
class Thread;
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
class WaitQueue;
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 Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
extern RecursiveSpinLock g_scheduler_lock;
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);
Kernel: Use a const reference to RegisterState in IRQ handling
2020-03-09 14:24:29 +00:00
static void timer_tick(const RegisterState&);
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();
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
static bool pick_next();
static bool yield();
Kernel: Fix some problems with Thread::wait_on and Lock This changes the Thread::wait_on function to not enable interrupts upon leaving, which caused some problems with page fault handlers and in other situations. It may now be called from critical sections, with interrupts enabled or disabled, and returns to the same state. This also requires some fixes to Lock. To aid debugging, a new define LOCK_DEBUG is added that enables checking for Lock leaks upon finalization of a Thread.
2020-12-01 02:04:36 +00:00
static void yield_from_critical();
Kernel: Fix thread donation hanging the system Fixes two flaws in the thread donation logic: Scheduler::donate_to would never really donate, but just trigger a deferred yield. And that deferred yield never actually donated to the beneficiary. So, when we can't immediately donate, we need to save the beneficiary and use this information as soon as we can perform the deferred context switch. Fixes #3495
2020-09-15 19:53:15 +00:00
static bool donate_to_and_switch(Thread*, const char* reason);
Kernel: Make Thread refcounted Similar to Process, we need to make Thread refcounted. This will solve problems that will appear once we schedule threads on more than one processor. This allows us to hold onto threads without necessarily holding the scheduler lock for the entire duration.
2020-09-27 14:53:35 +00:00
static bool donate_to(RefPtr<Thread>&, const char* reason);
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 bool context_switch(Thread*);
Kernel: Fix some issues related to fixes and block conditions Fix some problems with join blocks where the joining thread block condition was added twice, which lead to a crash when trying to unblock that condition a second time. Deferred block condition evaluation by File objects were also not properly keeping the File object alive, which lead to some random crashes and corruption problems. Other problems were caused by the fact that the Queued state didn't handle signals/interruptions consistently. To solve these issues we remove this state entirely, along with Thread::wait_on and change the WaitQueue into a BlockCondition instead. Also, deliver signals even if there isn't going to be a context switch to another thread. Fixes #4336 and #4330
2020-12-08 04:29:41 +00:00
static void enter_current(Thread& prev_thread, bool is_first);
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 leave_on_first_switch(u32 flags);
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();
static bool dequeue_runnable_thread(Thread&, bool = false);
static void queue_runnable_thread(Thread&);
Kernel: Add magic key combo (Alt+Shift+F12) to dump scheduler state Pressing this combo will dump a list of all threads and their state to the debug console. This might be useful to figure out why the system is not responding.
2021-04-18 17:57:17 +00:00
static void dump_scheduler_state();
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