Reference documentation for deal.II version GIT relicensing-1062-gc06da148b8 2024-07-15 19:20:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
No Matches
Public Member Functions | Static Public Member Functions | Static Private Attributes | List of all members

#include <deal.II/base/multithread_info.h>

Public Member Functions

 MultithreadInfo ()=delete

Static Public Member Functions

static unsigned int n_cores ()
static unsigned int n_threads ()
static std::size_t memory_consumption ()
static void set_thread_limit (const unsigned int max_threads=numbers::invalid_unsigned_int)
static bool is_running_single_threaded ()
static void initialize_multithreading ()
static tf::Executor & get_taskflow_executor ()

Static Private Attributes

static unsigned int n_max_threads = numbers::invalid_unsigned_int
static std::unique_ptr< tf::Executor > executor = nullptr

Detailed Description

This class provides information about the system which may be of use in multithreaded programs. At the moment this is just the number of CPUs. If deal.II is compiled with multithreading support, some functions will use multiple threads for their action. Currently the library supports both thread-based and task-based parallelism. Parallel computing with multiple processors accessing shared memory describes the different uses of each. The default number of threads used for task-based parallel methods is selected automatically by the Threading Building Blocks library. See Parallel computing with multiple processors accessing shared memory for more information on this. Thread-based parallel methods need to explicitly create threads and may want to use a number of threads that is related to the number of CPUs in your system. The recommended number of threads can be queried using MultithreadInfo::n_threads(), while the number of cores in the system is returned by MultithreadInfo::n_cores().

Definition at line 57 of file multithread_info.h.

Constructor & Destructor Documentation

◆ MultithreadInfo()

MultithreadInfo::MultithreadInfo ( )

Constructor. This constructor is deleted because no instance of this class needs to be constructed (all members are static).

Member Function Documentation

◆ n_cores()

unsigned int MultithreadInfo::n_cores ( )

The number of CPUs in the system.

This internally calls std::thread::hardware_concurrency but sets the result to 1 if the call returns an error.

Definition at line 40 of file

◆ n_threads()

unsigned int MultithreadInfo::n_threads ( )

Return the number of threads to use. This is initially set to the number of cores the system has (see n_cores()) but can be further restricted by set_thread_limit() and the environment variable DEAL_II_NUM_THREADS.

Definition at line 127 of file

◆ memory_consumption()

std::size_t MultithreadInfo::memory_consumption ( )

Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.

Definition at line 144 of file

◆ set_thread_limit()

void MultithreadInfo::set_thread_limit ( const unsigned int  max_threads = numbers::invalid_unsigned_int)

Set the maximum number of threads to be used to the minimum of the environment variable DEAL_II_NUM_THREADS and the given argument (or its default value). This affects the initialization of the TBB. If neither is given, the default from TBB is used (based on the number of cores in the system).

This routine is executed automatically with the default argument before your code in main() is running (using a static constructor). It is also executed by Utilities::MPI::MPI_InitFinalize. Use the appropriate argument of the constructor of Utilities::MPI::MPI_InitFinalize if you have an MPI based code.

Definition at line 52 of file

◆ is_running_single_threaded()

bool MultithreadInfo::is_running_single_threaded ( )

Return if the TBB is running using a single thread either because of thread affinity or because it is set via a call to set_thread_limit. This is used in the PETScWrappers to avoid using the interface that is not thread-safe.

Definition at line 136 of file

◆ initialize_multithreading()

void MultithreadInfo::initialize_multithreading ( )

Make sure the multithreading API is initialized. This normally does not need to be called in usercode.

Definition at line 153 of file

◆ get_taskflow_executor()

tf::Executor & MultithreadInfo::get_taskflow_executor ( )

Return a reference to the global Executor from taskflow.

The Executor is set to use n_threads() worker threads that you can control using set_thread_limit() and the DEAL_II_NUM_THREADS environment variable.

Definition at line 165 of file

Member Data Documentation

◆ n_max_threads

unsigned int MultithreadInfo::n_max_threads = numbers::invalid_unsigned_int

Variable representing the maximum number of threads.

Definition at line 142 of file multithread_info.h.

◆ executor

std::unique_ptr< tf::Executor > MultithreadInfo::executor = nullptr

Store a taskflow Executor that is constructed with N workers (from set_thread_limit).

Definition at line 149 of file multithread_info.h.

The documentation for this class was generated from the following files: