MaxOS::common::BlockingLock Class Reference

Enables a resource to be used by only one instance at a time through a combination of spinning and queuing. When waiting enqueued, thread will sleep. More...

#include <spinlock.h>

Public Member Functions
void	lock ()
	Lock the spinlock once it is available, sleeping until other processes are done with it.
void	unlock ()
	Unlock the spinlock.
bool	is_locked () const
	Check if the spinlock is locked.
void	acquire ()
	Acquire the spinlock, spin until the lock is available and sleeping the thread until marked as available.
void	release ()
	Mark as unlocked, wake the next enqueued thread.

Detailed Description

Enables a resource to be used by only one instance at a time through a combination of spinning and queuing. When waiting enqueued, thread will sleep.

Note

Repeated API that could be made a class that isn't because lock types shouldn't be interchangeable

See also

Spinlock

Definition at line 49 of file spinlock.h.

Member Function Documentation

acquire()

void BlockingLock::acquire

(

)

Acquire the spinlock, spin until the lock is available and sleeping the thread until marked as available.

Todo:

Move the yielding logic into process/thread code so that it can be reused

Definition at line 101 of file spinlock.cpp.

                           {
 
    // 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);
    }
 
 
}

References MaxOS::common::BLOCKING_FAST_TRY_LIMIT, MaxOS::processes::GlobalScheduler::core_scheduler(), MaxOS::processes::GlobalScheduler::current_thread(), MaxOS::hardwarecommunication::InterruptManager::ForceInterruptReturn(), and MaxOS::common::Vector< Type >::push_back().

Referenced by lock().

is_locked()

bool BlockingLock::is_locked

(

)

const

Check if the spinlock is locked.

Returns

True if the spinlock is locked, false otherwise

Definition at line 92 of file spinlock.cpp.

                                   {
    return m_locked;
}

lock()

void BlockingLock::lock

(

)

Lock the spinlock once it is available, sleeping until other processes are done with it.

Definition at line 73 of file spinlock.cpp.

                        {
    acquire();
    m_locked = true;
}

References acquire().

release()

void BlockingLock::release

(

)

Mark as unlocked, wake the next enqueued thread.

Definition at line 129 of file spinlock.cpp.

                           {
 
    // 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);
}

References MaxOS::common::Vector< Type >::empty(), MaxOS::processes::GlobalScheduler::get_thread(), and MaxOS::common::Vector< Type >::pop_front().

Referenced by unlock().

unlock()

void BlockingLock::unlock

(

)

Unlock the spinlock.

Definition at line 81 of file spinlock.cpp.

                          {
 
    m_locked = false;
    release();
}

References release().

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/common/spinlock.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/common/spinlock.cpp