Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
_flow_graph_types_impl.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2005-2019 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__flow_graph_types_impl_H
18 #define __TBB__flow_graph_types_impl_H
19 
20 #ifndef __TBB_flow_graph_H
21 #error Do not #include this internal file directly; use public TBB headers instead.
22 #endif
23 
24 // included in namespace tbb::flow::interfaceX
25 
26 namespace internal {
27 
28  // the change to key_matching (adding a K and KHash template parameter, making it a class)
29  // means we have to pass this data to the key_matching_port. All the ports have only one
30  // template parameter, so we have to wrap the following types in a trait:
31  //
32  // . K == key_type
33  // . KHash == hash and compare for Key
34  // . TtoK == function_body that given an object of T, returns its K
35  // . T == type accepted by port, and stored in the hash table
36  //
37  // The port will have an additional parameter on node construction, which is a function_body
38  // that accepts a const T& and returns a K which is the field in T which is its K.
39  template<typename Kp, typename KHashp, typename Tp>
40  struct KeyTrait {
41  typedef Kp K;
42  typedef Tp T;
44  typedef KHashp KHash;
45  };
46 
47 // wrap each element of a tuple in a template, and make a tuple of the result.
48  template<int N, template<class> class PT, typename TypeTuple>
50 
51  // A wrapper that generates the traits needed for each port of a key-matching join,
52  // and the type of the tuple of input ports.
53  template<int N, template<class> class PT, typename KeyTraits, typename TypeTuple>
55 
56  template<template<class> class PT, typename TypeTuple>
57  struct wrap_tuple_elements<1, PT, TypeTuple> {
58  typedef typename tbb::flow::tuple<
61  };
62 
63  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
64  struct wrap_key_tuple_elements<1, PT, KeyTraits, TypeTuple > {
65  typedef typename KeyTraits::key_type K;
66  typedef typename KeyTraits::hash_compare_type KHash;
68  typedef typename tbb::flow::tuple< PT<KeyTrait0> > type;
69  };
70 
71  template<template<class> class PT, typename TypeTuple>
72  struct wrap_tuple_elements<2, PT, TypeTuple> {
73  typedef typename tbb::flow::tuple<
77  };
78 
79  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
80  struct wrap_key_tuple_elements<2, PT, KeyTraits, TypeTuple> {
81  typedef typename KeyTraits::key_type K;
82  typedef typename KeyTraits::hash_compare_type KHash;
85  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1> > type;
86  };
87 
88  template<template<class> class PT, typename TypeTuple>
89  struct wrap_tuple_elements<3, PT, TypeTuple> {
90  typedef typename tbb::flow::tuple<
95  };
96 
97  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
98  struct wrap_key_tuple_elements<3, PT, KeyTraits, TypeTuple> {
99  typedef typename KeyTraits::key_type K;
100  typedef typename KeyTraits::hash_compare_type KHash;
104  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2> > type;
105  };
106 
107  template<template<class> class PT, typename TypeTuple>
108  struct wrap_tuple_elements<4, PT, TypeTuple> {
109  typedef typename tbb::flow::tuple<
115  };
116 
117  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
118  struct wrap_key_tuple_elements<4, PT, KeyTraits, TypeTuple> {
119  typedef typename KeyTraits::key_type K;
120  typedef typename KeyTraits::hash_compare_type KHash;
125  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
126  PT<KeyTrait3> > type;
127  };
128 
129  template<template<class> class PT, typename TypeTuple>
130  struct wrap_tuple_elements<5, PT, TypeTuple> {
131  typedef typename tbb::flow::tuple<
138  };
139 
140  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
141  struct wrap_key_tuple_elements<5, PT, KeyTraits, TypeTuple> {
142  typedef typename KeyTraits::key_type K;
143  typedef typename KeyTraits::hash_compare_type KHash;
149  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
150  PT<KeyTrait3>, PT<KeyTrait4> > type;
151  };
152 
153 #if __TBB_VARIADIC_MAX >= 6
154  template<template<class> class PT, typename TypeTuple>
155  struct wrap_tuple_elements<6, PT, TypeTuple> {
156  typedef typename tbb::flow::tuple<
163  type;
164  };
165 
166  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
167  struct wrap_key_tuple_elements<6, PT, KeyTraits, TypeTuple> {
168  typedef typename KeyTraits::key_type K;
169  typedef typename KeyTraits::hash_compare_type KHash;
176  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
177  PT<KeyTrait4>, PT<KeyTrait5> > type;
178  };
179 #endif
180 
181 #if __TBB_VARIADIC_MAX >= 7
182  template<template<class> class PT, typename TypeTuple>
183  struct wrap_tuple_elements<7, PT, TypeTuple> {
184  typedef typename tbb::flow::tuple<
192  type;
193  };
194 
195  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
196  struct wrap_key_tuple_elements<7, PT, KeyTraits, TypeTuple> {
197  typedef typename KeyTraits::key_type K;
198  typedef typename KeyTraits::hash_compare_type KHash;
206  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
207  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6> > type;
208  };
209 #endif
210 
211 #if __TBB_VARIADIC_MAX >= 8
212  template<template<class> class PT, typename TypeTuple>
213  struct wrap_tuple_elements<8, PT, TypeTuple> {
214  typedef typename tbb::flow::tuple<
223  type;
224  };
225 
226  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
227  struct wrap_key_tuple_elements<8, PT, KeyTraits, TypeTuple> {
228  typedef typename KeyTraits::key_type K;
229  typedef typename KeyTraits::hash_compare_type KHash;
238  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
239  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7> > type;
240  };
241 #endif
242 
243 #if __TBB_VARIADIC_MAX >= 9
244  template<template<class> class PT, typename TypeTuple>
245  struct wrap_tuple_elements<9, PT, TypeTuple> {
246  typedef typename tbb::flow::tuple<
256  type;
257  };
258 
259  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
260  struct wrap_key_tuple_elements<9, PT, KeyTraits, TypeTuple> {
261  typedef typename KeyTraits::key_type K;
262  typedef typename KeyTraits::hash_compare_type KHash;
272  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
273  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8> > type;
274  };
275 #endif
276 
277 #if __TBB_VARIADIC_MAX >= 10
278  template<template<class> class PT, typename TypeTuple>
279  struct wrap_tuple_elements<10, PT, TypeTuple> {
280  typedef typename tbb::flow::tuple<
291  type;
292  };
293 
294  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
295  struct wrap_key_tuple_elements<10, PT, KeyTraits, TypeTuple> {
296  typedef typename KeyTraits::key_type K;
297  typedef typename KeyTraits::hash_compare_type KHash;
308  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
309  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8>,
310  PT<KeyTrait9> > type;
311  };
312 #endif
313 
314 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
315  template< int... S > class sequence {};
316 
317  template< int N, int... S >
318  struct make_sequence : make_sequence < N - 1, N - 1, S... > {};
319 
320  template< int... S >
321  struct make_sequence < 0, S... > {
322  typedef sequence<S...> type;
323  };
324 #endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT */
325 
326 #if __TBB_INITIALIZER_LISTS_PRESENT
327  // Until C++14 std::initializer_list does not guarantee life time of contained objects.
328  template <typename T>
330  public:
331  typedef T value_type;
332  typedef const T& reference;
333  typedef const T& const_reference;
334  typedef size_t size_type;
335 
336  typedef T* iterator;
337  typedef const T* const_iterator;
338 
339  initializer_list_wrapper( std::initializer_list<T> il ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( il.size()*sizeof( T ) )) ) {
340  iterator dst = my_begin;
341  for ( typename std::initializer_list<T>::const_iterator src = il.begin(); src != il.end(); ++src )
342  new (dst++) T( *src );
343  my_end = dst;
344  }
345 
346  initializer_list_wrapper( const initializer_list_wrapper<T>& ilw ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( ilw.size()*sizeof( T ) )) ) {
347  iterator dst = my_begin;
348  for ( typename std::initializer_list<T>::const_iterator src = ilw.begin(); src != ilw.end(); ++src )
349  new (dst++) T( *src );
350  my_end = dst;
351  }
352 
353 #if __TBB_CPP11_RVALUE_REF_PRESENT
355  ilw.my_begin = ilw.my_end = NULL;
356  }
357 #endif /* __TBB_CPP11_RVALUE_REF_PRESENT */
358 
360  if ( my_begin )
361  free( my_begin );
362  }
363 
364  const_iterator begin() const __TBB_NOEXCEPT(true) { return my_begin; }
365  const_iterator end() const __TBB_NOEXCEPT(true) { return my_end; }
366  size_t size() const __TBB_NOEXCEPT(true) { return (size_t)(my_end - my_begin); }
367 
368  private:
371  };
372 #endif /* __TBB_INITIALIZER_LISTS_PRESENT */
373 
375 //* will have the correct alignment
376  template<typename T1, typename T2, size_t REM>
378  char first[sizeof(T1)];
379  T2 second;
380  char fill1[REM];
381  };
382 
383  template<typename T1, typename T2>
384  struct type_plus_align<T1,T2,0> {
385  char first[sizeof(T1)];
386  T2 second;
387  };
388 
389  template<class U> struct alignment_of {
390  typedef struct { char t; U padded; } test_alignment;
391  static const size_t value = sizeof(test_alignment) - sizeof(U);
392  };
393 
394  // T1, T2 are actual types stored. The space defined for T1 in the type returned
395  // is a char array of the correct size. Type T2 should be trivially-constructible,
396  // T1 must be explicitly managed.
397  template<typename T1, typename T2>
398  struct aligned_pair {
399  static const size_t t1_align = alignment_of<T1>::value;
400  static const size_t t2_align = alignment_of<T2>::value;
402  static const size_t max_align = t1_align < t2_align ? t2_align : t1_align;
403  static const size_t extra_bytes = sizeof(just_pair) % max_align;
404  static const size_t remainder = extra_bytes ? max_align - extra_bytes : 0;
405  public:
407  }; // aligned_pair
408 
409 // support for variant type
410 // type we use when we're not storing a value
412 
413 // type which contains another type, tests for what type is contained, and references to it.
414 // internal::Wrapper<T>
415 // void CopyTo( void *newSpace) : builds a Wrapper<T> copy of itself in newSpace
416 
417 // struct to allow us to copy and test the type of objects
418 struct WrapperBase {
419  virtual ~WrapperBase() {}
420  virtual void CopyTo(void* /*newSpace*/) const { }
421 };
422 
423 // Wrapper<T> contains a T, with the ability to test what T is. The Wrapper<T> can be
424 // constructed from a T, can be copy-constructed from another Wrapper<T>, and can be
425 // examined via value(), but not modified.
426 template<typename T>
427 struct Wrapper: public WrapperBase {
428  typedef T value_type;
429  typedef T* pointer_type;
430 private:
432 public:
433  const value_type &value() const { return value_space; }
434 
435 private:
436  Wrapper();
437 
438  // on exception will ensure the Wrapper will contain only a trivially-constructed object
439  struct _unwind_space {
444  }
445  };
446 public:
447  explicit Wrapper( const T& other ) : value_space(other) { }
448  explicit Wrapper(const Wrapper& other) : value_space(other.value_space) { }
449 
450  void CopyTo(void* newSpace) const __TBB_override {
451  _unwind_space guard((pointer_type)newSpace);
452  (void) new(newSpace) Wrapper(value_space);
453  guard.space = NULL;
454  }
455  ~Wrapper() { }
456 };
457 
458 // specialization for array objects
459 template<typename T, size_t N>
460 struct Wrapper<T[N]> : public WrapperBase {
461  typedef T value_type;
462  typedef T* pointer_type;
463  // space must be untyped.
464  typedef T ArrayType[N];
465 private:
466  // The space is not of type T[N] because when copy-constructing, it would be
467  // default-initialized and then copied to in some fashion, resulting in two
468  // constructions and one destruction per element. If the type is char[ ], we
469  // placement new into each element, resulting in one construction per element.
470  static const size_t space_size = sizeof(ArrayType) / sizeof(char);
471  char value_space[space_size];
472 
473 
474  // on exception will ensure the already-built objects will be destructed
475  // (the value_space is a char array, so it is already trivially-destructible.)
476  struct _unwind_class {
479  _unwind_class(pointer_type p) : space(p), already_built(0) {}
481  if(space) {
482  for(size_t i = already_built; i > 0 ; --i ) space[i-1].~value_type();
484  }
485  }
486  };
487 public:
488  const ArrayType &value() const {
489  char *vp = const_cast<char *>(value_space);
490  return reinterpret_cast<ArrayType &>(*vp);
491  }
492 
493 private:
494  Wrapper();
495 public:
496  // have to explicitly construct because other decays to a const value_type*
497  explicit Wrapper(const ArrayType& other) {
498  _unwind_class guard((pointer_type)value_space);
499  pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
500  for(size_t i = 0; i < N; ++i ) {
501  (void) new(vp++) value_type(other[i]);
502  ++(guard.already_built);
503  }
504  guard.space = NULL;
505  }
506  explicit Wrapper(const Wrapper& other) : WrapperBase() {
507  // we have to do the heavy lifting to copy contents
508  _unwind_class guard((pointer_type)value_space);
509  pointer_type dp = reinterpret_cast<pointer_type>(value_space);
510  pointer_type sp = reinterpret_cast<pointer_type>(const_cast<char *>(other.value_space));
511  for(size_t i = 0; i < N; ++i, ++dp, ++sp) {
512  (void) new(dp) value_type(*sp);
513  ++(guard.already_built);
514  }
515  guard.space = NULL;
516  }
517 
518  void CopyTo(void* newSpace) const __TBB_override {
519  (void) new(newSpace) Wrapper(*this); // exceptions handled in copy constructor
520  }
521 
523  // have to destroy explicitly in reverse order
524  pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
525  for(size_t i = N; i > 0 ; --i ) vp[i-1].~value_type();
526  }
527 };
528 
529 // given a tuple, return the type of the element that has the maximum alignment requirement.
530 // Given a tuple and that type, return the number of elements of the object with the max
531 // alignment requirement that is at least as big as the largest object in the tuple.
532 
533 template<bool, class T1, class T2> struct pick_one;
534 template<class T1, class T2> struct pick_one<true , T1, T2> { typedef T1 type; };
535 template<class T1, class T2> struct pick_one<false, T1, T2> { typedef T2 type; };
536 
537 template< template<class> class Selector, typename T1, typename T2 >
538 struct pick_max {
539  typedef typename pick_one< (Selector<T1>::value > Selector<T2>::value), T1, T2 >::type type;
540 };
541 
542 template<typename T> struct size_of { static const int value = sizeof(T); };
543 
544 template< size_t N, class Tuple, template<class> class Selector > struct pick_tuple_max {
545  typedef typename pick_tuple_max<N-1, Tuple, Selector>::type LeftMaxType;
546  typedef typename tbb::flow::tuple_element<N-1, Tuple>::type ThisType;
548 };
549 
550 template< class Tuple, template<class> class Selector > struct pick_tuple_max<0, Tuple, Selector> {
552 };
553 
554 // is the specified type included in a tuple?
555 template<class Q, size_t N, class Tuple>
557  typedef typename tbb::flow::tuple_element<N-1, Tuple>::type T_i;
559 };
560 
561 template<class Q, class Tuple>
562 struct is_element_of<Q,0,Tuple> {
565 };
566 
567 // allow the construction of types that are listed tuple. If a disallowed type
568 // construction is written, a method involving this type is created. The
569 // type has no definition, so a syntax error is generated.
571 
572 template<typename T, bool BUILD_IT> struct do_if;
573 template<typename T>
574 struct do_if<T, true> {
575  static void construct(void *mySpace, const T& x) {
576  (void) new(mySpace) Wrapper<T>(x);
577  }
578 };
579 template<typename T>
580 struct do_if<T, false> {
581  static void construct(void * /*mySpace*/, const T& x) {
582  // This method is instantiated when the type T does not match any of the
583  // element types in the Tuple in variant<Tuple>.
585  }
586 };
587 
588 // Tuple tells us the allowed types that variant can hold. It determines the alignment of the space in
589 // Wrapper, and how big Wrapper is.
590 //
591 // the object can only be tested for type, and a read-only reference can be fetched by cast_to<T>().
592 
595 template<typename TagType, typename T0, typename T1=tagged_null_type, typename T2=tagged_null_type, typename T3=tagged_null_type,
596  typename T4=tagged_null_type, typename T5=tagged_null_type, typename T6=tagged_null_type,
597  typename T7=tagged_null_type, typename T8=tagged_null_type, typename T9=tagged_null_type>
598 class tagged_msg {
599  typedef tbb::flow::tuple<T0, T1, T2, T3, T4
600  //TODO: Should we reject lists longer than a tuple can hold?
601  #if __TBB_VARIADIC_MAX >= 6
602  , T5
603  #endif
604  #if __TBB_VARIADIC_MAX >= 7
605  , T6
606  #endif
607  #if __TBB_VARIADIC_MAX >= 8
608  , T7
609  #endif
610  #if __TBB_VARIADIC_MAX >= 9
611  , T8
612  #endif
613  #if __TBB_VARIADIC_MAX >= 10
614  , T9
615  #endif
616  > Tuple;
617 
618 private:
619  class variant {
620  static const size_t N = tbb::flow::tuple_size<Tuple>::value;
623  static const size_t MaxNBytes = (sizeof(Wrapper<MaxSizeType>)+sizeof(AlignType)-1);
624  static const size_t MaxNElements = MaxNBytes/sizeof(AlignType);
627  static const size_t MaxSize = sizeof(SpaceType);
628 
629  public:
631 
632  template<typename T>
633  variant( const T& x ) {
635  }
636 
637  variant(const variant& other) {
638  const WrapperBase * h = punned_cast<const WrapperBase *>(&(other.my_space));
639  h->CopyTo(&my_space);
640  }
641 
642  // assignment must destroy and re-create the Wrapper type, as there is no way
643  // to create a Wrapper-to-Wrapper assign even if we find they agree in type.
644  void operator=( const variant& rhs ) {
645  if(&rhs != this) {
646  WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
647  h->~WrapperBase();
648  const WrapperBase *ch = punned_cast<const WrapperBase *>(&(rhs.my_space));
649  ch->CopyTo(&my_space);
650  }
651  }
652 
653  template<typename U>
654  const U& variant_cast_to() const {
655  const Wrapper<U> *h = dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space));
656  if(!h) {
658  }
659  return h->value();
660  }
661  template<typename U>
662  bool variant_is_a() const { return dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space)) != NULL; }
663 
664  bool variant_is_default_constructed() const {return variant_is_a<default_constructed>();}
665 
667  WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
668  h->~WrapperBase();
669  }
670  }; //class variant
671 
672  TagType my_tag;
674 
675 public:
676  tagged_msg(): my_tag(TagType(~0)), my_msg(){}
677 
678  template<typename T, typename R>
679  tagged_msg(T const &index, R const &value) : my_tag(index), my_msg(value) {}
680 
681  #if __TBB_CONST_REF_TO_ARRAY_TEMPLATE_PARAM_BROKEN
682  template<typename T, typename R, size_t N>
683  tagged_msg(T const &index, R (&value)[N]) : my_tag(index), my_msg(value) {}
684  #endif
685 
686  void set_tag(TagType const &index) {my_tag = index;}
687  TagType tag() const {return my_tag;}
688 
689  template<typename V>
690  const V& cast_to() const {return my_msg.template variant_cast_to<V>();}
691 
692  template<typename V>
693  bool is_a() const {return my_msg.template variant_is_a<V>();}
694 
696 }; //class tagged_msg
697 
698 // template to simplify cast and test for tagged_msg in template contexts
699 template<typename V, typename T>
700 const V& cast_to(T const &t) { return t.template cast_to<V>(); }
701 
702 template<typename V, typename T>
703 bool is_a(T const &t) { return t.template is_a<V>(); }
704 
705 enum op_stat { WAIT = 0, SUCCEEDED, FAILED };
706 
707 } // namespace internal
708 
709 #endif /* __TBB__flow_graph_types_impl_H */
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark S
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
const ArrayType & value() const
const_iterator begin() const __TBB_NOEXCEPT(true)
pick_tuple_max< N, Tuple, alignment_of >::type AlignType
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 >, PT< KeyTrait3 >, PT< KeyTrait4 > > type
size_t size() const __TBB_NOEXCEPT(true)
pick_tuple_max< N-1, Tuple, Selector >::type LeftMaxType
initializer_list_wrapper(const initializer_list_wrapper< T > &ilw) __TBB_NOEXCEPT(true)
static const size_t remainder
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 > > type
initializer_list_wrapper(std::initializer_list< T > il) __TBB_NOEXCEPT(true)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type > > type
static void construct(void *mySpace, const T &x)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 4, TypeTuple >::type > KeyTrait4
Wrapper(const ArrayType &other)
tbb::flow::tuple_element< 0, Tuple >::type type
type_plus_align< T1, T2, remainder > type
T punned_cast(U *ptr)
Cast between unrelated pointer types.
Definition: tbb_stddef.h:314
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 > > type
Detects whether two given types are the same.
#define __TBB_override
Definition: tbb_stddef.h:240
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
pick_one<(Selector< T1 >::value > Selector< T2 >::value), T1, T2 >::type type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
void CopyTo(void *newSpace) const __TBB_override
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
static void construct(void *, const T &x)
type_plus_align< T1, T2, 0 > just_pair
tbb::aligned_space< AlignType, MaxNElements > SpaceType
void CopyTo(void *newSpace) const __TBB_override
bool is_a(T const &t)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
void operator=(const variant &rhs)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function h
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
initializer_list_wrapper(initializer_list_wrapper< T > &&ilw) __TBB_NOEXCEPT(true)
tbb::flow::tuple_element< N-1, Tuple >::type T_i
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 1, TypeTuple >::type > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
pick_max< Selector, LeftMaxType, ThisType >::type type
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 1, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 2, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 3, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 4, TypeTuple >::type > > type
tbb::flow::tuple_element< 0, Tuple >::type T_i
void set_tag(TagType const &index)
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 1, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 2, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 3, TypeTuple >::type > > type
static const size_t t1_align
void const char const char int ITT_FORMAT __itt_group_sync p
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 >, PT< KeyTrait3 > > type
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 1, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 2, TypeTuple >::type > > type
tbb::flow::tuple< T0, T1, T2, T3, T4 > Tuple
pick_tuple_max< N, Tuple, size_of >::type MaxSizeType
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
type mimicking std::pair but with trailing fill to ensure each element of an array
tagged_msg(T const &index, R const &value)
internal::type_to_key_function_body< T, K > TtoK
const_iterator end() const __TBB_NOEXCEPT(true)
static const size_t max_align
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
Wrapper(const Wrapper &other)
const V & cast_to(T const &t)
static const size_t t2_align
virtual void CopyTo(void *) const
const value_type & value() const
#define __TBB_NOEXCEPT(expression)
Definition: tbb_stddef.h:110
Wrapper(const Wrapper &other)
tbb::flow::tuple_element< N-1, Tuple >::type ThisType
static const size_t extra_bytes

Copyright © 2005-2019 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.