0ct0pu5/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
ladybird/Kernel/Scheduler.h

77 lines
2.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 09:38:21 +01: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-07 22:15:02 +01:00
#pragma once
#include <AK/Assertions.h>
Kernel: Remove system.h and make the uptime global a qword.
2019-04-14 01:29:14 +02:00
#include <AK/Types.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 17:21:13 +02:00
#include <AK/Function.h>
#include <AK/IntrusiveList.h>
Move timer tick handling into Scheduler.
2018-11-08 00:24:59 +01:00
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 22:15:02 +01: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 22:03:17 +01: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 19:17:17 +01:00
class WaitQueue;
Move timer tick handling into Scheduler.
2018-11-08 00:24:59 +01:00
struct RegisterDump;
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 20:43:54 +02:00
struct SchedulerData;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 22:15:02 +01: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 22:03:17 +01:00
extern Thread* current;
extern Thread* g_finalizer;
Kernel: Get rid of "main thread" concept The idea of all processes reliably having a main thread was nice in some ways, but cumbersome in others. More importantly, it didn't match up with POSIX thread semantics, so let's move away from it. This thread gets rid of Process::main_thread() and you now we just have a bunch of Thread objects floating around each Process. When the finalizer nukes the last Thread in a Process, it will also tear down the Process. There's a bunch of more things to fix around this, but this is where we get started :^)
2019-12-22 11:35:02 +01:00
extern Thread* g_colonel;
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 19:17:17 +01:00
extern WaitQueue* g_finalizer_wait_queue;
Kernel: Finalizer should not go back to sleep if there's more to do Before putting itself back on the wait queue, the finalizer task will now check if there's more work to do, and if so, do it first. :^) This patch also puts a bunch of process/thread debug logging behind PROCESS_DEBUG and THREAD_DEBUG since it was unbearable to debug this stuff with all the spam.
2020-02-01 10:27:25 +01:00
extern bool g_finalizer_has_work;
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 21:17:35 +02:00
extern u64 g_uptime;
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 20:43:54 +02:00
extern SchedulerData* g_scheduler_data;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 22:15:02 +01:00
class Scheduler {
public:
static void initialize();
Move timer tick handling into Scheduler.
2018-11-08 00:24:59 +01:00
static void timer_tick(RegisterDump&);
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 22:15:02 +01:00
static bool pick_next();
static void pick_next_and_switch_now();
static void switch_now();
static bool yield();
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 22:03:17 +01:00
static bool donate_to(Thread*, const char* reason);
static bool context_switch(Thread&);
static void prepare_to_modify_tss(Thread&);
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 10:28:12 +01:00
static Process* colonel();
Kernel: Clean up around Scheduler::yield() a bit. Also add assertion in Lock that the scheduler isn't currently active. I've been seeing occasional fuckups that I suspect might be someone called by the scheduler trying to take a busy lock.
2019-02-06 15:05:47 +01:00
static bool is_active();
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 21:40:41 +02:00
static void beep();
Kernel: Stop idling after handling an IRQ If we receive an IRQ while the idle task is running, prevent it from re-halting the CPU after the IRQ handler returns. Instead have the idle task yield to the scheduler, so we can see if the IRQ has unblocked something.
2019-09-14 19:44:22 +02:00
static void idle_loop();
static void stop_idling();
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 11:53:16 +02: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 17:21:13 +02: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 20:43:54 +02: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 17:21:13 +02: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 20:43:54 +02: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 17:21:13 +02:00
static void init_thread(Thread& thread);
static void update_state_for_thread(Thread& thread);
Move timer tick handling into Scheduler.
2018-11-08 00:24:59 +01:00
private:
static void prepare_for_iret_to_new_process();
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 22:15:02 +01:00
};
Reference in a new issue Copy permalink