MaxOS::processes::GlobalScheduler Class Reference

The global scheduler that manages all processes and threads across all cores. More...

#include <scheduler.h>

Inheritance diagram for MaxOS::processes::GlobalScheduler:

Public Member Functions
	GlobalScheduler (system::Multiboot &multiboot)
	Constructs a new Global Scheduler object. Registers as the interrupt handler for interrupt 0x20 and setups the shared resource registries. Loads any ELF files from the multiboot structure.
	~GlobalScheduler ()
	Destroys the global scheduler and frees the per core schedulers.
system::cpu_status_t *	handle_interrupt (system::cpu_status_t *status) final
	Handles the interrupt 0x20.
void	balance ()
	Moves processes and threads between cores to balance the load so that each core has a similar amount of threads and processes.
uint64_t	add_process (Process *process)
	Adds a process to the least busy core.
uint64_t	add_thread (Thread *thread)
	Adds a thread to the least busy core.
Public Member Functions inherited from MaxOS::hardwarecommunication::InterruptHandler
virtual void	handle_interrupt ()
	Handles an interrupt.

Static Public Member Functions
static GlobalScheduler *	system_scheduler ()
	Gets the system scheduler.
static Scheduler *	core_scheduler ()
	Gets the scheduler for the currently executing core.
static system::cpu_status_t *	yield (system::cpu_status_t *current)
	Pass execution to the next thread.
static void	activate ()
	Activates each core's scheduler.
static void	deactivate ()
	Deactivates each core's scheduler.
static bool	is_active ()
	Checks if the global scheduler is active.
static void	load_multiboot_elfs (system::Multiboot *multiboot)
	Loads any valid ELF files from the multiboot structure.
static void	print_running_header ()
	Print the header for the running processes in the form ({name}:t{tid}c{core})
static uint64_t	remove_process (Process *process)
	Removes a process from the scheduler if the process has no threads, if it does then the threads are stopped but the process is not removed (this will be done automatically when all threads are stopped)
static system::cpu_status_t *	force_remove_process (Process *process)
	Removes a process from the scheduler and deletes all threads, begins running the next process.
static Process *	current_process ()
	Gets the process on the currently executing core.
static Process *	get_process (uint64_t pid)
	Gets a process on the currently executing core by its PID.
static uint64_t	next_pid ()
	Gets the next usable global PID.
static Thread *	current_thread ()
	Gets the thread on the currently executing core.
static Thread *	get_thread (uint64_t tid)
	Gets a thread on the currently executing core by its TID.
static uint64_t	next_tid ()
	Gets the next usable global TID.

Additional Inherited Members
Protected Member Functions inherited from MaxOS::hardwarecommunication::InterruptHandler
	InterruptHandler (uint8_t interrupt_number, int64_t redirect=-1, uint64_t redirect_index=0)
	Creates a new interrupt handler and registers it with the interrupt manager.
	~InterruptHandler ()
	Destroys the interrupt handler and unregisters it from the interrupt manager.
Protected Attributes inherited from MaxOS::hardwarecommunication::InterruptHandler
uint8_t	m_interrupt_number
	The interrupt number this handler handles.

Detailed Description

The global scheduler that manages all processes and threads across all cores.

Definition at line 26 of file scheduler.h.

Constructor & Destructor Documentation

GlobalScheduler()

GlobalScheduler::GlobalScheduler ( system::Multiboot &  multiboot )

explicit

Constructs a new Global Scheduler object. Registers as the interrupt handler for interrupt 0x20 and setups the shared resource registries. Loads any ELF files from the multiboot structure.

Parameters

multiboot

The multiboot structure that may contain ELF files to load

Definition at line 24 of file scheduler.cpp.

: InterruptHandler(0x20),
  m_shared_memory_registry(resource_type_t::SHARED_MEMORY),
  m_shared_messages_registry(resource_type_t::MESSAGE_ENDPOINT),
  m_next_pid(-1),
  m_next_tid(-1)
{
 
    // Set up the global scheduler
    Logger::INFO() << "Setting up global Scheduler\n";
    s_instance = this;
 
    // Set up the per core scheduler
    for(const auto& core : CPU::cores)
        core -> scheduler = new Scheduler();
 
    // Load the elfs
    load_multiboot_elfs(&multiboot);
 
}

References MaxOS::system::CPU::cores, MaxOS::Logger::INFO(), and load_multiboot_elfs().

~GlobalScheduler()

GlobalScheduler::~GlobalScheduler

(

)

Destroys the global scheduler and frees the per core schedulers.

Definition at line 87 of file scheduler.cpp.

                                 {
 
    // No longer the global instance
    s_instance = nullptr;
 
    // Free the per core scheduler
    for(const auto& core : CPU::cores)
        delete core->scheduler;
 
}

References MaxOS::system::CPU::cores.

Member Function Documentation

activate()

void GlobalScheduler::activate ( )

static

Activates each core's scheduler.

Definition at line 101 of file scheduler.cpp.

                               {
 
    s_instance -> m_active = true;
    for(const auto& core : CPU::cores)
        core->scheduler->activate();
 
}

References MaxOS::system::CPU::cores.

Referenced by kernel_main().

add_process()

uint64_t GlobalScheduler::add_process

(

Process *

process

)

Adds a process to the least busy core.

Parameters

process

The process to add

Returns

The pid of the new process

Definition at line 186 of file scheduler.cpp.

                                                      {
 
    // No cores?
    if(CPU::cores.empty())
        return 0;
 
    // Find the core with the least processes
    uint64_t core_id = 0;
    Scheduler* scheduler = CPU::cores[core_id]->scheduler;
    for(const auto& core : CPU::cores){
        auto core_scheduler = core->scheduler;
        if(core_scheduler->process_amount() < scheduler->process_amount()){
            core_id = core->id;
            scheduler = core_scheduler;
        }
    }
 
    // Save the pid
    auto pid = scheduler->add_process(process);
    m_core_pids.insert(pid,core_id);
 
    Logger::DEBUG() << "Adding process " << pid << ": " << process->name << " to core " << core_id <<"\n";
    return pid;
}

References MaxOS::processes::Scheduler::add_process(), core_scheduler(), MaxOS::system::CPU::cores, MaxOS::Logger::DEBUG(), MaxOS::common::Map< Key, Value >::insert(), MaxOS::processes::Process::name, and MaxOS::processes::Scheduler::process_amount().

Referenced by load_multiboot_elfs().

add_thread()

uint64_t GlobalScheduler::add_thread

(

Thread *

thread

)

Adds a thread to the least busy core.

Parameters

thread

The thread to add

Returns

The tid of the new thread

Definition at line 217 of file scheduler.cpp.

                                                   {
 
    // No cores?
    if(CPU::cores.empty())
        return 0;
 
    // Find the core with the least threads
    uint64_t core_id = 0;
    Scheduler* scheduler = CPU::cores[core_id]->scheduler;
    for(const auto& core : CPU::cores){
        auto core_scheduler = core->scheduler;
        if(core_scheduler->thread_amount() < scheduler->thread_amount()){
            core_id = core->id;
            scheduler = core_scheduler;
        }
    }
 
    // Save the tid
    auto tid = scheduler->add_thread(thread);
    m_core_tids.insert(tid,core_id);
 
    Logger::DEBUG() << "Adding thread " << tid << " to core " << core_id <<"\n";
    return tid;
}

References MaxOS::processes::Scheduler::add_thread(), core_scheduler(), MaxOS::system::CPU::cores, MaxOS::Logger::DEBUG(), MaxOS::common::Map< Key, Value >::insert(), and MaxOS::processes::Scheduler::thread_amount().

balance()

void GlobalScheduler::balance

(

)

Moves processes and threads between cores to balance the load so that each core has a similar amount of threads and processes.

Todo:

Implement

Definition at line 126 of file scheduler.cpp.

                              {
 
}

core_scheduler()

Scheduler * GlobalScheduler::core_scheduler ( )

static

Gets the scheduler for the currently executing core.

Returns

The scheduler for this core

Definition at line 349 of file scheduler.cpp.

                                           {
    return CPU::executing_core()->scheduler;
}

References MaxOS::system::CPU::executing_core(), and MaxOS::system::Core::scheduler.

Referenced by MaxOS::common::BlockingLock::acquire(), add_process(), add_thread(), current_process(), current_thread(), handle_interrupt(), MaxOS::system::CPU::PANIC(), MaxOS::system::SyscallManager::syscall_close_process(), MaxOS::system::SyscallManager::syscall_thread_close(), and yield().

current_process()

Process * GlobalScheduler::current_process ( )

static

Gets the process on the currently executing core.

Returns

The current process, or nullptr if not found

Definition at line 280 of file scheduler.cpp.

                                          {
    if(!s_instance || !s_instance ->m_active)
        return nullptr;
 
    return core_scheduler()->current_process();
}

References core_scheduler(), and MaxOS::processes::Scheduler::current_process().

Referenced by MaxOS::filesystem::VFSResourceRegistry::create_resource(), MaxOS::memory::VirtualMemoryManager::free(), MaxOS::filesystem::VFSResourceRegistry::get_resource(), MaxOS::memory::VirtualMemoryManager::load_shared_memory(), MaxOS::processes::SharedMemory::open(), MaxOS::system::CPU::PANIC(), MaxOS::system::CPU::prepare_for_panic(), print_running_header(), MaxOS::processes::SharedMemory::read(), MaxOS::system::SyscallManager::syscall_close_process(), MaxOS::system::SyscallManager::syscall_resource_close(), MaxOS::system::SyscallManager::syscall_resource_open(), MaxOS::system::SyscallManager::syscall_resource_read(), and MaxOS::system::SyscallManager::syscall_resource_write().

current_thread()

Thread * GlobalScheduler::current_thread ( )

static

Gets the thread on the currently executing core.

Returns

The currently executing thread

Definition at line 316 of file scheduler.cpp.

                                        {
    return core_scheduler()->current_thread();
}

References core_scheduler(), and MaxOS::processes::Scheduler::current_thread().

Referenced by MaxOS::common::BlockingLock::acquire(), print_running_header(), MaxOS::system::SyscallManager::syscall_thread_close(), MaxOS::system::SyscallManager::syscall_thread_sleep(), and yield().

deactivate()

void GlobalScheduler::deactivate ( )

static

Deactivates each core's scheduler.

Definition at line 112 of file scheduler.cpp.

                                 {
 
    s_instance -> m_active = false;
    for(const auto& core : CPU::cores)
        core->scheduler->deactivate();
 
}

References MaxOS::system::CPU::cores.

force_remove_process()

system::cpu_status_t * GlobalScheduler::force_remove_process ( Process *  process )

static

Removes a process from the scheduler and deletes all threads, begins running the next process.

Parameters

process

The process to remove

Returns

The status of the CPU for the next process to run or nullptr if the process was not found

Definition at line 264 of file scheduler.cpp.

                                                                          {
 
    // Get the core running the process
    if(!s_instance)
        return nullptr;
 
    auto core = s_instance -> m_core_pids[process->pid()];
    return CPU::cores[core]->scheduler->force_remove_process(process);
 
}

References MaxOS::system::CPU::cores, and MaxOS::processes::Process::pid().

Referenced by MaxOS::system::CPU::prepare_for_panic().

get_process()

Process * GlobalScheduler::get_process ( uint64_t  pid )

static

Gets a process on the currently executing core by its PID.

Parameters

pid	The process ID

Returns

The process or nullptr if not found

Definition at line 293 of file scheduler.cpp.

                                                  {
 
    // Get the core running the pid
    if(!s_instance)
        return nullptr;
 
    auto core = s_instance -> m_core_pids[pid];
    return CPU::cores[core]->scheduler->get_process(pid);
}

References MaxOS::system::CPU::cores.

Referenced by MaxOS::system::SyscallManager::syscall_close_process().

get_thread()

Thread * GlobalScheduler::get_thread ( uint64_t  tid )

static

Gets a thread on the currently executing core by its TID.

Parameters

tid	The thread ID

Returns

The thread or nullptr if not found

Definition at line 326 of file scheduler.cpp.

                                                {
 
    // Get the core running the tid
    if(!s_instance)
        return nullptr;
 
    auto core = s_instance -> m_core_tids[tid];
    return CPU::cores[core]->scheduler->get_thread(tid);
}

References MaxOS::system::CPU::cores.

Referenced by MaxOS::common::BlockingLock::release(), and MaxOS::system::SyscallManager::syscall_thread_close().

handle_interrupt()

system::cpu_status_t * GlobalScheduler::handle_interrupt ( system::cpu_status_t *  status )

finalvirtual

Handles the interrupt 0x20.

Parameters

status

The current CPU status

Returns

The new CPU status

Reimplemented from MaxOS::hardwarecommunication::InterruptHandler.

Definition at line 62 of file scheduler.cpp.

                                                                                {
 
    // Scheduler not active
    if(!s_instance || !s_instance->m_active)
        return status;
 
    auto s = core_scheduler()->schedule(status);
    ASSERT(s->rip != 0, "Cant run a empty state\n");
    return s;
}

References ASSERT, core_scheduler(), and MaxOS::processes::Scheduler::schedule().

is_active()

bool GlobalScheduler::is_active ( )

static

Checks if the global scheduler is active.

Returns

True if the scheduler is active, false otherwise

Definition at line 358 of file scheduler.cpp.

                                {
    return s_instance->m_active;
}

load_multiboot_elfs()

void GlobalScheduler::load_multiboot_elfs ( system::Multiboot *  multiboot )

static

Loads any valid ELF files from the multiboot structure.

Parameters

multiboot

The multiboot structure

Todo:

Handle passing multiple args to the process

Definition at line 138 of file scheduler.cpp.

                                                              {
 
    for (multiboot_tag* tag = multiboot->start_tag(); tag->type != MULTIBOOT_TAG_TYPE_END; tag = (struct multiboot_tag*) ((multiboot_uint8_t*) tag + ((tag->size + 7) & ~7))) {
 
        // Tag is not an ELF
        if (tag->type != MULTIBOOT_TAG_TYPE_MODULE)
            continue;
 
        // Try to create the elf from the module
        auto* module = (struct multiboot_tag_module*) tag;
        ELF64 elf((uintptr_t) PhysicalMemoryManager::to_dm_region(module->mod_start));
        if (!elf.is_valid())
            continue;
 
        Logger::DEBUG() << "Creating process from multiboot module for " << module->cmdline << " (at 0x" << (uint64_t) module->mod_start << ")\n";
 
        // Create an array of args for the process
        char* args[1] = {module->cmdline};
 
        // Create the process
        auto* process = new Process(module->cmdline, args, 1, &elf);
        GlobalScheduler::system_scheduler() -> add_process(process);
 
        Logger::DEBUG() << "ELF loaded to pid " << process->pid() << "\n";
    }
}

References add_process(), MaxOS::Logger::DEBUG(), MaxOS::processes::ELF64::is_valid(), MaxOS::system::Multiboot::start_tag(), system_scheduler(), and MaxOS::memory::PhysicalMemoryManager::to_dm_region().

Referenced by GlobalScheduler().

next_pid()

uint64_t GlobalScheduler::next_pid ( )

static

Gets the next usable global PID.

Returns

Definition at line 307 of file scheduler.cpp.

                                   {
    return s_instance -> m_next_pid++;
}

Referenced by MaxOS::processes::Scheduler::add_process().

next_tid()

uint64_t GlobalScheduler::next_tid ( )

static

Gets the next usable global TID.

Returns

Definition at line 340 of file scheduler.cpp.

                                   {
    return s_instance->m_next_tid++;
}

Referenced by MaxOS::processes::Scheduler::add_thread().

print_running_header()

void GlobalScheduler::print_running_header ( )

static

Print the header for the running processes in the form ({name}:t{tid}c{core})

Definition at line 168 of file scheduler.cpp.

                                           {
 
    // No threads or processes to get
    if(!s_instance || !s_instance->m_active)
        return;
 
    auto process = current_process();
    auto thread   = current_thread();
 
    Logger::Out() << "(" << process->name << ":t" << thread->tid  << "c" << CPU::executing_core()->id << ") ";
}

References current_process(), current_thread(), MaxOS::system::CPU::executing_core(), MaxOS::system::Core::id, and MaxOS::Logger::Out().

Referenced by MaxOS::Logger::set_log_level().

remove_process()

uint64_t GlobalScheduler::remove_process ( Process *  process )

static

Removes a process from the scheduler if the process has no threads, if it does then the threads are stopped but the process is not removed (this will be done automatically when all threads are stopped)

Parameters

process

The process to remove

Returns

-1 if the process has threads, 0 otherwise

Definition at line 248 of file scheduler.cpp.

                                                         {
 
    // Get the core running the process
    if(!s_instance)
        return 0;
 
    auto core = s_instance -> m_core_pids[process->pid()];
    return CPU::cores[core]->scheduler->remove_process(process);
}

References MaxOS::system::CPU::cores, and MaxOS::processes::Process::pid().

system_scheduler()

GlobalScheduler * GlobalScheduler::system_scheduler ( )

static

Gets the system scheduler.

Returns

The system scheduler or nullptr if not found

Definition at line 50 of file scheduler.cpp.

                                                   {
 
    return s_instance;
}

Referenced by load_multiboot_elfs(), MaxOS::system::CPU::prepare_for_panic(), and MaxOS::system::SyscallManager::syscall_close_process().

yield()

system::cpu_status_t * GlobalScheduler::yield ( system::cpu_status_t *  current )

static

Pass execution to the next thread.

Parameters

current

where to resume this thread to

Returns

The cpu state of the next thread to run

Definition at line 79 of file scheduler.cpp.

                                                                {
    current_thread()->execution_state = *current;
    return core_scheduler()->yield();
}

References core_scheduler(), current_thread(), MaxOS::processes::Thread::execution_state, and MaxOS::processes::Scheduler::yield().

Referenced by MaxOS::system::SyscallManager::syscall_thread_sleep(), and MaxOS::system::SyscallManager::syscall_thread_yield().

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/processes/scheduler.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/processes/scheduler.cpp