blob: d8988a9189e8400c7697194e77829aa9d31ef56f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
/* 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 */
|
