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

#include <scheduler.h>

Public Member Functions
	Scheduler (uint64_t core_id)
	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.

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.

uint64_t	core_id () const
	Gets the core that this scheduler handles processes 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 90 of file scheduler.h.

Constructor & Destructor Documentation

◆ Scheduler()

Scheduler::Scheduler ( uint64_t core_id )

Constructs a new Scheduler object and creates the idle process.

Definition at line 417 of file scheduler.cpp.

: m_next_thread_index(0),
  m_active(false),
  m_ticks(0),
  m_core_id(core_id)
{
 
    // Name the idle
    string name = "Idle c";
    name += string(m_core_id);
 
    // Create this idle process
    auto* idle = new Process(name, nullptr, nullptr, 0, true);
    GlobalScheduler::system_scheduler()->add_process(idle, this);
 
    // Idle must use the correct kernel memory
    idle->memory_manager = MemoryManager::s_kernel_memory_manager;
    idle->threads()[0]->set_tss_pointer(CPU::cores[core_id]->tss.rsp0);
}

References MaxOS::processes::GlobalScheduler::add_process(), core_id(), MaxOS::system::CPU::cores, MaxOS::memory::MemoryManager::s_kernel_memory_manager, and MaxOS::processes::GlobalScheduler::system_scheduler().

Member Function Documentation

◆ activate()

void Scheduler::activate ( )

Activates the scheduler.

Definition at line 641 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 583 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().

◆ 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 605 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().

◆ core_id()

uint64_t Scheduler::core_id ( ) const

Gets the core that this scheduler handles processes for.

Returns: The id of the core

Definition at line 633 of file scheduler.cpp.

                                  {
 
    return m_core_id;
}

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

◆ current_process()

Process * Scheduler::current_process ( )

Gets the current process.

Returns: The current process, or nullptr if not found

Definition at line 715 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(), schedule(), and schedule_next().

◆ current_thread()

Thread * Scheduler::current_thread ( )

Gets the currently executing thread.

Returns: The currently executing thread

Definition at line 759 of file scheduler.cpp.

                                  {
 
    return m_threads[m_next_thread_index];
}

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

◆ deactivate()

void Scheduler::deactivate ( )

Deactivates the scheduler.

Definition at line 775 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 687 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 735 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 786 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 750 of file scheduler.cpp.

                                   {
    return m_processes.size();
}

◆ 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 652 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 446 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++;
 
    // The idle thread has no time slice to protect
    Process* running_process = current_process();
    if (running_process && running_process->is_kernel)
        return schedule_next(cpu_state);
 
    // 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_process(), current_thread(), MaxOS::processes::Process::is_kernel, 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 480 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;
    }
 
    int pid0 = m_processes.size() > 0 ? (int) m_processes[0]->pid() : -1;
    int pid1 = m_processes.size() > 1 ? (int) m_processes[1]->pid() : -1;
    int pid2 = m_processes.size() > 2 ? (int) m_processes[2]->pid() : -1;
    ASSERT(owner_process != nullptr, "No owner process: tid %d parent_pid %d core %d index %d threads %d processes %d pids %d %d %d\n",
        (int) current_thread->tid, (int) current_thread->parent_pid, (int) m_core_id,
        (int) m_next_thread_index, (int) m_threads.size(), (int) m_processes.size(), pid0, pid1, pid2);
 
 
    // Load the thread's state
    return load_process(owner_process, current_thread);
}

References current_process(), current_thread(), MaxOS::processes::Thread::execution_state, MaxOS::processes::Thread::parent_pid, 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, MaxOS::processes::Thread::tid, and MaxOS::processes::Thread::wakeup_time.

Referenced by force_remove_process(), schedule(), and MaxOS::processes::Thread::yield().

◆ thread_amount()

uint64_t Scheduler::thread_amount ( )

Gets how many threads are running on this scheduler.

Returns: The amount

Definition at line 768 of file scheduler.cpp.

                                 {
    return m_threads.size();
}

◆ ticks()

uint64_t Scheduler::ticks ( ) const

Gets how long the system has been running for.

Returns: The number of ticks

Definition at line 623 of file scheduler.cpp.

                                {
 
    return m_ticks;
}

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

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

◆ core_id()

◆ current_process()

◆ current_thread()

◆ deactivate()

◆ force_remove_process()

◆ get_process()

◆ get_thread()

◆ process_amount()

◆ remove_process()

◆ schedule()

◆ schedule_next()

◆ thread_amount()

◆ ticks()