Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
governor.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2005-2020 Intel Corporation
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 */
16 
17 #ifndef _TBB_governor_H
18 #define _TBB_governor_H
19 
21 #include "../rml/include/rml_tbb.h"
22 
23 #include "tbb_misc.h" // for AvailableHwConcurrency
24 #include "tls.h"
25 
26 #if __TBB_SURVIVE_THREAD_SWITCH
27 #include "cilk-tbb-interop.h"
28 #endif /* __TBB_SURVIVE_THREAD_SWITCH */
29 
30 namespace tbb {
31 namespace internal {
32 
33 class market;
34 class generic_scheduler;
35 class __TBB_InitOnce;
36 
37 namespace rml {
38 class tbb_client;
39 }
40 
41 //------------------------------------------------------------------------
42 // Class governor
43 //------------------------------------------------------------------------
44 
46 
48 class governor {
49 private:
50  friend class __TBB_InitOnce;
51  friend class market;
52 
55 
57  static unsigned DefaultNumberOfThreads;
58 
60  static size_t DefaultPageSize;
61 
62  static rml::tbb_factory theRMLServerFactory;
63 
64  static bool UsePrivateRML;
65 
66  // Flags for runtime-specific conditions
68  static bool is_rethrow_broken;
69 
71  static void acquire_resources ();
72 
74  static void release_resources ();
75 
76  static rml::tbb_server* create_rml_server ( rml::tbb_client& );
77 
79 
81  static void auto_terminate(void* scheduler);
82 
83 public:
84  static unsigned default_num_threads () {
85  // No memory fence required, because at worst each invoking thread calls AvailableHwConcurrency once.
88  }
89  static size_t default_page_size () {
92  }
93  static void one_time_init();
95 
97  static generic_scheduler* init_scheduler( int num_threads, stack_size_type stack_size, bool auto_init );
98 
101 
103  static bool terminate_scheduler( generic_scheduler* s, bool blocking );
104 
106  static void sign_on( generic_scheduler* s );
107 
109  static void sign_off( generic_scheduler* s );
110 
112  static bool is_set( generic_scheduler* s );
113 
115  static void assume_scheduler( generic_scheduler* s );
116 
118  static uintptr_t tls_value_of( generic_scheduler* s );
119 
120  // TODO IDEA: refactor bit manipulations over pointer types to a class?
122  static generic_scheduler* tls_scheduler_of( uintptr_t v ) {
123  return (generic_scheduler*)(v & ~uintptr_t(1));
124  }
125 
127 
130  uintptr_t v = theTLS.get();
131  return (v&1) ? tls_scheduler_of(v) : init_scheduler( task_scheduler_init::automatic, 0, /*auto_init=*/true );
132  }
133 
135  uintptr_t v = theTLS.get();
136  return v ? tls_scheduler_of(v) : init_scheduler_weak();
137  }
138 
140  return tls_scheduler_of( theTLS.get() );
141  }
142 
146  }
147 
148  static void print_version_info ();
149 
150  static void initialize_rml_factory ();
151 
152  static bool does_client_join_workers (const tbb::internal::rml::tbb_client &client);
153 
154 #if __TBB_SURVIVE_THREAD_SWITCH
155  static __cilk_tbb_retcode stack_op_handler( __cilk_tbb_stack_op op, void* );
156 #endif /* __TBB_SURVIVE_THREAD_SWITCH */
157 
158  static bool speculation_enabled() { return is_speculation_enabled; }
159  static bool rethrow_exception_broken() { return is_rethrow_broken; }
160 
161 }; // class governor
162 
163 } // namespace internal
164 } // namespace tbb
165 
166 #endif /* _TBB_governor_H */
tbb::task_scheduler_init::automatic
static const int automatic
Typedef for number of threads that is automatic.
Definition: task_scheduler_init.h:83
__cilk_tbb_retcode
int __cilk_tbb_retcode
Definition: cilk-tbb-interop.h:42
internal
Definition: _flow_graph_async_msg_impl.h:24
tbb::internal::governor::tls_scheduler_of
static generic_scheduler * tls_scheduler_of(uintptr_t v)
Converts TLS value to the scheduler pointer.
Definition: governor.h:122
tbb::internal::__TBB_InitOnce
Class that supports TBB initialization.
Definition: tbb_main.h:37
tls.h
tbb::internal::governor::sign_on
static void sign_on(generic_scheduler *s)
Register TBB scheduler instance in thread-local storage.
Definition: governor.cpp:124
tbb::internal::governor::assume_scheduler
static void assume_scheduler(generic_scheduler *s)
Temporarily set TLS slot to the given scheduler.
Definition: governor.cpp:116
tbb::internal::basic_tls< uintptr_t >
tbb::internal::governor::default_num_threads
static unsigned default_num_threads()
Definition: governor.h:84
tbb::internal::governor::acquire_resources
static void acquire_resources()
Create key for thread-local storage and initialize RML.
Definition: governor.cpp:67
__cilk_tbb_stack_op
__cilk_tbb_stack_op
Definition: cilk-tbb-interop.h:44
tbb
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::internal::governor::speculation_enabled
static bool speculation_enabled()
Definition: governor.h:158
tbb::internal::generic_scheduler
Work stealing task scheduler.
Definition: scheduler.h:137
tbb::internal::governor::local_scheduler_weak
static generic_scheduler * local_scheduler_weak()
Definition: governor.h:134
tbb::internal::governor::release_resources
static void release_resources()
Destroy the thread-local storage key and deinitialize RML.
Definition: governor.cpp:79
tbb::internal::governor::is_rethrow_broken
static bool is_rethrow_broken
Definition: governor.h:68
tbb::internal::governor::tls_value_of
static uintptr_t tls_value_of(generic_scheduler *s)
Computes the value of the TLS.
Definition: governor.cpp:110
tbb::internal::governor::auto_terminate
static void auto_terminate(void *scheduler)
The internal routine to undo automatic initialization.
Definition: governor.cpp:215
tbb::internal::basic_tls::get
T get()
Definition: tls.h:57
tbb::internal::governor::does_client_join_workers
static bool does_client_join_workers(const tbb::internal::rml::tbb_client &client)
Definition: market.cpp:304
tbb::internal::governor::rethrow_exception_broken
static bool rethrow_exception_broken()
Definition: governor.h:159
tbb::stack_size_type
std::size_t stack_size_type
Definition: task_scheduler_init.h:42
tbb::internal::governor::print_version_info
static void print_version_info()
Definition: governor.cpp:229
tbb::internal::governor::DefaultPageSize
static size_t DefaultPageSize
Caches the size of OS regular memory page.
Definition: governor.h:60
tbb::internal::governor::init_scheduler
static generic_scheduler * init_scheduler(int num_threads, stack_size_type stack_size, bool auto_init)
Processes scheduler initialization request (possibly nested) in a master thread.
Definition: governor.cpp:172
tbb::internal::market
Definition: market.h:45
tbb::internal::governor::is_speculation_enabled
static bool is_speculation_enabled
Definition: governor.h:67
task_scheduler_init.h
tbb::internal::governor::local_scheduler_if_initialized
static generic_scheduler * local_scheduler_if_initialized()
Definition: governor.h:139
tbb::internal::governor::UsePrivateRML
static bool UsePrivateRML
Definition: governor.h:64
tbb::internal::governor::is_set
static bool is_set(generic_scheduler *s)
Used to check validity of the local scheduler TLS contents.
Definition: governor.cpp:120
tbb::internal::governor::initialize_rml_factory
static void initialize_rml_factory()
Definition: governor.cpp:242
tbb::internal::governor::init_scheduler_weak
static generic_scheduler * init_scheduler_weak()
Automatic initialization of scheduler in a master thread with default settings without arena.
Definition: governor.cpp:164
tbb::internal::governor::theTLS
static basic_tls< uintptr_t > theTLS
TLS for scheduler instances associated with individual threads.
Definition: governor.h:54
tbb::internal::scheduler
Definition: task.h:110
tbb_misc.h
s
void const char const char int ITT_FORMAT __itt_group_sync s
Definition: ittnotify_static.h:91
tbb::internal::governor::DefaultNumberOfThreads
static unsigned DefaultNumberOfThreads
Caches the maximal level of parallelism supported by the hardware.
Definition: governor.h:57
tbb::internal::governor::create_rml_server
static rml::tbb_server * create_rml_server(rml::tbb_client &)
Definition: governor.cpp:92
cilk-tbb-interop.h
tbb::internal::governor::default_page_size
static size_t default_page_size()
Definition: governor.h:89
tbb::internal::DefaultSystemPageSize
size_t DefaultSystemPageSize()
Returns OS regular memory page size.
Definition: tbb_misc.cpp:70
tbb::internal::governor::terminate_auto_initialized_scheduler
static void terminate_auto_initialized_scheduler()
Undo automatic initialization if necessary; call when a thread exits.
Definition: governor.h:144
tbb::internal::governor
The class handles access to the single instance of market, and to TLS to keep scheduler instances.
Definition: governor.h:48
tbb::internal::governor::theRMLServerFactory
static rml::tbb_factory theRMLServerFactory
Definition: governor.h:62
tbb::internal::governor::one_time_init
static void one_time_init()
Definition: governor.cpp:156
tbb::internal::governor::local_scheduler
static generic_scheduler * local_scheduler()
Obtain the thread-local instance of the TBB scheduler.
Definition: governor.h:129
tbb::internal::AvailableHwConcurrency
int AvailableHwConcurrency()
Returns maximal parallelism level supported by the current OS configuration.
tbb::internal::governor::terminate_scheduler
static bool terminate_scheduler(generic_scheduler *s, bool blocking)
Processes scheduler termination request (possibly nested) in a master thread.
Definition: governor.cpp:205
tbb::internal::governor::sign_off
static void sign_off(generic_scheduler *s)
Unregister TBB scheduler instance from thread-local storage.
Definition: governor.cpp:145

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.