mirror of
				https://git.zaroz.cloud/nintendo-back-up/yuzu/yuzu-mainline.git
				synced 2025-03-21 01:53:15 +00:00 
			
		
		
		
	kernel: Use Scheduler class for threading.
This commit is contained in:
		
							parent
							
								
									c78d495161
								
							
						
					
					
						commit
						ac81c02ed9
					
				@ -133,7 +133,7 @@ void System::Reschedule() {
 | 
				
			|||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    reschedule_pending = false;
 | 
					    reschedule_pending = false;
 | 
				
			||||||
    Kernel::Reschedule();
 | 
					    Core::System::GetInstance().Scheduler().Reschedule();
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 | 
					System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 | 
				
			||||||
@ -154,6 +154,7 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 | 
				
			|||||||
        break;
 | 
					        break;
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
 | 
					    scheduler = std::make_unique<Kernel::Scheduler>(cpu_core);
 | 
				
			||||||
    gpu_core = std::make_unique<Tegra::GPU>();
 | 
					    gpu_core = std::make_unique<Tegra::GPU>();
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    telemetry_session = std::make_unique<Core::TelemetrySession>();
 | 
					    telemetry_session = std::make_unique<Core::TelemetrySession>();
 | 
				
			||||||
 | 
				
			|||||||
@ -7,6 +7,7 @@
 | 
				
			|||||||
#include <memory>
 | 
					#include <memory>
 | 
				
			||||||
#include <string>
 | 
					#include <string>
 | 
				
			||||||
#include "common/common_types.h"
 | 
					#include "common/common_types.h"
 | 
				
			||||||
 | 
					#include "core/hle/kernel/scheduler.h"
 | 
				
			||||||
#include "core/loader/loader.h"
 | 
					#include "core/loader/loader.h"
 | 
				
			||||||
#include "core/memory.h"
 | 
					#include "core/memory.h"
 | 
				
			||||||
#include "core/perf_stats.h"
 | 
					#include "core/perf_stats.h"
 | 
				
			||||||
@ -107,6 +108,10 @@ public:
 | 
				
			|||||||
        return *gpu_core;
 | 
					        return *gpu_core;
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
 | 
					    Kernel::Scheduler& Scheduler() {
 | 
				
			||||||
 | 
					        return *scheduler;
 | 
				
			||||||
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    PerfStats perf_stats;
 | 
					    PerfStats perf_stats;
 | 
				
			||||||
    FrameLimiter frame_limiter;
 | 
					    FrameLimiter frame_limiter;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
@ -141,6 +146,7 @@ private:
 | 
				
			|||||||
    std::unique_ptr<Loader::AppLoader> app_loader;
 | 
					    std::unique_ptr<Loader::AppLoader> app_loader;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    std::shared_ptr<ARM_Interface> cpu_core;
 | 
					    std::shared_ptr<ARM_Interface> cpu_core;
 | 
				
			||||||
 | 
					    std::unique_ptr<Kernel::Scheduler> scheduler;
 | 
				
			||||||
    std::unique_ptr<Tegra::GPU> gpu_core;
 | 
					    std::unique_ptr<Tegra::GPU> gpu_core;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    /// When true, signals that a reschedule should happen
 | 
					    /// When true, signals that a reschedule should happen
 | 
				
			||||||
 | 
				
			|||||||
@ -483,7 +483,7 @@ static void ExitProcess() {
 | 
				
			|||||||
    g_current_process->status = ProcessStatus::Exited;
 | 
					    g_current_process->status = ProcessStatus::Exited;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    // Stop all the process threads that are currently waiting for objects.
 | 
					    // Stop all the process threads that are currently waiting for objects.
 | 
				
			||||||
    auto& thread_list = GetThreadList();
 | 
					    auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
 | 
				
			||||||
    for (auto& thread : thread_list) {
 | 
					    for (auto& thread : thread_list) {
 | 
				
			||||||
        if (thread->owner_process != g_current_process)
 | 
					        if (thread->owner_process != g_current_process)
 | 
				
			||||||
            continue;
 | 
					            continue;
 | 
				
			||||||
@ -585,7 +585,7 @@ static void SleepThread(s64 nanoseconds) {
 | 
				
			|||||||
 | 
					
 | 
				
			||||||
    // Don't attempt to yield execution if there are no available threads to run,
 | 
					    // Don't attempt to yield execution if there are no available threads to run,
 | 
				
			||||||
    // this way we avoid a useless reschedule to the idle thread.
 | 
					    // this way we avoid a useless reschedule to the idle thread.
 | 
				
			||||||
    if (nanoseconds == 0 && !HaveReadyThreads())
 | 
					    if (nanoseconds == 0 && !Core::System::GetInstance().Scheduler().HaveReadyThreads())
 | 
				
			||||||
        return;
 | 
					        return;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    // Sleep current thread and check for next thread to schedule
 | 
					    // Sleep current thread and check for next thread to schedule
 | 
				
			||||||
 | 
				
			|||||||
@ -41,14 +41,6 @@ void Thread::Acquire(Thread* thread) {
 | 
				
			|||||||
//               us to simply use a pool index or similar.
 | 
					//               us to simply use a pool index or similar.
 | 
				
			||||||
static Kernel::HandleTable wakeup_callback_handle_table;
 | 
					static Kernel::HandleTable wakeup_callback_handle_table;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
// Lists all thread ids that aren't deleted/etc.
 | 
					 | 
				
			||||||
static std::vector<SharedPtr<Thread>> thread_list;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
// Lists only ready thread ids.
 | 
					 | 
				
			||||||
static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
static SharedPtr<Thread> current_thread;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
// The first available thread id at startup
 | 
					// The first available thread id at startup
 | 
				
			||||||
static u32 next_thread_id;
 | 
					static u32 next_thread_id;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
@ -63,10 +55,6 @@ inline static u32 const NewThreadId() {
 | 
				
			|||||||
Thread::Thread() {}
 | 
					Thread::Thread() {}
 | 
				
			||||||
Thread::~Thread() {}
 | 
					Thread::~Thread() {}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
Thread* GetCurrentThread() {
 | 
					 | 
				
			||||||
    return current_thread.get();
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
/**
 | 
					/**
 | 
				
			||||||
 * Check if the specified thread is waiting on the specified address to be arbitrated
 | 
					 * Check if the specified thread is waiting on the specified address to be arbitrated
 | 
				
			||||||
 * @param thread The thread to test
 | 
					 * @param thread The thread to test
 | 
				
			||||||
@ -86,7 +74,7 @@ void Thread::Stop() {
 | 
				
			|||||||
    // Clean up thread from ready queue
 | 
					    // Clean up thread from ready queue
 | 
				
			||||||
    // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
 | 
					    // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
 | 
				
			||||||
    if (status == THREADSTATUS_READY) {
 | 
					    if (status == THREADSTATUS_READY) {
 | 
				
			||||||
        ready_queue.remove(current_priority, this);
 | 
					        Core::System::GetInstance().Scheduler().UnscheduleThread(this, current_priority);
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    status = THREADSTATUS_DEAD;
 | 
					    status = THREADSTATUS_DEAD;
 | 
				
			||||||
@ -109,78 +97,6 @@ void Thread::Stop() {
 | 
				
			|||||||
    Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
 | 
					    Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Switches the CPU's active thread context to that of the specified thread
 | 
					 | 
				
			||||||
 * @param new_thread The thread to switch to
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
static void SwitchContext(Thread* new_thread) {
 | 
					 | 
				
			||||||
    Thread* previous_thread = GetCurrentThread();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    // Save context for previous thread
 | 
					 | 
				
			||||||
    if (previous_thread) {
 | 
					 | 
				
			||||||
        previous_thread->last_running_ticks = CoreTiming::GetTicks();
 | 
					 | 
				
			||||||
        Core::CPU().SaveContext(previous_thread->context);
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        if (previous_thread->status == THREADSTATUS_RUNNING) {
 | 
					 | 
				
			||||||
            // This is only the case when a reschedule is triggered without the current thread
 | 
					 | 
				
			||||||
            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
 | 
					 | 
				
			||||||
            ready_queue.push_front(previous_thread->current_priority, previous_thread);
 | 
					 | 
				
			||||||
            previous_thread->status = THREADSTATUS_READY;
 | 
					 | 
				
			||||||
        }
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    // Load context of new thread
 | 
					 | 
				
			||||||
    if (new_thread) {
 | 
					 | 
				
			||||||
        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
 | 
					 | 
				
			||||||
                   "Thread must be ready to become running.");
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        // Cancel any outstanding wakeup events for this thread
 | 
					 | 
				
			||||||
        CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle);
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        auto previous_process = Kernel::g_current_process;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        current_thread = new_thread;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        ready_queue.remove(new_thread->current_priority, new_thread);
 | 
					 | 
				
			||||||
        new_thread->status = THREADSTATUS_RUNNING;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        if (previous_process != current_thread->owner_process) {
 | 
					 | 
				
			||||||
            Kernel::g_current_process = current_thread->owner_process;
 | 
					 | 
				
			||||||
            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
 | 
					 | 
				
			||||||
        }
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
        Core::CPU().LoadContext(new_thread->context);
 | 
					 | 
				
			||||||
        Core::CPU().SetTlsAddress(new_thread->GetTLSAddress());
 | 
					 | 
				
			||||||
    } else {
 | 
					 | 
				
			||||||
        current_thread = nullptr;
 | 
					 | 
				
			||||||
        // Note: We do not reset the current process and current page table when idling because
 | 
					 | 
				
			||||||
        // technically we haven't changed processes, our threads are just paused.
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Pops and returns the next thread from the thread queue
 | 
					 | 
				
			||||||
 * @return A pointer to the next ready thread
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
static Thread* PopNextReadyThread() {
 | 
					 | 
				
			||||||
    Thread* next;
 | 
					 | 
				
			||||||
    Thread* thread = GetCurrentThread();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    if (thread && thread->status == THREADSTATUS_RUNNING) {
 | 
					 | 
				
			||||||
        // We have to do better than the current thread.
 | 
					 | 
				
			||||||
        // This call returns null when that's not possible.
 | 
					 | 
				
			||||||
        next = ready_queue.pop_first_better(thread->current_priority);
 | 
					 | 
				
			||||||
        if (!next) {
 | 
					 | 
				
			||||||
            // Otherwise just keep going with the current thread
 | 
					 | 
				
			||||||
            next = thread;
 | 
					 | 
				
			||||||
        }
 | 
					 | 
				
			||||||
    } else {
 | 
					 | 
				
			||||||
        next = ready_queue.pop_first();
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    return next;
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
void WaitCurrentThread_Sleep() {
 | 
					void WaitCurrentThread_Sleep() {
 | 
				
			||||||
    Thread* thread = GetCurrentThread();
 | 
					    Thread* thread = GetCurrentThread();
 | 
				
			||||||
    thread->status = THREADSTATUS_WAIT_SLEEP;
 | 
					    thread->status = THREADSTATUS_WAIT_SLEEP;
 | 
				
			||||||
@ -195,8 +111,7 @@ void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) {
 | 
				
			|||||||
void ExitCurrentThread() {
 | 
					void ExitCurrentThread() {
 | 
				
			||||||
    Thread* thread = GetCurrentThread();
 | 
					    Thread* thread = GetCurrentThread();
 | 
				
			||||||
    thread->Stop();
 | 
					    thread->Stop();
 | 
				
			||||||
    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
 | 
					    Core::System::GetInstance().Scheduler().RemoveThread(thread);
 | 
				
			||||||
                      thread_list.end());
 | 
					 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
/**
 | 
					/**
 | 
				
			||||||
@ -274,31 +189,11 @@ void Thread::ResumeFromWait() {
 | 
				
			|||||||
 | 
					
 | 
				
			||||||
    wakeup_callback = nullptr;
 | 
					    wakeup_callback = nullptr;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    ready_queue.push_back(current_priority, this);
 | 
					 | 
				
			||||||
    status = THREADSTATUS_READY;
 | 
					    status = THREADSTATUS_READY;
 | 
				
			||||||
 | 
					    Core::System::GetInstance().Scheduler().ScheduleThread(this, current_priority);
 | 
				
			||||||
    Core::System::GetInstance().PrepareReschedule();
 | 
					    Core::System::GetInstance().PrepareReschedule();
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Prints the thread queue for debugging purposes
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
static void DebugThreadQueue() {
 | 
					 | 
				
			||||||
    Thread* thread = GetCurrentThread();
 | 
					 | 
				
			||||||
    if (!thread) {
 | 
					 | 
				
			||||||
        LOG_DEBUG(Kernel, "Current: NO CURRENT THREAD");
 | 
					 | 
				
			||||||
    } else {
 | 
					 | 
				
			||||||
        LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority,
 | 
					 | 
				
			||||||
                  GetCurrentThread()->GetObjectId());
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    for (auto& t : thread_list) {
 | 
					 | 
				
			||||||
        u32 priority = ready_queue.contains(t.get());
 | 
					 | 
				
			||||||
        if (priority != -1) {
 | 
					 | 
				
			||||||
            LOG_DEBUG(Kernel, "0x%02X %u", priority, t->GetObjectId());
 | 
					 | 
				
			||||||
        }
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
/**
 | 
					/**
 | 
				
			||||||
 * Finds a free location for the TLS section of a thread.
 | 
					 * Finds a free location for the TLS section of a thread.
 | 
				
			||||||
 * @param tls_slots The TLS page array of the thread's owner process.
 | 
					 * @param tls_slots The TLS page array of the thread's owner process.
 | 
				
			||||||
@ -366,8 +261,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 | 
				
			|||||||
 | 
					
 | 
				
			||||||
    SharedPtr<Thread> thread(new Thread);
 | 
					    SharedPtr<Thread> thread(new Thread);
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    thread_list.push_back(thread);
 | 
					    Core::System::GetInstance().Scheduler().AddThread(thread, priority);
 | 
				
			||||||
    ready_queue.prepare(priority);
 | 
					 | 
				
			||||||
 | 
					
 | 
				
			||||||
    thread->thread_id = NewThreadId();
 | 
					    thread->thread_id = NewThreadId();
 | 
				
			||||||
    thread->status = THREADSTATUS_DORMANT;
 | 
					    thread->status = THREADSTATUS_DORMANT;
 | 
				
			||||||
@ -438,12 +332,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 | 
				
			|||||||
void Thread::SetPriority(u32 priority) {
 | 
					void Thread::SetPriority(u32 priority) {
 | 
				
			||||||
    ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
 | 
					    ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
 | 
				
			||||||
               "Invalid priority value.");
 | 
					               "Invalid priority value.");
 | 
				
			||||||
    // If thread was ready, adjust queues
 | 
					    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
 | 
				
			||||||
    if (status == THREADSTATUS_READY)
 | 
					 | 
				
			||||||
        ready_queue.move(this, current_priority, priority);
 | 
					 | 
				
			||||||
    else
 | 
					 | 
				
			||||||
        ready_queue.prepare(priority);
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    nominal_priority = current_priority = priority;
 | 
					    nominal_priority = current_priority = priority;
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
@ -457,11 +346,7 @@ void Thread::UpdatePriority() {
 | 
				
			|||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
void Thread::BoostPriority(u32 priority) {
 | 
					void Thread::BoostPriority(u32 priority) {
 | 
				
			||||||
    // If thread was ready, adjust queues
 | 
					    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
 | 
				
			||||||
    if (status == THREADSTATUS_READY)
 | 
					 | 
				
			||||||
        ready_queue.move(this, current_priority, priority);
 | 
					 | 
				
			||||||
    else
 | 
					 | 
				
			||||||
        ready_queue.prepare(priority);
 | 
					 | 
				
			||||||
    current_priority = priority;
 | 
					    current_priority = priority;
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
@ -487,25 +372,6 @@ SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
 | 
				
			|||||||
    return thread;
 | 
					    return thread;
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
bool HaveReadyThreads() {
 | 
					 | 
				
			||||||
    return ready_queue.get_first() != nullptr;
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
void Reschedule() {
 | 
					 | 
				
			||||||
    Thread* cur = GetCurrentThread();
 | 
					 | 
				
			||||||
    Thread* next = PopNextReadyThread();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    if (cur && next) {
 | 
					 | 
				
			||||||
        LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
 | 
					 | 
				
			||||||
    } else if (cur) {
 | 
					 | 
				
			||||||
        LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
 | 
					 | 
				
			||||||
    } else if (next) {
 | 
					 | 
				
			||||||
        LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    SwitchContext(next);
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
void Thread::SetWaitSynchronizationResult(ResultCode result) {
 | 
					void Thread::SetWaitSynchronizationResult(ResultCode result) {
 | 
				
			||||||
    context.cpu_registers[0] = result.raw;
 | 
					    context.cpu_registers[0] = result.raw;
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
@ -528,25 +394,18 @@ VAddr Thread::GetCommandBufferAddress() const {
 | 
				
			|||||||
 | 
					
 | 
				
			||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
 | 
					////////////////////////////////////////////////////////////////////////////////////////////////////
 | 
				
			||||||
 | 
					
 | 
				
			||||||
 | 
					/**
 | 
				
			||||||
 | 
					 * Gets the current thread
 | 
				
			||||||
 | 
					 */
 | 
				
			||||||
 | 
					Thread* GetCurrentThread() {
 | 
				
			||||||
 | 
					    return Core::System::GetInstance().Scheduler().GetCurrentThread();
 | 
				
			||||||
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
void ThreadingInit() {
 | 
					void ThreadingInit() {
 | 
				
			||||||
    ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
 | 
					    ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
 | 
				
			||||||
 | 
					 | 
				
			||||||
    current_thread = nullptr;
 | 
					 | 
				
			||||||
    next_thread_id = 1;
 | 
					    next_thread_id = 1;
 | 
				
			||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
void ThreadingShutdown() {
 | 
					void ThreadingShutdown() {}
 | 
				
			||||||
    current_thread = nullptr;
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
    for (auto& t : thread_list) {
 | 
					 | 
				
			||||||
        t->Stop();
 | 
					 | 
				
			||||||
    }
 | 
					 | 
				
			||||||
    thread_list.clear();
 | 
					 | 
				
			||||||
    ready_queue.clear();
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
const std::vector<SharedPtr<Thread>>& GetThreadList() {
 | 
					 | 
				
			||||||
    return thread_list;
 | 
					 | 
				
			||||||
}
 | 
					 | 
				
			||||||
 | 
					
 | 
				
			||||||
} // namespace Kernel
 | 
					} // namespace Kernel
 | 
				
			||||||
 | 
				
			|||||||
@ -249,16 +249,6 @@ private:
 | 
				
			|||||||
SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
 | 
					SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
 | 
				
			||||||
                                  SharedPtr<Process> owner_process);
 | 
					                                  SharedPtr<Process> owner_process);
 | 
				
			||||||
 | 
					
 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Returns whether there are any threads that are ready to run.
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
bool HaveReadyThreads();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Reschedules to the next available thread (call after current thread is suspended)
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
void Reschedule();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
/**
 | 
					/**
 | 
				
			||||||
 * Gets the current thread
 | 
					 * Gets the current thread
 | 
				
			||||||
 */
 | 
					 */
 | 
				
			||||||
@ -290,9 +280,4 @@ void ThreadingInit();
 | 
				
			|||||||
 */
 | 
					 */
 | 
				
			||||||
void ThreadingShutdown();
 | 
					void ThreadingShutdown();
 | 
				
			||||||
 | 
					
 | 
				
			||||||
/**
 | 
					 | 
				
			||||||
 * Get a const reference to the thread list for debug use
 | 
					 | 
				
			||||||
 */
 | 
					 | 
				
			||||||
const std::vector<SharedPtr<Thread>>& GetThreadList();
 | 
					 | 
				
			||||||
 | 
					 | 
				
			||||||
} // namespace Kernel
 | 
					} // namespace Kernel
 | 
				
			||||||
 | 
				
			|||||||
@ -5,6 +5,7 @@
 | 
				
			|||||||
#include "yuzu/debugger/wait_tree.h"
 | 
					#include "yuzu/debugger/wait_tree.h"
 | 
				
			||||||
#include "yuzu/util/util.h"
 | 
					#include "yuzu/util/util.h"
 | 
				
			||||||
 | 
					
 | 
				
			||||||
 | 
					#include "core/core.h"
 | 
				
			||||||
#include "core/hle/kernel/condition_variable.h"
 | 
					#include "core/hle/kernel/condition_variable.h"
 | 
				
			||||||
#include "core/hle/kernel/event.h"
 | 
					#include "core/hle/kernel/event.h"
 | 
				
			||||||
#include "core/hle/kernel/mutex.h"
 | 
					#include "core/hle/kernel/mutex.h"
 | 
				
			||||||
@ -50,7 +51,7 @@ std::size_t WaitTreeItem::Row() const {
 | 
				
			|||||||
}
 | 
					}
 | 
				
			||||||
 | 
					
 | 
				
			||||||
std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList() {
 | 
					std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList() {
 | 
				
			||||||
    const auto& threads = Kernel::GetThreadList();
 | 
					    const auto& threads = Core::System::GetInstance().Scheduler().GetThreadList();
 | 
				
			||||||
    std::vector<std::unique_ptr<WaitTreeThread>> item_list;
 | 
					    std::vector<std::unique_ptr<WaitTreeThread>> item_list;
 | 
				
			||||||
    item_list.reserve(threads.size());
 | 
					    item_list.reserve(threads.size());
 | 
				
			||||||
    for (std::size_t i = 0; i < threads.size(); ++i) {
 | 
					    for (std::size_t i = 0; i < threads.size(); ++i) {
 | 
				
			||||||
 | 
				
			|||||||
		Loading…
	
		Reference in New Issue
	
	Block a user