SkSemaphore Class Reference

#include <SkSemaphore.h>

Classes
struct	OSSemaphore

Public Member Functions
constexpr	SkSemaphore (int count=0)
SK_SPI	~SkSemaphore ()
void	signal (int n=1)
void	wait ()
SK_SPI bool	try_wait ()

Detailed Description

Definition at line 18 of file SkSemaphore.h.

Constructor & Destructor Documentation

SkSemaphore()

constexpr SkSemaphore::SkSemaphore ( int  count = 0 )

inlineconstexpr

Definition at line 20 of file SkSemaphore.h.

: fCount(count), fOSSemaphore(nullptr) {}

~SkSemaphore()

SkSemaphore::~SkSemaphore

(

)

Definition at line 63 of file SkSemaphore.cpp.

                          {
    delete fOSSemaphore;
}

Member Function Documentation

signal()

void SkSemaphore::signal ( int  n = 1 )

inline

Definition at line 56 of file SkSemaphore.h.

                                     {
    int prev = fCount.fetch_add(n, std::memory_order_release);
 
    // We only want to call the OS semaphore when our logical count crosses
    // from <0 to >=0 (when we need to wake sleeping threads).
    //
    // This is easiest to think about with specific examples of prev and n.
    // If n == 5 and prev == -3, there are 3 threads sleeping and we signal
    // std::min(-(-3), 5) == 3 times on the OS semaphore, leaving the count at 2.
    //
    // If prev >= 0, no threads are waiting, std::min(-prev, n) is always <= 0,
    // so we don't call the OS semaphore, leaving the count at (prev + n).
    int toSignal = std::min(-prev, n);
    if (toSignal > 0) {
        this->osSignal(toSignal);
    }
}

try_wait()

bool SkSemaphore::try_wait

(

)

Definition at line 77 of file SkSemaphore.cpp.

                           {
    int count = fCount.load(std::memory_order_relaxed);
    if (count > 0) {
        return fCount.compare_exchange_weak(count, count-1, std::memory_order_acquire);
    }
    return false;
}

wait()

void SkSemaphore::wait ( )

inline

Definition at line 74 of file SkSemaphore.h.

                              {
    // Since this fetches the value before the subtract, zero and below means that there are no
    // resources left, so the thread needs to wait.
    if (fCount.fetch_sub(1, std::memory_order_acquire) <= 0) {
        SK_POTENTIALLY_BLOCKING_REGION_BEGIN;
        this->osWait();
        SK_POTENTIALLY_BLOCKING_REGION_END;
    }
}

---

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

• third_party/skia/include/private/base/SkSemaphore.h
• third_party/skia/src/base/SkSemaphore.cpp