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 <block.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

Todo:: move to libcommon

Definition at line 28 of file block.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

circular dependancy resolution

Definition at line 49 of file block.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);
 
    // Scheduler will awake when the process that holds this lock marks this thread as READY
    thread->yield();
}

References MaxOS::processes::BLOCKING_FAST_TRY_LIMIT, and MaxOS::processes::GlobalScheduler::current_thread().

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 39 of file block.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 23 of file block.cpp.

                        {
    acquire();
}

References acquire().

Referenced by MaxOS::processes::SharedMessageEndpoint::send().

◆ release()

void BlockingLock::release ( )

Mark as unlocked, wake the next enqueued thread.

Definition at line 68 of file block.cpp.

                           {
 
    // Next thread can be run
    if(!m_queue.empty())
        GlobalScheduler::get_thread(m_queue.pop_front())->thread_state = ThreadState::READY;
 
    __atomic_clear(&m_locked, __ATOMIC_RELEASE);
}

References MaxOS::processes::GlobalScheduler::get_thread(), and MaxOS::processes::Thread::thread_state.

Referenced by unlock().

◆ unlock()

void BlockingLock::unlock ( )

Unlock the spinlock.

Definition at line 30 of file block.cpp.

                          {
    release();
}

References release().