diff options
author | bunnei <bunneidev@gmail.com> | 2020-11-28 22:34:07 +0100 |
---|---|---|
committer | bunnei <bunneidev@gmail.com> | 2020-12-06 09:03:24 +0100 |
commit | 7e5d0f1fe311663329bc15b9e387f3ce2083dcf0 (patch) | |
tree | 350e07db8895fae85859b61010dd85a09f46039d /src/core/hle/kernel/k_scheduler_lock.h | |
parent | hle: kernel: svc: Remove reschedule on svcBreak. (diff) | |
download | yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar.gz yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar.bz2 yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar.lz yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar.xz yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.tar.zst yuzu-7e5d0f1fe311663329bc15b9e387f3ce2083dcf0.zip |
Diffstat (limited to 'src/core/hle/kernel/k_scheduler_lock.h')
-rw-r--r-- | src/core/hle/kernel/k_scheduler_lock.h | 76 |
1 files changed, 76 insertions, 0 deletions
diff --git a/src/core/hle/kernel/k_scheduler_lock.h b/src/core/hle/kernel/k_scheduler_lock.h new file mode 100644 index 000000000..d46f5fc04 --- /dev/null +++ b/src/core/hle/kernel/k_scheduler_lock.h @@ -0,0 +1,76 @@ +// Copyright 2020 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +// This file references various implementation details from Atmosphere, an open-source firmware for +// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX. + +#pragma once + +#include "common/assert.h" +#include "common/spin_lock.h" +#include "core/hardware_properties.h" + +namespace Kernel { + +class KernelCore; + +template <typename SchedulerType> +class KAbstractSchedulerLock { +private: + KernelCore& kernel; + Common::SpinLock spin_lock; + s32 lock_count; + Core::EmuThreadHandle owner_thread; + +public: + KAbstractSchedulerLock(KernelCore& kernel) + : kernel{kernel}, spin_lock(), lock_count(0), + owner_thread(Core::EmuThreadHandle::InvalidHandle()) {} + + bool IsLockedByCurrentThread() const { + return this->owner_thread == kernel.GetCurrentEmuThreadID(); + } + + void Lock() { + if (this->IsLockedByCurrentThread()) { + /* If we already own the lock, we can just increment the count. */ + ASSERT(this->lock_count > 0); + this->lock_count++; + } else { + /* Otherwise, we want to disable scheduling and acquire the spinlock. */ + SchedulerType::DisableScheduling(kernel); + this->spin_lock.lock(); + + /* For debug, ensure that our state is valid. */ + ASSERT(this->lock_count == 0); + ASSERT(this->owner_thread == Core::EmuThreadHandle::InvalidHandle()); + + /* Increment count, take ownership. */ + this->lock_count = 1; + this->owner_thread = kernel.GetCurrentEmuThreadID(); + } + } + + void Unlock() { + ASSERT(this->IsLockedByCurrentThread()); + ASSERT(this->lock_count > 0); + + /* Release an instance of the lock. */ + if ((--this->lock_count) == 0) { + /* We're no longer going to hold the lock. Take note of what cores need scheduling. */ + const u64 cores_needing_scheduling = + SchedulerType::UpdateHighestPriorityThreads(kernel); + Core::EmuThreadHandle leaving_thread = owner_thread; + + /* Note that we no longer hold the lock, and unlock the spinlock. */ + this->owner_thread = Core::EmuThreadHandle::InvalidHandle(); + this->spin_lock.unlock(); + + /* Enable scheduling, and perform a rescheduling operation. */ + SchedulerType::EnableScheduling(kernel, cores_needing_scheduling, leaving_thread); + } + } +}; + +} // namespace Kernel |