66e7c5b774
Add a general-purpose counting semaphore class. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
104 lines
2.5 KiB
C++
104 lines
2.5 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2019, Google Inc.
|
|
*
|
|
* semaphore.cpp - General-purpose counting semaphore
|
|
*/
|
|
|
|
#include "semaphore.h"
|
|
#include "thread.h"
|
|
|
|
/**
|
|
* \file semaphore.h
|
|
* \brief General-purpose counting semaphore
|
|
*/
|
|
|
|
namespace libcamera {
|
|
|
|
/**
|
|
* \class Semaphore
|
|
* \brief General-purpose counting semaphore
|
|
*
|
|
* A semaphore is a locking primitive that protects resources. It is created
|
|
* with an initial number of resources (which may be 0), and offers two
|
|
* primitives to acquire and release resources. The acquire() method tries to
|
|
* acquire a number of resources, and blocks if not enough resources are
|
|
* available until they get released. The release() method releases a number of
|
|
* resources, waking up any consumer blocked on an acquire() call.
|
|
*/
|
|
|
|
/**
|
|
* \brief Construct a semaphore with \a n resources
|
|
* \param[in] n The resource count
|
|
*/
|
|
Semaphore::Semaphore(unsigned int n)
|
|
: available_(n)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* \brief Retrieve the number of available resources
|
|
* \return The number of available resources
|
|
*/
|
|
unsigned int Semaphore::available()
|
|
{
|
|
MutexLocker locker(mutex_);
|
|
return available_;
|
|
}
|
|
|
|
/**
|
|
* \brief Acquire \a n resources
|
|
* \param[in] n The resource count
|
|
*
|
|
* This method attempts to acquire \a n resources. If \a n is higher than the
|
|
* number of available resources, the call will block until enough resources
|
|
* become available.
|
|
*/
|
|
void Semaphore::acquire(unsigned int n)
|
|
{
|
|
MutexLocker locker(mutex_);
|
|
cv_.wait(locker, [&] { return available_ >= n; });
|
|
available_ -= n;
|
|
}
|
|
|
|
/**
|
|
* \brief Try to acquire \a n resources without blocking
|
|
* \param[in] n The resource count
|
|
*
|
|
* This method attempts to acquire \a n resources. If \a n is higher than the
|
|
* number of available resources, it returns false immediately without
|
|
* acquiring any resource. Otherwise it acquires the resources and returns
|
|
* true.
|
|
*
|
|
* \return True if the resources have been acquired, false otherwise
|
|
*/
|
|
bool Semaphore::tryAcquire(unsigned int n)
|
|
{
|
|
MutexLocker locker(mutex_);
|
|
if (available_ < n)
|
|
return false;
|
|
|
|
available_ -= n;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* \brief Release \a n resources
|
|
* \param[in] n The resource count
|
|
*
|
|
* This method releases \a n resources, increasing the available resource count
|
|
* by \a n. If the number of available resources becomes large enough for any
|
|
* consumer blocked on an acquire() call, those consumers get woken up.
|
|
*/
|
|
void Semaphore::release(unsigned int n)
|
|
{
|
|
{
|
|
MutexLocker locker(mutex_);
|
|
available_ += n;
|
|
}
|
|
|
|
cv_.notify_all();
|
|
}
|
|
|
|
} /* namespace libcamera */
|