spinlock.cpp

Go to the documentation of this file.

 
#include <common/spinlock.h>
#include <processes/scheduler.h>
 
using namespace MaxOS;
using namespace MaxOS::common;
using namespace MaxOS::processes;
using namespace MaxOS::system;
using namespace MaxOS::hardwarecommunication;
 
Spinlock::Spinlock() = default;
Spinlock::~Spinlock() = default;
 
void Spinlock::lock() {
    acquire();
    m_locked = true;
}
 
void Spinlock::unlock() {
 
    m_locked = false;
    release();
}
 
bool Spinlock::is_locked() const {
    return m_locked;
}
 
 
void Spinlock::acquire() {
    while (__atomic_test_and_set(&m_locked, __ATOMIC_ACQUIRE))
        asm("nop");
}
 
void Spinlock::release() {
    __atomic_clear(&m_locked, __ATOMIC_RELEASE);
}
 
BlockingLock::BlockingLock() = default;
BlockingLock::~BlockingLock() = default;
 
bool BlockingLock::must_spin() {
    return GlobalScheduler::is_active();
}
 
void BlockingLock::lock() {
    acquire();
    m_locked = true;
}
 
void BlockingLock::unlock() {
 
    m_locked = false;
    release();
}
 
bool BlockingLock::is_locked() const {
    return m_locked;
}
 
void BlockingLock::acquire() {
 
    // Try to get the lock
    for (int i = 0; (i < BLOCKING_FAST_TRY_LIMIT || must_spin()); ++i)
        if(!__atomic_test_and_set(&m_locked, __ATOMIC_ACQUIRE))
            return;
 
    // Add to the queue
    auto thread = GlobalScheduler::current_thread();
    thread->thread_state = ThreadState::WAITING;
    m_queue.push_back(thread->tid);
 
    thread->save_cpu_state();
 
    // Guard against being resumed here
    if(thread->thread_state == ThreadState::WAITING){
 
        // Yield to the next thread
        cpu_status_t* next = GlobalScheduler::core_scheduler()->schedule_next(&thread->execution_state);
        InterruptManager::ForceInterruptReturn(next);
    }
 
 
}
 
void BlockingLock::release() {
 
    // Next thread can be run
    if(!m_queue.empty()){
        auto tid = m_queue.pop_front();
        GlobalScheduler::get_thread(tid)->thread_state = ThreadState::READY;
    }
 
    __atomic_clear(&m_locked, __ATOMIC_RELEASE);
}