LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-10 13:00:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
57a2394cb4
ladybird/Kernel/Scheduler.h

84 lines
3.0 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 11:38:21 +03:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03: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 18:21:13 +03:00
#include <AK/Function.h>
#include <AK/IntrusiveList.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 03:27:42 +03: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-29 00:34:31 +03: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 21:58:19 +03:00
#include <Kernel/Time/TimeManagement.h>
Scheduler: Use monotonic time for blocking threads
2020-03-14 01:59:45 +03:00
#include <Kernel/UnixTypes.h>
Kernel: Move all code into the Kernel namespace
2020-02-16 03:27:42 +03:00
namespace Kernel {
Move timer tick handling into Scheduler.
2018-11-08 02:24:59 +03:00
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03: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-24 00:03:17 +03: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 21:17:17 +03:00
class WaitQueue;
Kernel: Rename RegisterDump => RegisterState
2020-02-16 02:15:37 +03:00
struct RegisterState;
Kernel: Don't create Function objects in the scheduling code Each Function is a heap allocation, so let's make an effort to avoid doing that during scheduling. Because of header dependencies, I had to put the runnables iteration helpers in Thread.h, which is a bit meh but at least this cuts out all the kmalloc() traffic in pick_next().
2019-08-07 21:43:54 +03:00
struct SchedulerData;
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03: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-24 00:03:17 +03: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 21:17:17 +03: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 22:42:28 +03:00
extern Atomic<bool> g_finalizer_has_work;
Kernel: Don't create Function objects in the scheduling code Each Function is a heap allocation, so let's make an effort to avoid doing that during scheduling. Because of header dependencies, I had to put the runnables iteration helpers in Thread.h, which is a bit meh but at least this cuts out all the kmalloc() traffic in pick_next().
2019-08-07 21:43:54 +03:00
extern SchedulerData* g_scheduler_data;
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-29 00:34:31 +03:00
extern RecursiveSpinLock g_scheduler_lock;
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03: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 16:27:22 +03: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 17:24:29 +03: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 22:42:28 +03:00
[[noreturn]] static void start();
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03: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 05:04:36 +03: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 22:53:15 +03: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 17:53:35 +03: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 23:32:07 +03: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 07:29:41 +03: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 23:37:40 +03: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 12:28:12 +03:00
static Process* colonel();
Kernel: Add a beep() syscall that beeps the PC speaker. Hook this up in Terminal so that the '\a' character generates a beep. Finally emit an '\a' character in the shell line editing code when backspacing at the start of the line.
2019-05-15 22:40:41 +03:00
static void beep();
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 06:51:34 +03: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 22:42:28 +03: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 23:32:07 +03:00
static void notify_finalizer();
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
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 18:21:13 +03:00
template<typename Callback>
Kernel: Don't create Function objects in the scheduling code Each Function is a heap allocation, so let's make an effort to avoid doing that during scheduling. Because of header dependencies, I had to put the runnables iteration helpers in Thread.h, which is a bit meh but at least this cuts out all the kmalloc() traffic in pick_next().
2019-08-07 21:43:54 +03:00
static inline IterationDecision for_each_runnable(Callback);
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 18:21:13 +03:00
template<typename Callback>
Kernel: Don't create Function objects in the scheduling code Each Function is a heap allocation, so let's make an effort to avoid doing that during scheduling. Because of header dependencies, I had to put the runnables iteration helpers in Thread.h, which is a bit meh but at least this cuts out all the kmalloc() traffic in pick_next().
2019-08-07 21:43:54 +03:00
static inline IterationDecision for_each_nonrunnable(Callback);
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 18:21:13 +03:00
static void init_thread(Thread& thread);
Move the scheduler code to its own class. This is very mechanical.
2018-11-08 00:15:02 +03:00
};
Kernel: Move all code into the Kernel namespace
2020-02-16 03:27:42 +03:00
}
Reference in New Issue Copy Permalink