ksemaphore.cpp

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
===========================================================================*/
#include "mark3.h"

namespace Mark3
{
namespace
{
    //---------------------------------------------------------------------------
    void TimedSemaphore_Callback(Thread* pclOwner_, void* pvData_)
    {
        KERNEL_ASSERT(nullptr != pclOwner_);
        KERNEL_ASSERT(nullptr != pvData_);

        auto* pclSemaphore = static_cast<Semaphore*>(pvData_);

        // Indicate that the semaphore has expired on the thread
        pclOwner_->SetExpired(true);

        // Wake up the thread that was blocked on this semaphore.
        pclSemaphore->WakeMe(pclOwner_);

        if (pclOwner_->GetCurPriority() >= Scheduler::GetCurrentThread()->GetCurPriority()) {
            Thread::Yield();
        }
    }
} // anonymous namespace

//---------------------------------------------------------------------------
Semaphore::~Semaphore()
{
    // If there are any threads waiting on this object when it goes out
    // of scope, set a kernel panic.
    if (nullptr != m_clBlockList.GetHead()) {
        Kernel::Panic(PANIC_ACTIVE_SEMAPHORE_DESCOPED);
    }
}

//---------------------------------------------------------------------------
void Semaphore::WakeMe(Thread* pclChosenOne_)
{
    KERNEL_ASSERT(pclChosenOne_);
    KERNEL_ASSERT(IsInitialized());

    // Remove from the semaphore waitlist and back to its ready list.
    UnBlock(pclChosenOne_);
}

//---------------------------------------------------------------------------
uint8_t Semaphore::WakeNext()
{
    auto* pclChosenOne = m_clBlockList.HighestWaiter();
    KERNEL_ASSERT(pclChosenOne);

    // Remove from the semaphore waitlist and back to its ready list.
    UnBlock(pclChosenOne);

    // Call a task switch if higher or equal priority thread
    if (pclChosenOne->GetCurPriority() >= Scheduler::GetCurrentThread()->GetCurPriority()) {
        return 1;
    }
    return 0;
}

//---------------------------------------------------------------------------
void Semaphore::Init(uint16_t u16InitVal_, uint16_t u16MaxVal_)
{
    KERNEL_ASSERT(!m_clBlockList.GetHead());

    // Copy the paramters into the object - set the maximum value for this
    // semaphore to implement either binary or counting semaphores, and set
    // the initial count.  Clear the wait list for this object.
    m_u16Value    = u16InitVal_;
    m_u16MaxValue = u16MaxVal_;

    SetInitialized();
}

//---------------------------------------------------------------------------
bool Semaphore::Post()
{
    KERNEL_ASSERT(IsInitialized());

    auto bThreadWake = false;
    auto bBail       = false;
    // Increment the semaphore count - we can mess with threads so ensure this
    // is in a critical section.  We don't just disable the scheudler since
    // we want to be able to do this from within an interrupt context as well.

    { // Begin critical section
        const auto cs = CriticalGuard{};
        // If nothing is waiting for the semaphore
        if (nullptr == m_clBlockList.GetHead()) {
            // Check so see if we've reached the maximum value in the semaphore
            if (m_u16Value < m_u16MaxValue) {
                // Increment the count value
                m_u16Value++;
            } else {
                // Maximum value has been reached, bail out.
                bBail = true;
            }
        } else {
            // Otherwise, there are threads waiting for the semaphore to be
            // posted, so wake the next one (highest priority goes first).
            bThreadWake = (WakeNext() != 0u);
        }
    } // end critical section

    // If we weren't able to increment the semaphore count, fail out.
    if (bBail) {
        return false;
    }

    // if bThreadWake was set, it means that a higher-priority thread was
    // woken.  Trigger a context switch to ensure that this thread gets
    // to execute next.
    if (bThreadWake) {
        Thread::Yield();
    }
    return true;
}

//---------------------------------------------------------------------------
bool Semaphore::Pend_i(uint32_t u32WaitTimeMS_)
{
    KERNEL_ASSERT(IsInitialized());

    auto clSemTimer = Timer {};
    auto bUseTimer  = false;

    // Once again, messing with thread data - ensure
    // we're doing all of these operations from within a thread-safe context.

    { // Begin critical section
        const auto cs = CriticalGuard{};
        // Check to see if we need to take any action based on the semaphore count
        if (0 != m_u16Value) {
            // The semaphore count is non-zero, we can just decrement the count
            // and go along our merry way.
            m_u16Value--;
        } else {
            // The semaphore count is zero - we need to block the current thread
            // and wait until the semaphore is posted from elsewhere.
            if (0u != u32WaitTimeMS_) {
                g_pclCurrent->SetExpired(false);
                clSemTimer.Init();
                clSemTimer.Start(false, u32WaitTimeMS_, TimedSemaphore_Callback, this);
                bUseTimer = true;
            }
            BlockPriority(g_pclCurrent);

            // Switch Threads immediately
            Thread::Yield();
        }
    } // End critical section

    if (bUseTimer) {
        clSemTimer.Stop();
        return (g_pclCurrent->GetExpired() == false);
    }
    return true;
}

//---------------------------------------------------------------------------
// Redirect the untimed pend API to the timed pend, with a null timeout.
void Semaphore::Pend()
{
    Pend_i(0);
}

//---------------------------------------------------------------------------
bool Semaphore::Pend(uint32_t u32WaitTimeMS_)
{
    return Pend_i(u32WaitTimeMS_);
}

//---------------------------------------------------------------------------
uint16_t Semaphore::GetCount()
{
    KERNEL_ASSERT(IsInitialized());

    auto cs = CriticalGuard{};
    return m_u16Value;
}
} // namespace Mark3