Schedules processes to run on the core via their threads. More...

#include <scheduler.h>

Public Member Functions
	Scheduler ()
	Constructs a new Scheduler object and creates the idle process.

system::cpu_status_t *	schedule (system::cpu_status_t *cpu_state)
	Schedules the next thread to run.

system::cpu_status_t *	schedule_next (system::cpu_status_t *status)
	Schedules the next thread to run.

system::cpu_status_t *	yield ()
	Pass execution to the next thread.

uint64_t	add_process (Process *process)
	Adds a process to the scheduler.

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)

system::cpu_status_t *	force_remove_process (Process *process)
	Removes a process from the scheduler and deletes all threads, begins running the next process.

uint64_t	add_thread (Thread *thread)
	Adds a thread to the scheduler.

Process *	current_process ()
	Gets the current process.

Process *	get_process (uint64_t pid)
	Gets a process by its PID.

uint64_t	process_amount ()
	Gets how processes are running on this scheduler.

Thread *	current_thread ()
	Gets the currently executing thread.

Thread *	get_thread (uint64_t tid)
	Gets a thread by its TID.

uint64_t	thread_amount ()
	Gets how many threads are running on this scheduler.

uint64_t	ticks () const
	Gets how long the system has been running for.

void	activate ()
	Activates the scheduler.

void	deactivate ()
	Deactivates the scheduler.

Detailed Description

Schedules processes to run on the core via their threads.

Definition at line 85 of file scheduler.h.

Constructor & Destructor Documentation

◆ Scheduler()

Scheduler::Scheduler ( )

Constructs a new Scheduler object and creates the idle process.

Definition at line 365 of file scheduler.cpp.

: m_next_thread_index(0),
  m_active(false),
  m_ticks(0)
{
 
    // Create this idle process
    auto* idle = new Process("Idle", nullptr, nullptr, 0, true);
    idle->memory_manager = MemoryManager::s_kernel_memory_manager;
    idle->set_pid(0);
    add_process(idle);
}

References add_process(), and MaxOS::memory::MemoryManager::s_kernel_memory_manager.

Member Function Documentation

◆ activate()

void Scheduler::activate ( )

Activates the scheduler.

Definition at line 573 of file scheduler.cpp.

                         {
 
    m_active = true;
}

◆ add_process()

uint64_t Scheduler::add_process ( Process * process )

Adds a process to the scheduler.

Parameters

process The process to add

Returns: The process ID (will be assigned during add)

Definition at line 505 of file scheduler.cpp.

                                                {
 
    // Get the next process ID
    auto pid = GlobalScheduler::next_pid();
    process->set_pid(pid);
 
    // Add the process to the list
    m_processes.push_back(process);
 
    // Add the threads to the list
    for(const auto& thread : process->threads())
        thread->tid = add_thread(thread);
 
    return pid;
}

References add_thread(), MaxOS::processes::GlobalScheduler::next_pid(), MaxOS::processes::Process::set_pid(), MaxOS::processes::Process::threads(), and MaxOS::processes::Thread::tid.

Referenced by MaxOS::processes::GlobalScheduler::add_process(), and Scheduler().

◆ add_thread()

uint64_t Scheduler::add_thread ( Thread * thread )

Adds a thread to the scheduler.

Parameters

thread The thread to add

Returns: The thread ID

Definition at line 527 of file scheduler.cpp.

                                             {
 
    // Get the next thread ID
    auto tid = GlobalScheduler::next_tid();
    thread->tid = tid;
 
    // Add the thread to the list
    m_threads.push_back(thread);
 
    // Return the thread ID
    return tid;
}

References MaxOS::processes::GlobalScheduler::next_tid(), and MaxOS::processes::Thread::tid.

Referenced by add_process(), and MaxOS::processes::GlobalScheduler::add_thread().

◆ current_process()

Process * Scheduler::current_process ( )

Gets the current process.

Returns: The current process, or nullptr if not found

Definition at line 647 of file scheduler.cpp.

                                    {
 
    Process* current_process = nullptr;
 
    // Find the process that has the thread being executed
    for (auto process: m_processes)
        if (process->pid() == current_thread()->parent_pid) {
            current_process = process;
            break;
        }
 
    return current_process;
}

References current_process(), current_thread(), MaxOS::processes::Thread::parent_pid, and MaxOS::processes::Process::pid().

Referenced by MaxOS::processes::GlobalScheduler::current_process(), current_process(), and schedule_next().

◆ current_thread()

Thread * Scheduler::current_thread ( )

Gets the currently executing thread.

Returns: The currently executing thread

Definition at line 691 of file scheduler.cpp.

                                  {
 
    return m_threads[m_next_thread_index];
}

Referenced by current_process(), MaxOS::processes::GlobalScheduler::current_thread(), force_remove_process(), schedule(), schedule_next(), and yield().

◆ deactivate()

void Scheduler::deactivate ( )

Deactivates the scheduler.

Definition at line 707 of file scheduler.cpp.

                           {
 
    m_active = false;
}

◆ force_remove_process()

cpu_status_t * Scheduler::force_remove_process ( Process * process )

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

                                                              {
 
    // If there is no process, fail
    if (!process)
        return nullptr;
 
    // Remove all the threads
    for (auto thread: process->threads()) {
 
        // Remove the thread from the scheduler
        size_t index = m_threads.find(thread) - m_threads.begin();
        m_threads.erase(m_threads.begin() + index);
 
        // Delete the thread
        process->remove_thread(thread->tid);
 
    }
 
    // Process will be dead now so run the next process (don't care about the execution state being outdated as it is being
    // removed regardless)
    return schedule_next(&current_thread()->execution_state);
}

References current_thread(), MaxOS::processes::Process::remove_thread(), schedule_next(), MaxOS::processes::Process::threads(), and MaxOS::processes::Thread::tid.

◆ get_process()

Process * Scheduler::get_process ( uint64_t pid )

Gets a process by its PID.

Parameters

pid	The process ID

Returns: The process or nullptr if not found

Definition at line 667 of file scheduler.cpp.

                                            {
 
    // Try to find the process
    for (auto process: m_processes)
        if (process->pid() == pid)
            return process;
 
    // Not found
    return nullptr;
}

References MaxOS::processes::Process::pid().

◆ get_thread()

Thread * Scheduler::get_thread ( uint64_t tid )

Gets a thread by its TID.

Parameters

tid	The thread ID

Returns: The thread or nullptr if not found

Definition at line 718 of file scheduler.cpp.

                                          {
 
    // Try to find the thread
    for (auto thread: m_threads)
        if (thread->tid == tid)
            return thread;
 
    return nullptr;
}

References MaxOS::processes::Thread::tid.

◆ process_amount()

uint64_t Scheduler::process_amount ( )

Gets how processes are running on this scheduler.

Returns: The amount

Definition at line 682 of file scheduler.cpp.

                                   {
    return m_processes.size();
}

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

◆ remove_process()

uint64_t Scheduler::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)

Parameters

process The process to remove

Returns: -1 if the process has threads, 0 otherwise

Definition at line 584 of file scheduler.cpp.

                                                   {
 
    // Check if the process has no threads
    if (!process->threads().empty()) {
 
        // Set the threads to stopped or remove them if forced
        for (auto thread: process->threads())
            thread->thread_state = ThreadState::STOPPED;
 
        // Need to wait until the threads are stopped before removing the process (this will be called again when all threads are stopped)
        return -1;
 
    }
 
    // Remove the process
    for (uint32_t i = 0; i < m_processes.size(); i++) {
        if (m_processes[i] == process) {
            m_processes.erase(m_processes.begin() + i);
 
            // Delete the process mem
            delete process;
            return 0;
        }
    }
 
    // Process not found
    return -1;
}

References MaxOS::processes::Thread::thread_state, and MaxOS::processes::Process::threads().

Referenced by schedule_next().

◆ schedule()

cpu_status_t * Scheduler::schedule ( system::cpu_status_t * cpu_state )

Schedules the next thread to run.

Parameters

cpu_state The current CPU state

Returns: The next CPU state

Definition at line 387 of file scheduler.cpp.

                                                         {
 
    // Scheduler cant schedule anything
    if (m_threads.empty() || !m_active)
        return cpu_state;
 
    // Thread that we are dealing with
    Thread* current_thread = m_threads[m_next_thread_index];
 
    // Ticked
    m_ticks++;
    current_thread->ticks++;
 
    // Thread hasn't used its time slot yet
    if(current_thread->ticks % TICKS_PER_EVENT)
        return cpu_state;
 
    // Schedule the next thread
    return schedule_next(cpu_state);
}

References current_thread(), schedule_next(), MaxOS::processes::Thread::ticks, and MaxOS::processes::TICKS_PER_EVENT.

Referenced by MaxOS::processes::GlobalScheduler::handle_interrupt().

◆ schedule_next()

cpu_status_t * Scheduler::schedule_next ( system::cpu_status_t * status )

Schedules the next thread to run.

Parameters

status The current CPU status of the thread

Returns: The next CPU status

Todo:: Remove by reference where possible

Definition at line 416 of file scheduler.cpp.

                                                              {
 
    // Get the current state
    Thread* current_thread = m_threads[m_next_thread_index];
    Process* owner_process = current_process();
    auto old_tid = m_next_thread_index;
 
    // Save the executing thread state
    current_thread->execution_state = *cpu_state;
    current_thread->save_sse_state();
    if (current_thread->thread_state == ThreadState::RUNNING)
        current_thread->thread_state = ThreadState::READY;
 
    // Find a free thread to run
    while ((++m_next_thread_index) != old_tid){
        m_next_thread_index %= m_threads.size();
 
        // Get the current thread
        current_thread = m_threads[m_next_thread_index];
        owner_process = current_process();
 
        // Handle state changes
        switch (current_thread->thread_state) {
 
            case ThreadState::SLEEPING:
 
                // If the wake-up time hasn't occurred yet, run the next thread
                if (current_thread->wakeup_time > TICKS_PER_EVENT){
                    current_thread->wakeup_time -= TICKS_PER_EVENT;
                    continue;
                }
 
                break;
 
            case ThreadState::STOPPED:
 
                // Find the process that has the thread and remove it
                for (auto thread: owner_process->threads()) {
                    if (thread == current_thread) {
                        owner_process->remove_thread(thread->tid);
                        break;
                    }
                }
 
                // Remove the thread
                m_threads.erase(m_threads.begin() + m_next_thread_index);
                if(owner_process->threads().empty())
                    remove_process(owner_process);
                continue;
 
            case ThreadState::WAITING:
                continue;
 
            default:
                break;
        }
        break;
    }
 
    // Load the thread's state
    return load_process(owner_process, current_thread);
}

References current_process(), current_thread(), MaxOS::processes::Thread::execution_state, remove_process(), MaxOS::processes::Process::remove_thread(), MaxOS::processes::Thread::save_sse_state(), MaxOS::processes::Thread::thread_state, MaxOS::processes::Process::threads(), MaxOS::processes::TICKS_PER_EVENT, and MaxOS::processes::Thread::wakeup_time.

Referenced by force_remove_process(), schedule(), and yield().

◆ thread_amount()

uint64_t Scheduler::thread_amount ( )

Gets how many threads are running on this scheduler.

Returns: The amount

Definition at line 700 of file scheduler.cpp.

                                 {
    return m_threads.size();
}

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

◆ ticks()

uint64_t Scheduler::ticks ( ) const

Gets how long the system has been running for.

Returns: The number of ticks

Definition at line 545 of file scheduler.cpp.

                                {
 
    return m_ticks;
}

◆ yield()

cpu_status_t * Scheduler::yield ( )

Pass execution to the next thread.

Returns: The cpu state of the next thread to run

Definition at line 555 of file scheduler.cpp.

                               {
 
    // If this is the only thread, can't yield
    if (m_threads.size() <= 1)
        return &current_thread()->execution_state;
 
    // Set the current thread to waiting if running
    auto thread = current_thread();
    if (thread->thread_state == ThreadState::RUNNING)
        thread->thread_state = ThreadState::READY;
 
    // Schedule the next thread
    return schedule_next(&thread->execution_state);
}

References current_thread(), MaxOS::processes::Thread::execution_state, schedule_next(), and MaxOS::processes::Thread::thread_state.

Referenced by MaxOS::processes::GlobalScheduler::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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Scheduler()

Member Function Documentation

◆ activate()

◆ add_process()

◆ add_thread()

◆ current_process()

◆ current_thread()

◆ deactivate()

◆ force_remove_process()

◆ get_process()

◆ get_thread()

◆ process_amount()

◆ remove_process()

◆ schedule()

◆ schedule_next()

◆ thread_amount()

◆ ticks()

◆ yield()