Merge pull request #3038 from lioncash/docs

kernel/scheduler: Minor changes

src/core/hle/kernel/scheduler.cpp

@@ -22,9 +22,9 @@
 
 namespace Kernel {
 
-GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {
+GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {}
-    is_reselection_pending = false;
+
-}
+GlobalScheduler::~GlobalScheduler() = default;
 
 void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
     thread_list.push_back(std::move(thread));
@@ -35,24 +35,11 @@ void GlobalScheduler::RemoveThread(const Thread* thread) {
                       thread_list.end());
 }
 
-/*
- * UnloadThread selects a core and forces it to unload its current thread's context
- */
 void GlobalScheduler::UnloadThread(s32 core) {
     Scheduler& sched = system.Scheduler(core);
     sched.UnloadThread();
 }
 
-/*
- * SelectThread takes care of selecting the new scheduled thread.
- * It does it in 3 steps:
- * - First a thread is selected from the top of the priority queue. If no thread
- * is obtained then we move to step two, else we are done.
- * - Second we try to get a suggested thread that's not assigned to any core or
- * that is not the top thread in that core.
- * - Third is no suggested thread is found, we do a second pass and pick a running
- * thread in another core and swap it with its current thread.
- */
 void GlobalScheduler::SelectThread(u32 core) {
     const auto update_thread = [](Thread* thread, Scheduler& sched) {
         if (thread != sched.selected_thread) {
@@ -114,30 +101,19 @@ void GlobalScheduler::SelectThread(u32 core) {
     update_thread(current_thread, sched);
 }
 
-/*
- * YieldThread takes a thread and moves it to the back of the it's priority list
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
 bool GlobalScheduler::YieldThread(Thread* yielding_thread) {
     // Note: caller should use critical section, etc.
     const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
     const u32 priority = yielding_thread->GetPriority();
 
     // Yield the thread
-    ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
+    const Thread* const winner = scheduled_queue[core_id].front(priority);
-               "Thread yielding without being in front");
+    ASSERT_MSG(yielding_thread == winner, "Thread yielding without being in front");
     scheduled_queue[core_id].yield(priority);
 
-    Thread* winner = scheduled_queue[core_id].front(priority);
     return AskForReselectionOrMarkRedundant(yielding_thread, winner);
 }
 
-/*
- * YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
- * Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
- * a better priority than the next thread in the core.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
 bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
     // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
     // etc.
@@ -189,12 +165,6 @@ bool GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
     return AskForReselectionOrMarkRedundant(yielding_thread, winner);
 }
 
-/*
- * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
- * and into the suggested queue. If no thread can be squeduled afterwards in that core,
- * a suggested thread is obtained instead.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
 bool GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
     // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
     // etc.
@@ -280,7 +250,7 @@ void GlobalScheduler::PreemptThreads() {
             if (winner->IsRunning()) {
                 UnloadThread(winner->GetProcessorID());
             }
-            TransferToCore(winner->GetPriority(), core_id, winner);
+            TransferToCore(winner->GetPriority(), s32(core_id), winner);
             current_thread =
                 winner->GetPriority() <= current_thread->GetPriority() ? winner : current_thread;
         }
@@ -313,7 +283,7 @@ void GlobalScheduler::PreemptThreads() {
                 if (winner->IsRunning()) {
                     UnloadThread(winner->GetProcessorID());
                 }
-                TransferToCore(winner->GetPriority(), core_id, winner);
+                TransferToCore(winner->GetPriority(), s32(core_id), winner);
                 current_thread = winner;
             }
         }
@@ -331,12 +301,12 @@ void GlobalScheduler::Unsuggest(u32 priority, u32 core, Thread* thread) {
 }
 
 void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
+    ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
     scheduled_queue[core].add(thread, priority);
 }
 
 void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
+    ASSERT_MSG(thread->GetProcessorID() == s32(core), "Thread must be assigned to this core.");
     scheduled_queue[core].add(thread, priority, false);
 }
 
@@ -368,7 +338,8 @@ void GlobalScheduler::TransferToCore(u32 priority, s32 destination_core, Thread*
     }
 }
 
-bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) {
+bool GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread,
+                                                       const Thread* winner) {
     if (current_thread == winner) {
         current_thread->IncrementYieldCount();
         return true;
@@ -386,8 +357,6 @@ void GlobalScheduler::Shutdown() {
     thread_list.clear();
 }
 
-GlobalScheduler::~GlobalScheduler() = default;
-
 Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
     : system(system), cpu_core(cpu_core), core_id(core_id) {}
 
@@ -470,7 +439,7 @@ void Scheduler::SwitchContext() {
 
     // Load context of new thread
     if (new_thread) {
-        ASSERT_MSG(new_thread->GetProcessorID() == this->core_id,
+        ASSERT_MSG(new_thread->GetProcessorID() == s32(this->core_id),
                    "Thread must be assigned to this core.");
         ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
                    "Thread must be ready to become running.");

src/core/hle/kernel/scheduler.h

@@ -26,6 +26,7 @@ public:
 
     explicit GlobalScheduler(Core::System& system);
     ~GlobalScheduler();
+
     /// Adds a new thread to the scheduler
     void AddThread(SharedPtr<Thread> thread);
 
@@ -37,47 +38,57 @@ public:
         return thread_list;
     }
 
-    // Add a thread to the suggested queue of a cpu core. Suggested threads may be
+    /**
-    // picked if no thread is scheduled to run on the core.
+     * Add a thread to the suggested queue of a cpu core. Suggested threads may be
+     * picked if no thread is scheduled to run on the core.
+     */
     void Suggest(u32 priority, u32 core, Thread* thread);
 
-    // Remove a thread to the suggested queue of a cpu core. Suggested threads may be
+    /**
-    // picked if no thread is scheduled to run on the core.
+     * Remove a thread to the suggested queue of a cpu core. Suggested threads may be
+     * picked if no thread is scheduled to run on the core.
+     */
     void Unsuggest(u32 priority, u32 core, Thread* thread);
 
-    // Add a thread to the scheduling queue of a cpu core. The thread is added at the
+    /**
-    // back the queue in its priority level
+     * Add a thread to the scheduling queue of a cpu core. The thread is added at the
+     * back the queue in its priority level.
+     */
     void Schedule(u32 priority, u32 core, Thread* thread);
 
-    // Add a thread to the scheduling queue of a cpu core. The thread is added at the
+    /**
-    // front the queue in its priority level
+     * Add a thread to the scheduling queue of a cpu core. The thread is added at the
+     * front the queue in its priority level.
+     */
     void SchedulePrepend(u32 priority, u32 core, Thread* thread);
 
-    // Reschedule an already scheduled thread based on a new priority
+    /// Reschedule an already scheduled thread based on a new priority
     void Reschedule(u32 priority, u32 core, Thread* thread);
 
-    // Unschedule a thread.
+    /// Unschedules a thread.
     void Unschedule(u32 priority, u32 core, Thread* thread);
 
-    // Transfers a thread into an specific core. If the destination_core is -1
+    /**
-    // it will be unscheduled from its source code and added into its suggested
+     * Transfers a thread into an specific core. If the destination_core is -1
-    // queue.
+     * it will be unscheduled from its source code and added into its suggested
+     * queue.
+     */
     void TransferToCore(u32 priority, s32 destination_core, Thread* thread);
 
-    /*
+    /// Selects a core and forces it to unload its current thread's context
-     * UnloadThread selects a core and forces it to unload its current thread's context
-     */
     void UnloadThread(s32 core);
 
-    /*
+    /**
-     * SelectThread takes care of selecting the new scheduled thread.
+     * Takes care of selecting the new scheduled thread in three steps:
-     * It does it in 3 steps:
+     *
-     * - First a thread is selected from the top of the priority queue. If no thread
+     * 1. First a thread is selected from the top of the priority queue. If no thread
-     * is obtained then we move to step two, else we are done.
+     *    is obtained then we move to step two, else we are done.
-     * - Second we try to get a suggested thread that's not assigned to any core or
+     *
-     * that is not the top thread in that core.
+     * 2. Second we try to get a suggested thread that's not assigned to any core or
-     * - Third is no suggested thread is found, we do a second pass and pick a running
+     *    that is not the top thread in that core.
-     * thread in another core and swap it with its current thread.
+     *
+     * 3. Third is no suggested thread is found, we do a second pass and pick a running
+     *    thread in another core and swap it with its current thread.
      */
     void SelectThread(u32 core);
 
@@ -85,33 +96,37 @@ public:
         return !scheduled_queue[core_id].empty();
     }
 
-    /*
+    /**
-     * YieldThread takes a thread and moves it to the back of the it's priority list
+     * Takes a thread and moves it to the back of the it's priority list.
-     * This operation can be redundant and no scheduling is changed if marked as so.
+     *
+     * @note This operation can be redundant and no scheduling is changed if marked as so.
      */
     bool YieldThread(Thread* thread);
 
-    /*
+    /**
-     * YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
+     * Takes a thread and moves it to the back of the it's priority list.
      * Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
      * a better priority than the next thread in the core.
-     * This operation can be redundant and no scheduling is changed if marked as so.
+     *
+     * @note This operation can be redundant and no scheduling is changed if marked as so.
      */
     bool YieldThreadAndBalanceLoad(Thread* thread);
 
-    /*
+    /**
-     * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
+     * Takes a thread and moves it out of the scheduling queue.
-     * and into the suggested queue. If no thread can be squeduled afterwards in that core,
+     * and into the suggested queue. If no thread can be scheduled afterwards in that core,
      * a suggested thread is obtained instead.
-     * This operation can be redundant and no scheduling is changed if marked as so.
+     *
+     * @note This operation can be redundant and no scheduling is changed if marked as so.
      */
     bool YieldThreadAndWaitForLoadBalancing(Thread* thread);
 
-    /*
+    /**
-     * PreemptThreads this operation rotates the scheduling queues of threads at
+     * Rotates the scheduling queues of threads at a preemption priority and then does
-     * a preemption priority and then does some core rebalancing. Preemption priorities
+     * some core rebalancing. Preemption priorities can be found in the array
-     * can be found in the array 'preemption_priorities'. This operation happens
+     * 'preemption_priorities'.
-     * every 10ms.
+     *
+     * @note This operation happens every 10ms.
      */
     void PreemptThreads();
 
@@ -130,15 +145,15 @@ public:
     void Shutdown();
 
 private:
-    bool AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner);
+    bool AskForReselectionOrMarkRedundant(Thread* current_thread, const Thread* winner);
 
     static constexpr u32 min_regular_priority = 2;
     std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> scheduled_queue;
     std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue;
-    std::atomic<bool> is_reselection_pending;
+    std::atomic<bool> is_reselection_pending{false};
 
-    // `preemption_priorities` are the priority levels at which the global scheduler
+    // The priority levels at which the global scheduler preempts threads every 10 ms. They are
-    // preempts threads every 10 ms. They are ordered from Core 0 to Core 3
+    // ordered from Core 0 to Core 3.
     std::array<u32, NUM_CPU_CORES> preemption_priorities = {59, 59, 59, 62};
 
     /// Lists all thread ids that aren't deleted/etc.
@@ -181,10 +196,8 @@ public:
 
 private:
     friend class GlobalScheduler;
-    /**
+
-     * Switches the CPU's active thread context to that of the specified thread
+    /// Switches the CPU's active thread context to that of the specified thread
-     * @param new_thread The thread to switch to
-     */
     void SwitchContext();
 
     /**