docs/classtf_1_1Semaphore.html
| | Taskflow: A General-purpose Task-parallel Programming System |
Loading...
Searching...
No Matches
Public Member Functions | Friends | List of all members
tf::Semaphore Class Reference
class to create a semophore object for building a concurrency constraint More...
#include <taskflow/core/semaphore.hpp>
|
|
| | Semaphore ()=default |
| | constructs a default semaphore
|
| |
| | Semaphore (size_t max_value) |
| | constructs a semaphore with the given value (i.e., counter)
|
| |
| size_t | value () const |
| | queries the current counter value
|
| |
| size_t | max_value () const |
| | queries the maximum allowable value of this semaphore
|
| |
| void | reset () |
| | resets the semaphores to a clean state
|
| |
| void | reset (size_t new_max_value) |
| | resets the semaphores to a clean state with the given new maximum value
|
| |
|
| | class | Node | | | | class | Executor | | |
class to create a semophore object for building a concurrency constraint
A semaphore creates a constraint that limits the maximum concurrency, i.e., the number of workers, in a set of tasks. You can let a task acquire/release one or multiple semaphores before/after executing its work. A task can acquire and release a semaphore, or just acquire or just release it. A tf::Semaphore object starts with an initial count. As long as that count is above 0, tasks can acquire the semaphore and do their work. If the count is 0 or less, a task trying to acquire the semaphore will not run but goes to a waiting list of that semaphore. When the semaphore is released by another task, it reschedules all tasks on that waiting list.
tf::Executor executor(8); // create an executor of 8 workers
tf::Taskflow taskflow;
tf::Semaphore semaphore(1); // create a semaphore with initial count 1
SmallVector<tf::Task> tasks {
taskflow.emplace({ std::cout << "A" << std::endl; }),
taskflow.emplace({ std::cout << "B" << std::endl; }),
taskflow.emplace({ std::cout << "C" << std::endl; }),
taskflow.emplace({ std::cout << "D" << std::endl; }),
taskflow.emplace({ std::cout << "E" << std::endl; })
};
for(auto & task : tasks) { // each task acquires and release the semaphore
task.acquire(semaphore);
task.release(semaphore);
}
executor.run(taskflow).wait();
class to create an executor
Definition executor.hpp:62
Task emplace(C &&callable)
creates a static task
Definition flow_builder.hpp:1571
class to create a semophore object for building a concurrency constraint
Definition semaphore.hpp:68
class to define a vector optimized for small array
Definition small_vector.hpp:931
class to create a taskflow object
Definition taskflow.hpp:64
The above example creates five tasks with no dependencies between them. Under normal circumstances, the five tasks would be executed concurrently. However, this example has a semaphore with initial count 1, and all tasks need to acquire that semaphore before running and release that semaphore after they are done. This arrangement limits the number of concurrently running tasks to only one.
|
| tf::Semaphore::Semaphore | ( | | ) | |
| default |
constructs a default semaphore
A default semaphore has the value of zero. Users can call tf::Semaphore::reset to reassign a new value to the semaphore.
|
| tf::Semaphore::Semaphore | ( | size_t | max_value | ) | |
| inlineexplicit |
constructs a semaphore with the given value (i.e., counter)
A semaphore creates a constraint that limits the maximum concurrency, i.e., the number of workers, in a set of tasks.
tf::Semaphore semaphore(4); // concurrency constraint of 4 workers
The documentation for this class was generated from the following file:
taskflow/core/semaphore.hpp
Maintained by Dr. Tsung-Wei Huang — Generated by 1.13.1