tlx
semaphore.hpp
Go to the documentation of this file.
1/*******************************************************************************
2 * tlx/semaphore.hpp
3 *
4 * A simple semaphore implementation using C++11 synchronization methods.
5 *
6 * Copied and modified from STXXL https://github.com/stxxl/stxxl, which is
7 * distributed under the Boost Software License, Version 1.0.
8 *
9 * Part of tlx - http://panthema.net/tlx
10 *
11 * Copyright (C) 2002 Roman Dementiev <dementiev@mpi-sb.mpg.de>
12 * Copyright (C) 2013-2018 Timo Bingmann <tb@panthema.net>
13 *
14 * All rights reserved. Published under the Boost Software License, Version 1.0
15 ******************************************************************************/
16
17#ifndef TLX_SEMAPHORE_HEADER
18#define TLX_SEMAPHORE_HEADER
19
20#include <condition_variable>
21#include <mutex>
22
23namespace tlx {
24
25//! A simple semaphore implementation using C++11 synchronization methods.
27{
28public:
29 //! construct semaphore
30 explicit Semaphore(size_t initial_value = 0)
31 : value_(initial_value) { }
32
33 //! non-copyable: delete copy-constructor
34 Semaphore(const Semaphore&) = delete;
35 //! non-copyable: delete assignment operator
36 Semaphore& operator = (const Semaphore&) = delete;
37 //! move-constructor: just move the value
39 //! move-assignment: just move the value
40 Semaphore& operator = (Semaphore&& s) { value_ = s.value_; return *this; }
41
42 //! function increments the semaphore and signals any threads that are
43 //! blocked waiting a change in the semaphore
44 size_t signal() {
45 std::unique_lock<std::mutex> lock(mutex_);
46 size_t res = ++value_;
47 cv_.notify_one();
48 return res;
49 }
50 //! function increments the semaphore and signals any threads that are
51 //! blocked waiting a change in the semaphore
52 size_t signal(size_t delta) {
53 std::unique_lock<std::mutex> lock(mutex_);
54 size_t res = (value_ += delta);
55 cv_.notify_all();
56 return res;
57 }
58 //! function decrements the semaphore by delta and blocks if the semaphore
59 //! is < (delta + slack) until another thread signals a change
60 size_t wait(size_t delta = 1, size_t slack = 0) {
61 std::unique_lock<std::mutex> lock(mutex_);
62 while (value_ < delta + slack)
63 cv_.wait(lock);
64 value_ -= delta;
65 return value_;
66 }
67 //! function decrements the semaphore by delta if (delta + slack) tokens are
68 //! available as a batch. the function will not block and returns true if
69 //! delta was acquired otherwise false.
70 bool try_acquire(size_t delta = 1, size_t slack = 0) {
71 std::unique_lock<std::mutex> lock(mutex_);
72 if (value_ < delta + slack)
73 return false;
74 value_ -= delta;
75 return true;
76 }
77
78 //! return the current value -- should only be used for debugging.
79 size_t value() const { return value_; }
80
81private:
82 //! value of the semaphore
83 size_t value_;
84
85 //! mutex for condition variable
86 std::mutex mutex_;
87
88 //! condition variable
89 std::condition_variable cv_;
90};
91
92//! alias for STL-like code style
94
95} // namespace tlx
96
97#endif // !TLX_SEMAPHORE_HEADER
98
99/******************************************************************************/
A simple semaphore implementation using C++11 synchronization methods.
Definition: semaphore.hpp:27
std::mutex mutex_
mutex for condition variable
Definition: semaphore.hpp:86
Semaphore(size_t initial_value=0)
construct semaphore
Definition: semaphore.hpp:30
size_t value() const
return the current value – should only be used for debugging.
Definition: semaphore.hpp:79
size_t signal()
function increments the semaphore and signals any threads that are blocked waiting a change in the se...
Definition: semaphore.hpp:44
std::condition_variable cv_
condition variable
Definition: semaphore.hpp:89
size_t wait(size_t delta=1, size_t slack=0)
function decrements the semaphore by delta and blocks if the semaphore is < (delta + slack) until ano...
Definition: semaphore.hpp:60
Semaphore & operator=(const Semaphore &)=delete
non-copyable: delete assignment operator
size_t signal(size_t delta)
function increments the semaphore and signals any threads that are blocked waiting a change in the se...
Definition: semaphore.hpp:52
bool try_acquire(size_t delta=1, size_t slack=0)
function decrements the semaphore by delta if (delta + slack) tokens are available as a batch.
Definition: semaphore.hpp:70
Semaphore(const Semaphore &)=delete
non-copyable: delete copy-constructor
size_t value_
value of the semaphore
Definition: semaphore.hpp:83
Semaphore(Semaphore &&s)
move-constructor: just move the value
Definition: semaphore.hpp:38