Compadre  1.3.3
Compadre_ParallelManager.hpp
Go to the documentation of this file.
1 #ifndef _COMPADRE_PARALLELMANAGER_HPP_
2 #define _COMPADRE_PARALLELMANAGER_HPP_
3 
4 #include "Compadre_Config.h"
5 #include "Compadre_Typedefs.hpp"
6 
7 namespace Compadre {
8 
9 
10 //! Parallel Manager
11 /*!
12 * This class sets and manages thread / teams levels, scratch memory sizes, and kernel executions.
13 * ex:
14 * Compadre::ConvertLayoutLeftToRight clr;
15 * Compadre::ParallelManager pm;
16 * // no tag specified
17 * pm.CallFunctorWithTeamThreads(clr, 100, "MyFunctorName");
18 * // some tag specified
19 * pm.CallFunctorWithTeamThreads<DefaultTag>(clr, 100);
20 */
22 protected:
23 
24  //! lowest level memory for Kokkos::parallel_for for team access memory
27 
28  //! higher (slower) level memory for Kokkos::parallel_for for team access memory
31 
32  //! lowest level memory for Kokkos::parallel_for for thread access memory
35 
36  //! higher (slower) level memory for Kokkos::parallel_for for thread access memory
39 
40  //! largest team size
43 
44 
45 /** @name Private Modifiers
46  * Private function because information lives on the device
47  */
48 ///@{
49 ///@}
50 
51 /** @name Private Accessors
52  * Private function because information lives on the device
53  */
54 ///@{
55 ///@}
56 
57 /** @name Private Utility
58  *
59  */
60 ///@{
61 ///@}
62 
63 public:
64 
65 /** @name Instantiation / Destruction
66  *
67  */
68 ///@{
69 
72 
73 #ifdef COMPADRE_USE_CUDA
78 
79  _default_threads = 16;
81 #else
86 
87  _default_threads = 1;
89 #endif
90  if (const char* env_threads = std::getenv("THREADS")) {
91  _default_threads = std::atoi(env_threads);
92  }
93  if (const char* env_vector_lanes = std::getenv("VECTORLANES")) {
94  _default_vector_lanes = std::atoi(env_vector_lanes);
95  }
96  printf("threads per team: %d, vector lanes per team: %d\n", _default_threads, _default_vector_lanes);
97  }
98 
99 ///@}
100 
101 /** @name Public Utility
102  *
103  */
104 ///@{
105 ///@}
106 
107 /** @name Accessors
108  * Retrieve member variables through public member functions
109  */
110 ///@{
111 
112  //! Calls a parallel_for
113  //! parallel_for will break out over loops over teams with each vector lane executing code be default
114  template<typename Tag, class C>
115  void CallFunctorWithTeamThreadsAndVectors(C functor, const global_index_type batch_size, const int threads_per_team = -1,
116  const int vector_lanes_per_thread = -1) const {
117 
118  if (threads_per_team>0 && vector_lanes_per_thread>0) {
120  // all levels of each type need specified separately
121  Kokkos::parallel_for(
122  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, vector_lanes_per_thread)
123  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
124  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
125  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
126  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
127  functor, typeid(Tag).name());
129  // scratch thread levels are the same
130  Kokkos::parallel_for(
131  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, vector_lanes_per_thread)
132  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
133  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
134  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
135  functor, typeid(Tag).name());
137  // scratch team levels are the same
138  Kokkos::parallel_for(
139  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, vector_lanes_per_thread)
140  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
141  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
142  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
143  functor, typeid(Tag).name());
144  } else {
145  // scratch team levels and thread levels are the same
146  Kokkos::parallel_for(
147  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, vector_lanes_per_thread)
148  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
149  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
150  functor, typeid(Tag).name());
151  }
152  } else if (threads_per_team>0) {
154  // all levels of each type need specified separately
155  Kokkos::parallel_for(
156  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, _default_vector_lanes)
157  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
158  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
159  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
160  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
161  functor, typeid(Tag).name());
163  // scratch thread levels are the same
164  Kokkos::parallel_for(
165  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, _default_vector_lanes)
166  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
167  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
168  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
169  functor, typeid(Tag).name());
171  // scratch team levels are the same
172  Kokkos::parallel_for(
173  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, _default_vector_lanes)
174  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
175  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
176  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
177  functor, typeid(Tag).name());
178  } else {
179  // scratch team levels and thread levels are the same
180  Kokkos::parallel_for(
181  Kokkos::TeamPolicy<Tag>(batch_size, threads_per_team, _default_vector_lanes)
182  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
183  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
184  functor, typeid(Tag).name());
185  }
186  } else if (vector_lanes_per_thread>0) {
188  // all levels of each type need specified separately
189  Kokkos::parallel_for(
190  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, vector_lanes_per_thread)
191  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
192  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
193  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
194  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
195  functor, typeid(Tag).name());
197  // scratch thread levels are the same
198  Kokkos::parallel_for(
199  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, vector_lanes_per_thread)
200  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
201  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
202  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
203  functor, typeid(Tag).name());
205  // scratch team levels are the same
206  Kokkos::parallel_for(
207  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, vector_lanes_per_thread)
208  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
209  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
210  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
211  functor, typeid(Tag).name());
212  } else {
213  // scratch team levels and thread levels are the same
214  Kokkos::parallel_for(
215  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, vector_lanes_per_thread)
216  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
217  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
218  functor, typeid(Tag).name());
219  }
220  } else {
222  // all levels of each type need specified separately
223  Kokkos::parallel_for(
224  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, _default_vector_lanes)
225  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
226  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
227  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
228  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
229  functor, typeid(Tag).name());
231  // scratch thread levels are the same
232  Kokkos::parallel_for(
233  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, _default_vector_lanes)
234  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
235  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
236  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
237  functor, typeid(Tag).name());
239  // scratch team levels are the same
240  Kokkos::parallel_for(
241  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, _default_vector_lanes)
242  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
243  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
244  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
245  functor, typeid(Tag).name());
246  } else {
247  // scratch team levels and thread levels are the same
248  Kokkos::parallel_for(
249  Kokkos::TeamPolicy<Tag>(batch_size, _default_threads, _default_vector_lanes)
250  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
251  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
252  functor, typeid(Tag).name());
253  }
254  }
255  }
256 
257  //! Calls a parallel_for
258  //! parallel_for will break out over loops over teams with each vector lane executing code be default
259  template<class C>
260  void CallFunctorWithTeamThreadsAndVectors(C functor, const global_index_type batch_size, const int threads_per_team = -1,
261  const int vector_lanes_per_thread = -1, std::string functor_name = typeid(C).name()) const {
262 
263  if (threads_per_team>0 && vector_lanes_per_thread>0) {
265  // all levels of each type need specified separately
266  Kokkos::parallel_for(
267  Kokkos::TeamPolicy<>(batch_size, threads_per_team, vector_lanes_per_thread)
268  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
269  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
270  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
271  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
272  functor, functor_name);
274  // scratch thread levels are the same
275  Kokkos::parallel_for(
276  Kokkos::TeamPolicy<>(batch_size, threads_per_team, vector_lanes_per_thread)
277  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
278  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
279  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
280  functor, functor_name);
282  // scratch team levels are the same
283  Kokkos::parallel_for(
284  Kokkos::TeamPolicy<>(batch_size, threads_per_team, vector_lanes_per_thread)
285  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
286  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
287  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
288  functor, functor_name);
289  } else {
290  // scratch team levels and thread levels are the same
291  Kokkos::parallel_for(
292  Kokkos::TeamPolicy<>(batch_size, threads_per_team, vector_lanes_per_thread)
293  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
294  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
295  functor, functor_name);
296  }
297  } else if (threads_per_team>0) {
299  // all levels of each type need specified separately
300  Kokkos::parallel_for(
301  Kokkos::TeamPolicy<>(batch_size, threads_per_team, _default_vector_lanes)
302  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
303  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
304  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
305  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
306  functor, functor_name);
308  // scratch thread levels are the same
309  Kokkos::parallel_for(
310  Kokkos::TeamPolicy<>(batch_size, threads_per_team, _default_vector_lanes)
311  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
312  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
313  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
314  functor, functor_name);
316  // scratch team levels are the same
317  Kokkos::parallel_for(
318  Kokkos::TeamPolicy<>(batch_size, threads_per_team, _default_vector_lanes)
319  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
320  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
321  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
322  functor, functor_name);
323  } else {
324  // scratch team levels and thread levels are the same
325  Kokkos::parallel_for(
326  Kokkos::TeamPolicy<>(batch_size, threads_per_team, _default_vector_lanes)
327  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
328  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
329  functor, functor_name);
330  }
331  } else if (vector_lanes_per_thread>0) {
333  Kokkos::parallel_for(
334  Kokkos::TeamPolicy<>(batch_size, _default_threads, vector_lanes_per_thread)
335  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
336  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
337  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
338  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
339  functor, functor_name);
341  // scratch thread levels are the same
342  Kokkos::parallel_for(
343  Kokkos::TeamPolicy<>(batch_size, _default_threads, vector_lanes_per_thread)
344  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
345  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
346  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
347  functor, functor_name);
349  // scratch team levels are the same
350  Kokkos::parallel_for(
351  Kokkos::TeamPolicy<>(batch_size, _default_threads, vector_lanes_per_thread)
352  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
353  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
354  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
355  functor, functor_name);
356  } else {
357  // scratch team levels and thread levels are the same
358  Kokkos::parallel_for(
359  Kokkos::TeamPolicy<>(batch_size, _default_threads, vector_lanes_per_thread)
360  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
361  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
362  functor, functor_name);
363  }
364  } else {
366  Kokkos::parallel_for(
367  Kokkos::TeamPolicy<>(batch_size, _default_threads, _default_vector_lanes)
368  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
369  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
370  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
371  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
372  functor, functor_name);
374  // scratch thread levels are the same
375  Kokkos::parallel_for(
376  Kokkos::TeamPolicy<>(batch_size, _default_threads, _default_vector_lanes)
377  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a))
378  .set_scratch_size(_scratch_team_level_b, Kokkos::PerTeam(_team_scratch_size_b))
379  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
380  functor, functor_name);
382  // scratch team levels are the same
383  Kokkos::parallel_for(
384  Kokkos::TeamPolicy<>(batch_size, _default_threads, _default_vector_lanes)
385  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
386  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a))
387  .set_scratch_size(_scratch_thread_level_b, Kokkos::PerThread(_thread_scratch_size_b)),
388  functor, functor_name);
389  } else {
390  // scratch team levels and thread levels are the same
391  Kokkos::parallel_for(
392  Kokkos::TeamPolicy<>(batch_size, _default_threads, _default_vector_lanes)
393  .set_scratch_size(_scratch_team_level_a, Kokkos::PerTeam(_team_scratch_size_a + _team_scratch_size_b))
394  .set_scratch_size(_scratch_thread_level_a, Kokkos::PerThread(_thread_scratch_size_a + _thread_scratch_size_b)),
395  functor, functor_name);
396  }
397  }
398  }
399 
400  //! Calls a parallel_for
401  //! parallel_for will break out over loops over teams with each thread executing code be default
402  template<typename Tag, class C>
403  void CallFunctorWithTeamThreads(C functor, const global_index_type batch_size) const {
404  // calls breakout over vector lanes with vector lane size of 1
405  CallFunctorWithTeamThreadsAndVectors<Tag,C>(functor, batch_size, _default_threads, 1);
406  }
407 
408  //! Calls a parallel_for
409  //! parallel_for will break out over loops over teams with each thread executing code be default
410  template<class C>
411  void CallFunctorWithTeamThreads(C functor, const global_index_type batch_size, std::string functor_name = typeid(C).name()) const {
412  // calls breakout over vector lanes with vector lane size of 1
413  CallFunctorWithTeamThreadsAndVectors<C>(functor, batch_size, _default_threads, 1, functor_name);
414  }
415 
416  KOKKOS_INLINE_FUNCTION
417  int getTeamScratchLevel(const int level) const {
418  if (level == 0) {
419  return _scratch_team_level_a;
420  } else {
421  return _scratch_team_level_b;
422  }
423  }
424 
425  KOKKOS_INLINE_FUNCTION
426  int getThreadScratchLevel(const int level) const {
427  if (level == 0) {
429  } else {
431  }
432  }
433 
434  KOKKOS_INLINE_FUNCTION
435  int getTeamScratchSize(const int level) const {
436  if (level == 0) {
437  return _team_scratch_size_a;
438  } else {
439  return _team_scratch_size_b;
440  }
441  }
442 
443  KOKKOS_INLINE_FUNCTION
444  int getThreadScratchSize(const int level) const {
445  if (level == 0) {
446  return _thread_scratch_size_a;
447  } else {
448  return _thread_scratch_size_b;
449  }
450  }
451 
452 ///@}
453 
454 
455 /** @name Modifiers
456  * Changed member variables through public member functions
457  */
458 ///@{
459 
460  void setTeamScratchLevel(const int level, const int value) {
461  if (level == 0) {
462  _scratch_team_level_a = value;
463  } else {
464  _scratch_team_level_b = value;
465  }
466  }
467 
468  void setThreadScratchLevel(const int level, const int value) {
469  if (level == 0) {
470  _scratch_thread_level_a = value;
471  } else {
472  _scratch_thread_level_b = value;
473  }
474  }
475 
476  void setTeamScratchSize(const int level, const int value) {
477  if (level == 0) {
478  _team_scratch_size_a = value;
479  } else {
480  _team_scratch_size_b = value;
481  }
482  }
483 
484  void setThreadScratchSize(const int level, const int value) {
485  if (level == 0) {
486  _thread_scratch_size_a = value;
487  } else {
488  _thread_scratch_size_b = value;
489  }
490  }
491 
497  }
498 
499 ///@}
500 
501 
502 }; // ParallelManager Class
503 } // Compadre
504 
505 #endif
506 
507 
std::size_t global_index_type
int _scratch_thread_level_b
higher (slower) level memory for Kokkos::parallel_for for thread access memory
void CallFunctorWithTeamThreads(C functor, const global_index_type batch_size, std::string functor_name=typeid(C).name()) const
Calls a parallel_for parallel_for will break out over loops over teams with each thread executing cod...
void CallFunctorWithTeamThreads(C functor, const global_index_type batch_size) const
Calls a parallel_for parallel_for will break out over loops over teams with each thread executing cod...
KOKKOS_INLINE_FUNCTION int getTeamScratchLevel(const int level) const
void CallFunctorWithTeamThreadsAndVectors(C functor, const global_index_type batch_size, const int threads_per_team=-1, const int vector_lanes_per_thread=-1) const
Calls a parallel_for parallel_for will break out over loops over teams with each vector lane executin...
void setTeamScratchLevel(const int level, const int value)
KOKKOS_INLINE_FUNCTION int getThreadScratchLevel(const int level) const
void setThreadScratchLevel(const int level, const int value)
KOKKOS_INLINE_FUNCTION int getThreadScratchSize(const int level) const
int _default_threads
largest team size
int _scratch_team_level_b
lowest level memory for Kokkos::parallel_for for thread access memory
void setTeamScratchSize(const int level, const int value)
void setThreadScratchSize(const int level, const int value)
int _scratch_thread_level_a
higher (slower) level memory for Kokkos::parallel_for for team access memory
KOKKOS_INLINE_FUNCTION int getTeamScratchSize(const int level) const
int _scratch_team_level_a
lowest level memory for Kokkos::parallel_for for team access memory
void CallFunctorWithTeamThreadsAndVectors(C functor, const global_index_type batch_size, const int threads_per_team=-1, const int vector_lanes_per_thread=-1, std::string functor_name=typeid(C).name()) const
Calls a parallel_for parallel_for will break out over loops over teams with each vector lane executin...