libMesh
Classes | Typedefs | Functions | Variables
libMesh::Threads Namespace Reference

The Threads namespace is for wrapper functions for common general multithreading algorithms and tasks. More...

Classes

class  atomic
 Defines atomic operations which can only be executed on a single thread at a time. More...
 
class  BlockedRange
 Blocked range which can be subdivided and executed in parallel. More...
 
class  BoolAcquire
 We use a class to turn Threads::in_threads on and off, to be exception-safe. More...
 
class  NonConcurrentThread
 Simple compatibility class for std::thread 'concurrent' execution. More...
 
class  RangeBody
 
class  recursive_mutex
 Recursive mutex. More...
 
class  scalable_allocator
 Scalable allocator to be used in multithreaded code chunks which allocate a lot of dynamic memory. More...
 
class  spin_mutex
 Spin mutex. More...
 
class  split
 Dummy "splitting object" used to distinguish splitting constructors from copy constructors. More...
 
class  task_scheduler_init
 Scheduler to manage threads. More...
 

Typedefs

typedef NonConcurrentThread Thread
 Use the non-concurrent placeholder. More...
 
typedef tbb::task_scheduler_init task_scheduler_init
 Scheduler to manage threads. More...
 
typedef tbb::split split
 Dummy "splitting object" used to distinguish splitting constructors from copy constructors. More...
 
typedef tbb::spin_mutex spin_mutex
 Spin mutex. More...
 
typedef tbb::recursive_mutex recursive_mutex
 Recursive mutex. More...
 

Functions

template<typename Range , typename Body >
void parallel_for (const Range &range, const Body &body)
 Execute the provided function object in parallel on the specified range. More...
 
template<typename Range , typename Body , typename Partitioner >
void parallel_for (const Range &range, const Body &body, const Partitioner &)
 Execute the provided function object in parallel on the specified range with the specified partitioner. More...
 
template<typename Range , typename Body >
void parallel_reduce (const Range &range, Body &body)
 Execute the provided reduction operation in parallel on the specified range. More...
 
template<typename Range , typename Body , typename Partitioner >
void parallel_reduce (const Range &range, Body &body, const Partitioner &)
 Execute the provided reduction operation in parallel on the specified range with the specified partitioner. More...
 
template<typename Range >
unsigned int num_pthreads (Range &range)
 
template<typename Range , typename Body >
void * run_body (void *args)
 

Variables

bool in_threads = false
 A boolean which is true iff we are in a Threads:: function It may be useful to assert(!Threadsin_threads) in any code which is known to not be thread-safe. More...
 
spin_mutex spin_mtx
 A convenient spin mutex object which can be used for obtaining locks. More...
 
recursive_mutex recursive_mtx
 A convenient recursive mutex object which can be used for obtaining locks. More...
 

Detailed Description

The Threads namespace is for wrapper functions for common general multithreading algorithms and tasks.

Typedef Documentation

typedef tbb::recursive_mutex libMesh::Threads::recursive_mutex

Recursive mutex.

Implements mutual exclusion by busy-waiting in user space for the lock to be acquired. The same thread can acquire the same lock multiple times

Definition at line 216 of file threads_tbb.h.

typedef tbb::spin_mutex libMesh::Threads::spin_mutex

Spin mutex.

Implements mutual exclusion by busy-waiting in user space for the lock to be acquired.

Definition at line 209 of file threads_tbb.h.

typedef tbb::split libMesh::Threads::split

Dummy "splitting object" used to distinguish splitting constructors from copy constructors.

Definition at line 79 of file threads_tbb.h.

typedef tbb::task_scheduler_init libMesh::Threads::task_scheduler_init

Scheduler to manage threads.

Definition at line 73 of file threads_tbb.h.

typedef tbb::tbb_thread libMesh::Threads::Thread

Use the non-concurrent placeholder.

Thread object abstraction that provides a basic constructor and support for join().

Use std::thread when available.

Definition at line 43 of file threads_none.h.

Function Documentation

template<typename Range >
unsigned int libMesh::Threads::num_pthreads ( Range &  range)

Definition at line 214 of file threads_pthread.h.

References std::min(), and libMesh::n_threads().

Referenced by libMesh::Threads::task_scheduler_init::terminate().

215 {
216  unsigned int min = std::min((std::size_t)libMesh::n_threads(), range.size());
217  return min > 0 ? min : 1;
218 }
unsigned int n_threads()
Definition: libmesh_base.h:125
long double min(long double a, double b)
template<typename Range , typename Body >
void libMesh::Threads::parallel_for ( const Range &  range,
const Body &  body 
)
template<typename Range , typename Body , typename Partitioner >
void libMesh::Threads::parallel_for ( const Range &  range,
const Body &  body,
const Partitioner partitioner 
)

Execute the provided function object in parallel on the specified range with the specified partitioner.

Definition at line 87 of file threads_none.h.

References in_threads.

88 {
89  BoolAcquire b(in_threads);
90  body(range);
91 }
bool in_threads
A boolean which is true iff we are in a Threads:: function It may be useful to assert(!Threadsin_thre...
Definition: threads.C:31
template<typename Range , typename Body >
void libMesh::Threads::parallel_reduce ( const Range &  range,
Body &  body 
)
template<typename Range , typename Body , typename Partitioner >
void libMesh::Threads::parallel_reduce ( const Range &  range,
Body &  body,
const Partitioner partitioner 
)

Execute the provided reduction operation in parallel on the specified range with the specified partitioner.

Definition at line 115 of file threads_none.h.

References in_threads.

116 {
117  BoolAcquire b(in_threads);
118  body(range);
119 }
bool in_threads
A boolean which is true iff we are in a Threads:: function It may be useful to assert(!Threadsin_thre...
Definition: threads.C:31
template<typename Range , typename Body >
void* libMesh::Threads::run_body ( void *  args)

Definition at line 229 of file threads_pthread.h.

References libMesh::Threads::RangeBody< Range, Body >::body, libmesh_nullptr, and libMesh::Threads::RangeBody< Range, Body >::range.

230 {
231  RangeBody<Range, Body> * range_body = (RangeBody<Range, Body> *)args;
232 
233  Body & body = *range_body->body;
234  Range & range = *range_body->range;
235 
236  body(range);
237 
238  return libmesh_nullptr;
239 }
const class libmesh_nullptr_t libmesh_nullptr

Variable Documentation

bool libMesh::Threads::in_threads = false

A boolean which is true iff we are in a Threads:: function It may be useful to assert(!Threadsin_threads) in any code which is known to not be thread-safe.

Definition at line 31 of file threads.C.

Referenced by parallel_for(), parallel_reduce(), libMesh::MeshBase::point_locator(), libMesh::MeshBase::sub_point_locator(), and libMesh::Threads::task_scheduler_init::terminate().

Threads::recursive_mutex libMesh::Threads::recursive_mtx

A convenient recursive mutex object which can be used for obtaining locks.

Definition at line 30 of file threads.C.

Threads::spin_mutex libMesh::Threads::spin_mtx