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.
system::Core *	least_busy_core (bool check_threads=false)
	Finds the core with the least amount of threads/processes.
uint64_t	add_process (Process *process, Scheduler *scheduler=nullptr)
	Adds a process to the least busy core.
uint64_t	add_thread (Thread *thread, Scheduler *scheduler=nullptr)
	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 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	prepare_initrd (multiboot_tag_module *module)
	Loads the initrd into the init program at 0xFFF000.
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.
virtual	~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 28 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 29 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(0),
  m_next_tid(0)
{
 
    // 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(core->id);
 
    // 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 81 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 95 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,
		Scheduler *	scheduler = nullptr
	)

Adds a process to the least busy core.

Parameters

process	The process to add
scheduler	Optional, specify a specific scheduler to add to

Returns

The pid of the new process

Definition at line 234 of file scheduler.cpp.

                                                                            {
 
    // No cores?
    if(CPU::cores.empty())
        return 0;
 
    // Find the core with the least processes
    if (!scheduler)
        scheduler = least_busy_core()->scheduler;
    auto core_id = scheduler->core_id();
 
    // Save the pid
    auto pid = scheduler->add_process(process);
    m_core_pids.insert(pid,core_id);
 
    //@TODO better way to do this
    if (process->name == DEBUG_TARGET && DO_DEBUGGING) {
        Logger::DEBUG() << "Starting PROG with GDB\n";
        auto serial = new SerialConsole();
        auto debugger = new GDBServer(serial);
        debugger->attach(process->threads()[0]);
    }
 
    Logger::DEBUG() << "Adding process " << pid << ": " << process->name << " to core " << core_id <<"\n";
    return pid;
}

References MaxOS::processes::Scheduler::add_process(), MaxOS::processes::Scheduler::core_id(), MaxOS::system::CPU::cores, MaxOS::Logger::DEBUG(), MaxOS::runtime::DEBUG_TARGET, MaxOS::runtime::DO_DEBUGGING, least_busy_core(), MaxOS::processes::Process::name, MaxOS::system::Core::scheduler, and MaxOS::processes::Process::threads().

Referenced by load_multiboot_elfs(), and MaxOS::processes::Scheduler::Scheduler().

add_thread()

uint64_t GlobalScheduler::add_thread	(	Thread *	thread,
		Scheduler *	scheduler = nullptr
	)

Adds a thread to the least busy core.

Parameters

thread	The thread to add
scheduler	Optional, specify a specific scheduler to add to

Returns

The tid of the new thread

Definition at line 268 of file scheduler.cpp.

                                                                         {
 
    // No cores?
    if(CPU::cores.empty())
        return 0;
 
    // Find the core with the least threads
    if (!scheduler)
        scheduler = least_busy_core(true)->scheduler;
    auto core_id = scheduler->core_id();
 
    // 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(), MaxOS::processes::Scheduler::core_id(), MaxOS::system::CPU::cores, MaxOS::Logger::DEBUG(), least_busy_core(), and MaxOS::system::Core::scheduler.

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 120 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 398 of file scheduler.cpp.

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

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

Referenced by current_process(), current_thread(), handle_interrupt(), MaxOS::system::CPU::PANIC(), and MaxOS::processes::Thread::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 325 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::processes::resources::ProcessResourceRegistry::create_resource(), MaxOS::memory::VirtualMemoryManager::free(), MaxOS::memory::MemoryManager::free(), MaxOS::processes::resources::ProcessResourceRegistry::get_resource(), MaxOS::runtime::GDBServer::handle_remove_breakpoint(), MaxOS::runtime::GDBServer::handle_set_breakpoint(), MaxOS::memory::VirtualMemoryManager::load_shared_memory(), MaxOS::memory::MemoryManager::malloc(), MaxOS::processes::SharedMemory::open(), MaxOS::system::CPU::PANIC(), MaxOS::system::CPU::prepare_for_panic(), print_running_header(), MaxOS::processes::SharedMemory::read(), MaxOS::runtime::GDBServer::send_memory(), MaxOS::processes::resources::BridgeHandler::send_to_bridge(), 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 361 of file scheduler.cpp.

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

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

Referenced by MaxOS::processes::BlockingLock::acquire(), MaxOS::processes::resources::ThreadResourceRegistry::get_resource(), MaxOS::runtime::TrapFlagExcpetion::handle_interrupt(), MaxOS::runtime::BreakPointException::handle_interrupt(), print_running_header(), MaxOS::processes::SharedMessageEndpoint::read(), and MaxOS::processes::resources::BridgeHandler::send_to_bridge().

deactivate()

void GlobalScheduler::deactivate ( )

static

Deactivates each core's scheduler.

Definition at line 106 of file scheduler.cpp.

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

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

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

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 309 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 338 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::processes::resources::ProcessResourceRegistry::get_resource(), MaxOS::runtime::GDBServer::handle_remove_breakpoint(), MaxOS::runtime::GDBServer::handle_set_breakpoint(), prepare_initrd(), and MaxOS::runtime::GDBServer::send_memory().

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 375 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::processes::resources::ThreadResourceRegistry::get_resource(), and MaxOS::processes::BlockingLock::release().

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 67 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 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 407 of file scheduler.cpp.

                                {
    if (!s_instance)
        return false;
 
    return s_instance->m_active;
}

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

least_busy_core()

Core * GlobalScheduler::least_busy_core

(

bool

check_threads = false

)

Finds the core with the least amount of threads/processes.

Parameters

check_threads

If true also check for least amount of threads, defaults to false

Returns

The core with the lowest work load

Definition at line 130 of file scheduler.cpp.

                                                         {
 
    // Find the scheduler with the lowest work load
    auto core = CPU::cores[0];
    for(const auto& current : CPU::cores)
        if((check_threads && current->scheduler->thread_amount()  < core->scheduler->thread_amount())
                         ||  current->scheduler->process_amount() < core->scheduler->process_amount())
            core = current;
 
 
    return core;
 
}

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

Referenced by add_process(), and add_thread().

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

Definition at line 150 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 module
        if (tag->type != MULTIBOOT_TAG_TYPE_MODULE)
            continue;
 
        // Get the tag
        auto* module = (struct multiboot_tag_module*) tag;
        auto start  = (uintptr_t)PhysicalMemoryManager::to_dm_region(module->mod_start);
        Logger::DEBUG() << "Creating process from multiboot module for " << module->cmdline << " (at 0x" << (uint64_t) module->mod_start << ")\n";
 
        // Handle the init ramdisk
        if (strcmp(module->cmdline, "initrd") == 0)
            prepare_initrd(module);
 
        // Try to create the elf from the module
        ELF64 elf(start);
        if (!elf.is_valid())
            continue;
 
        // 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);
        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(), prepare_initrd(), 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 352 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 389 of file scheduler.cpp.

                                   {
    return s_instance->m_next_tid++;
}

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

prepare_initrd()

void GlobalScheduler::prepare_initrd ( multiboot_tag_module *  module )

static

Loads the initrd into the init program at 0xFFF000.

Parameters

module

The initrd module

Todo:

dont hardcode pid (and maybe not rely on Init being ordered after module)

Definition at line 190 of file scheduler.cpp.

                                                                 {
 
    // Find the Init process
    Process* init_process = get_process(4);
    ASSERT(init_process != nullptr, "Can't find init process\n");
 
    // Extract info
    auto start  = (uintptr_t)PhysicalMemoryManager::to_dm_region(module->mod_start);
    uint32_t size = module->mod_end - module->mod_start;
 
    // Prepare
    size_t actual_size;
    MemoryManager::switch_active_memory_manager(init_process->memory_manager);
    init_process->memory_manager->vmm()->allocate(0xFFF000, size + sizeof(uint32_t), actual_size, WRITE | PRESENT);
 
    // Copy
    memcpy((void*)0xFFF000, &size, sizeof(uint32_t));
    memcpy((void*)(0xFFF000 + sizeof(uint32_t)), (void*)start, size);
    MemoryManager::switch_active_memory_manager(MemoryManager::s_kernel_memory_manager);
}

References MaxOS::memory::VirtualMemoryManager::allocate(), get_process(), MaxOS::processes::Process::memory_manager, multiboot_tag_module::mod_start, MaxOS::memory::PRESENT, MaxOS::memory::MemoryManager::s_kernel_memory_manager, MaxOS::memory::PhysicalMemoryManager::to_dm_region(), MaxOS::memory::BumpMemoryManager::vmm(), and MaxOS::memory::WRITE.

Referenced by load_multiboot_elfs().

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 214 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::active_logger()->printf("(%s:t%dc%d) ",process->name.c_str(), thread->tid,CPU::executing_core()->id);
}

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

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 293 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().

Referenced by MaxOS::processes::resources::ProcessResource::close(), and MaxOS::processes::resources::ProcessResource::write().

system_scheduler()

GlobalScheduler * GlobalScheduler::system_scheduler ( )

static

Gets the system scheduler.

Returns

The system scheduler or nullptr if not found

Definition at line 55 of file scheduler.cpp.

                                                   {
 
    return s_instance;
}

Referenced by MaxOS::processes::resources::ProcessResourceRegistry::create_resource(), load_multiboot_elfs(), MaxOS::system::CPU::prepare_for_panic(), and MaxOS::processes::Scheduler::Scheduler().

---

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