| /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| /* |
| * Copyright (C) 2019, Google Inc. |
| * |
| * semaphore.cpp - General-purpose counting semaphore |
| */ |
| |
| #include "libcamera/internal/semaphore.h" |
| #include "libcamera/internal/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 */ |