Semaphore Class Reference

#include <Semaphore.hpp>

Collaboration diagram for Semaphore:

Public Member Functions
	Semaphore (uint32_t val, bool share, const char *name=nullptr)
bool	wait ()
bool	tryWait ()
bool	timeWait (const uint32_t *usec)
bool	post ()
uint32_t	count ()

Private Attributes
bool	m_isShared
uint32_t	m_count
struct task_sync	m_taskSync

Detailed Description

Definition at line 16 of file Semaphore.hpp.

Constructor & Destructor Documentation

Semaphore()

Semaphore::Semaphore	(	uint32_t	val,
		bool	share,
		const char *	name = nullptr
	)

Initializes a semaphore struct using the values defined. Semaphores are used in order to maintain mutual exclusion when multiple threads need to access a particular variable.

Parameters

val	Initial value
share	Allow semaphore to be shared across threads
name	Semaphore name (for debugging / printing)

Definition at line 23 of file Semaphore.cpp.

    : m_isShared(share)
    , m_count(val)
{
    m_taskSync.dbg_name = name;
    tasks_sync_init(&m_taskSync);
}

Member Function Documentation

count()

uint32_t Semaphore::count

(

)

Atomically get the semaphore's current counter value.

Returns

uint32_t Returns the semaphore count.

Definition at line 81 of file Semaphore.cpp.

{
    uint32_t ret = 0;
    __atomic_load(&m_count, &ret, __ATOMIC_ACQUIRE);
 
    return ret;
}

Here is the caller graph for this function:

post()

bool Semaphore::post

(

)

Post to the semaphore.

Returns

int Returns true on success.

Definition at line 73 of file Semaphore.cpp.

{
    __atomic_fetch_add(&m_count, 1, __ATOMIC_RELEASE);
    TASK_ONLY tasks_sync_unblock(&m_taskSync);
 
    return true;
}

Here is the call graph for this function:

timeWait()

bool Semaphore::timeWait

(

const uint32_t *

usec

)

Wait on the semaphore for a set duration of time.

Parameters

usec	Microseconds to wait until returning if unsuccessful.

Returns

int Returns true on success.

Definition at line 58 of file Semaphore.cpp.

{
    // TODO: Add the timer functionality here.
    (void)usec;
    uint32_t curVal = count();
    do {
        while (curVal == 0) {
            curVal = count();
        }
        // Fail using atomic relaxed because it may allow us to get to the "waiting" state faster.
    } while (!COMPARE_EXCHANGE(curVal, __ATOMIC_ACQUIRE));
 
    return true;
}

Here is the call graph for this function:

tryWait()

bool Semaphore::tryWait

(

)

Check if the semaphore is available. If unavailable, return immediately, otherwise wait on the semaphore.

Returns

int Returns 0 on success.

Definition at line 45 of file Semaphore.cpp.

{
    uint32_t curVal = count();
    do {
        if (curVal == 0) {
            return false;
        }
        // We need to fail on an Atomic Acquire Release because it will fail less often (i.e. fewer loop iterations)
    } while (!COMPARE_EXCHANGE(curVal, __ATOMIC_ACQUIRE));
 
    return true;
}

Here is the call graph for this function:

wait()

bool Semaphore::wait

(

)

Wait for the semaphore to become available.

Returns

int Returns true on success.

Definition at line 31 of file Semaphore.cpp.

{
    uint32_t curVal = count();
    do {
        while (curVal == 0) {
            TASK_ONLY tasks_sync_block(&m_taskSync);
            curVal = count();
        }
        // Fail using atomic relaxed because it may allow us to get to the "waiting" state faster.
    } while (!COMPARE_EXCHANGE(curVal, __ATOMIC_RELAXED));
 
    return true;
}

Here is the call graph for this function:

Field Documentation

m_count

uint32_t Semaphore::m_count

private

Definition at line 68 of file Semaphore.hpp.

m_isShared

bool Semaphore::m_isShared

private

Definition at line 67 of file Semaphore.hpp.

m_taskSync

struct task_sync Semaphore::m_taskSync

private

Definition at line 69 of file Semaphore.hpp.

---

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

• Semaphore.hpp
• Semaphore.cpp