ladybird/Kernel/Lock.cpp
Andreas Kling f067730f6b Kernel: Add a WaitQueue for Thread queueing/waking and use it for Lock
The kernel's Lock class now uses a proper wait queue internally instead
of just having everyone wake up regularly to try to acquire the lock.

We also keep the donation mechanism, so that whenever someone tries to
take the lock and fails, that thread donates the remainder of its
timeslice to the current lock holder.

After unlocking a Lock, the unlocking thread calls WaitQueue::wake_one,
which unblocks the next thread in queue.
2019-12-01 12:07:43 +01:00

76 lines
2.3 KiB
C++

#include <Kernel/Lock.h>
#include <Kernel/Thread.h>
void Lock::lock()
{
ASSERT(!Scheduler::is_active());
if (!are_interrupts_enabled()) {
kprintf("Interrupts disabled when trying to take Lock{%s}\n", m_name);
dump_backtrace();
hang();
}
for (;;) {
bool expected = false;
if (m_lock.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
if (!m_holder || m_holder == current) {
m_holder = current;
++m_level;
m_lock.store(false, AK::memory_order_release);
return;
}
m_lock.store(false, AK::memory_order_release);
(void)current->donate_remaining_timeslice_and_block<Thread::WaitQueueBlocker>(m_holder, m_name, m_queue);
}
}
}
void Lock::unlock()
{
for (;;) {
bool expected = false;
if (m_lock.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
ASSERT(m_holder == current);
ASSERT(m_level);
--m_level;
if (m_level) {
m_lock.store(false, AK::memory_order_release);
return;
}
m_holder = nullptr;
m_queue.wake_one();
m_lock.store(false, AK::memory_order_release);
return;
}
// I don't know *who* is using "m_lock", so just yield.
Scheduler::yield();
}
}
bool Lock::unlock_if_locked()
{
for (;;) {
bool expected = false;
if (m_lock.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
if (m_level == 0) {
m_lock.store(false, AK::memory_order_release);
return false;
}
if (m_holder != current) {
m_lock.store(false, AK::memory_order_release);
return false;
}
ASSERT(m_level);
--m_level;
if (m_level) {
m_lock.store(false, AK::memory_order_release);
return false;
}
m_holder = nullptr;
m_lock.store(false, AK::memory_order_release);
m_queue.wake_one();
return true;
}
// I don't know *who* is using "m_lock", so just yield.
Scheduler::yield();
}
}