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 
18 
19 */
20 
21 #ifndef __TBB__flow_graph_types_impl_H
22 #define __TBB__flow_graph_types_impl_H
23 
24 #ifndef __TBB_flow_graph_H
25 #error Do not #include this internal file directly; use public TBB headers instead.
26 #endif
27 
28 // included in namespace tbb::flow::interfaceX
29 
30 namespace internal {
31 
32  // the change to key_matching (adding a K and KHash template parameter, making it a class)
33  // means we have to pass this data to the key_matching_port. All the ports have only one
34  // template parameter, so we have to wrap the following types in a trait:
35  //
36  // . K == key_type
37  // . KHash == hash and compare for Key
38  // . TtoK == function_body that given an object of T, returns its K
39  // . T == type accepted by port, and stored in the hash table
40  //
41  // The port will have an additional parameter on node construction, which is a function_body
42  // that accepts a const T& and returns a K which is the field in T which is its K.
43  template<typename Kp, typename KHashp, typename Tp>
44  struct KeyTrait {
45  typedef Kp K;
46  typedef Tp T;
48  typedef KHashp KHash;
49  };
50 
51 // wrap each element of a tuple in a template, and make a tuple of the result.
52  template<int N, template<class> class PT, typename TypeTuple>
54 
55  // A wrapper that generates the traits needed for each port of a key-matching join,
56  // and the type of the tuple of input ports.
57  template<int N, template<class> class PT, typename KeyTraits, typename TypeTuple>
59 
60  template<template<class> class PT, typename TypeTuple>
61  struct wrap_tuple_elements<1, PT, TypeTuple> {
62  typedef typename tbb::flow::tuple<
65  };
66 
67  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
68  struct wrap_key_tuple_elements<1, PT, KeyTraits, TypeTuple > {
69  typedef typename KeyTraits::key_type K;
70  typedef typename KeyTraits::hash_compare_type KHash;
72  typedef typename tbb::flow::tuple< PT<KeyTrait0> > type;
73  };
74 
75  template<template<class> class PT, typename TypeTuple>
76  struct wrap_tuple_elements<2, PT, TypeTuple> {
77  typedef typename tbb::flow::tuple<
81  };
82 
83  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
84  struct wrap_key_tuple_elements<2, PT, KeyTraits, TypeTuple> {
85  typedef typename KeyTraits::key_type K;
86  typedef typename KeyTraits::hash_compare_type KHash;
89  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1> > type;
90  };
91 
92  template<template<class> class PT, typename TypeTuple>
93  struct wrap_tuple_elements<3, PT, TypeTuple> {
94  typedef typename tbb::flow::tuple<
99  };
100 
101  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
102  struct wrap_key_tuple_elements<3, PT, KeyTraits, TypeTuple> {
103  typedef typename KeyTraits::key_type K;
104  typedef typename KeyTraits::hash_compare_type KHash;
108  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2> > type;
109  };
110 
111  template<template<class> class PT, typename TypeTuple>
112  struct wrap_tuple_elements<4, PT, TypeTuple> {
113  typedef typename tbb::flow::tuple<
119  };
120 
121  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
122  struct wrap_key_tuple_elements<4, PT, KeyTraits, TypeTuple> {
123  typedef typename KeyTraits::key_type K;
124  typedef typename KeyTraits::hash_compare_type KHash;
129  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
130  PT<KeyTrait3> > type;
131  };
132 
133  template<template<class> class PT, typename TypeTuple>
134  struct wrap_tuple_elements<5, PT, TypeTuple> {
135  typedef typename tbb::flow::tuple<
142  };
143 
144  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
145  struct wrap_key_tuple_elements<5, PT, KeyTraits, TypeTuple> {
146  typedef typename KeyTraits::key_type K;
147  typedef typename KeyTraits::hash_compare_type KHash;
153  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
154  PT<KeyTrait3>, PT<KeyTrait4> > type;
155  };
156 
157 #if __TBB_VARIADIC_MAX >= 6
158  template<template<class> class PT, typename TypeTuple>
159  struct wrap_tuple_elements<6, PT, TypeTuple> {
160  typedef typename tbb::flow::tuple<
167  type;
168  };
169 
170  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
171  struct wrap_key_tuple_elements<6, PT, KeyTraits, TypeTuple> {
172  typedef typename KeyTraits::key_type K;
173  typedef typename KeyTraits::hash_compare_type KHash;
180  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
181  PT<KeyTrait4>, PT<KeyTrait5> > type;
182  };
183 #endif
184 
185 #if __TBB_VARIADIC_MAX >= 7
186  template<template<class> class PT, typename TypeTuple>
187  struct wrap_tuple_elements<7, PT, TypeTuple> {
188  typedef typename tbb::flow::tuple<
196  type;
197  };
198 
199  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
200  struct wrap_key_tuple_elements<7, PT, KeyTraits, TypeTuple> {
201  typedef typename KeyTraits::key_type K;
202  typedef typename KeyTraits::hash_compare_type KHash;
210  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
211  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6> > type;
212  };
213 #endif
214 
215 #if __TBB_VARIADIC_MAX >= 8
216  template<template<class> class PT, typename TypeTuple>
217  struct wrap_tuple_elements<8, PT, TypeTuple> {
218  typedef typename tbb::flow::tuple<
227  type;
228  };
229 
230  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
231  struct wrap_key_tuple_elements<8, PT, KeyTraits, TypeTuple> {
232  typedef typename KeyTraits::key_type K;
233  typedef typename KeyTraits::hash_compare_type KHash;
242  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
243  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7> > type;
244  };
245 #endif
246 
247 #if __TBB_VARIADIC_MAX >= 9
248  template<template<class> class PT, typename TypeTuple>
249  struct wrap_tuple_elements<9, PT, TypeTuple> {
250  typedef typename tbb::flow::tuple<
260  type;
261  };
262 
263  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
264  struct wrap_key_tuple_elements<9, PT, KeyTraits, TypeTuple> {
265  typedef typename KeyTraits::key_type K;
266  typedef typename KeyTraits::hash_compare_type KHash;
276  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
277  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8> > type;
278  };
279 #endif
280 
281 #if __TBB_VARIADIC_MAX >= 10
282  template<template<class> class PT, typename TypeTuple>
283  struct wrap_tuple_elements<10, PT, TypeTuple> {
284  typedef typename tbb::flow::tuple<
295  type;
296  };
297 
298  template<template<class> class PT, typename KeyTraits, typename TypeTuple>
299  struct wrap_key_tuple_elements<10, PT, KeyTraits, TypeTuple> {
300  typedef typename KeyTraits::key_type K;
301  typedef typename KeyTraits::hash_compare_type KHash;
312  typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
313  PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8>,
314  PT<KeyTrait9> > type;
315  };
316 #endif
317 
318 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
319  template< int... S > class sequence {};
320 
321  template< int N, int... S >
322  struct make_sequence : make_sequence < N - 1, N - 1, S... > {};
323 
324  template< int... S >
325  struct make_sequence < 0, S... > {
326  typedef sequence<S...> type;
327  };
328 #endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT */
329 
330 #if __TBB_INITIALIZER_LISTS_PRESENT
331  // Until C++14 std::initializer_list does not guarantee life time of contained objects.
332  template <typename T>
334  public:
335  typedef T value_type;
336  typedef const T& reference;
337  typedef const T& const_reference;
338  typedef size_t size_type;
339 
340  typedef T* iterator;
341  typedef const T* const_iterator;
342 
343  initializer_list_wrapper( std::initializer_list<T> il ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( il.size()*sizeof( T ) )) ) {
344  iterator dst = my_begin;
345  for ( typename std::initializer_list<T>::const_iterator src = il.begin(); src != il.end(); ++src )
346  new (dst++) T( *src );
347  my_end = dst;
348  }
349 
350  initializer_list_wrapper( const initializer_list_wrapper<T>& ilw ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( ilw.size()*sizeof( T ) )) ) {
351  iterator dst = my_begin;
352  for ( typename std::initializer_list<T>::const_iterator src = ilw.begin(); src != ilw.end(); ++src )
353  new (dst++) T( *src );
354  my_end = dst;
355  }
356 
357 #if __TBB_CPP11_RVALUE_REF_PRESENT
359  ilw.my_begin = ilw.my_end = NULL;
360  }
361 #endif /* __TBB_CPP11_RVALUE_REF_PRESENT */
362 
364  if ( my_begin )
365  free( my_begin );
366  }
367 
368  const_iterator begin() const __TBB_NOEXCEPT(true) { return my_begin; }
369  const_iterator end() const __TBB_NOEXCEPT(true) { return my_end; }
370  size_t size() const __TBB_NOEXCEPT(true) { return (size_t)(my_end - my_begin); }
371 
372  private:
375  };
376 #endif /* __TBB_INITIALIZER_LISTS_PRESENT */
377 
379 //* will have the correct alignment
380  template<typename T1, typename T2, size_t REM>
382  char first[sizeof(T1)];
383  T2 second;
384  char fill1[REM];
385  };
386 
387  template<typename T1, typename T2>
388  struct type_plus_align<T1,T2,0> {
389  char first[sizeof(T1)];
390  T2 second;
391  };
392 
393  template<class U> struct alignment_of {
394  typedef struct { char t; U padded; } test_alignment;
395  static const size_t value = sizeof(test_alignment) - sizeof(U);
396  };
397 
398  // T1, T2 are actual types stored. The space defined for T1 in the type returned
399  // is a char array of the correct size. Type T2 should be trivially-constructible,
400  // T1 must be explicitly managed.
401  template<typename T1, typename T2>
402  struct aligned_pair {
403  static const size_t t1_align = alignment_of<T1>::value;
404  static const size_t t2_align = alignment_of<T2>::value;
406  static const size_t max_align = t1_align < t2_align ? t2_align : t1_align;
407  static const size_t extra_bytes = sizeof(just_pair) % max_align;
408  static const size_t remainder = extra_bytes ? max_align - extra_bytes : 0;
409  public:
411  }; // aligned_pair
412 
413 // support for variant type
414 // type we use when we're not storing a value
416 
417 // type which contains another type, tests for what type is contained, and references to it.
418 // internal::Wrapper<T>
419 // void CopyTo( void *newSpace) : builds a Wrapper<T> copy of itself in newSpace
420 
421 // struct to allow us to copy and test the type of objects
422 struct WrapperBase {
423  virtual ~WrapperBase() {}
424  virtual void CopyTo(void* /*newSpace*/) const { }
425 };
426 
427 // Wrapper<T> contains a T, with the ability to test what T is. The Wrapper<T> can be
428 // constructed from a T, can be copy-constructed from another Wrapper<T>, and can be
429 // examined via value(), but not modified.
430 template<typename T>
431 struct Wrapper: public WrapperBase {
432  typedef T value_type;
433  typedef T* pointer_type;
434 private:
436 public:
437  const value_type &value() const { return value_space; }
438 
439 private:
440  Wrapper();
441 
442  // on exception will ensure the Wrapper will contain only a trivially-constructed object
443  struct _unwind_space {
448  }
449  };
450 public:
451  explicit Wrapper( const T& other ) : value_space(other) { }
452  explicit Wrapper(const Wrapper& other) : value_space(other.value_space) { }
453 
454  void CopyTo(void* newSpace) const __TBB_override {
455  _unwind_space guard((pointer_type)newSpace);
456  (void) new(newSpace) Wrapper(value_space);
457  guard.space = NULL;
458  }
459  ~Wrapper() { }
460 };
461 
462 // specialization for array objects
463 template<typename T, size_t N>
464 struct Wrapper<T[N]> : public WrapperBase {
465  typedef T value_type;
466  typedef T* pointer_type;
467  // space must be untyped.
468  typedef T ArrayType[N];
469 private:
470  // The space is not of type T[N] because when copy-constructing, it would be
471  // default-initialized and then copied to in some fashion, resulting in two
472  // constructions and one destruction per element. If the type is char[ ], we
473  // placement new into each element, resulting in one construction per element.
474  static const size_t space_size = sizeof(ArrayType) / sizeof(char);
475  char value_space[space_size];
476 
477 
478  // on exception will ensure the already-built objects will be destructed
479  // (the value_space is a char array, so it is already trivially-destructible.)
480  struct _unwind_class {
483  _unwind_class(pointer_type p) : space(p), already_built(0) {}
485  if(space) {
486  for(size_t i = already_built; i > 0 ; --i ) space[i-1].~value_type();
488  }
489  }
490  };
491 public:
492  const ArrayType &value() const {
493  char *vp = const_cast<char *>(value_space);
494  return reinterpret_cast<ArrayType &>(*vp);
495  }
496 
497 private:
498  Wrapper();
499 public:
500  // have to explicitly construct because other decays to a const value_type*
501  explicit Wrapper(const ArrayType& other) {
502  _unwind_class guard((pointer_type)value_space);
503  pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
504  for(size_t i = 0; i < N; ++i ) {
505  (void) new(vp++) value_type(other[i]);
506  ++(guard.already_built);
507  }
508  guard.space = NULL;
509  }
510  explicit Wrapper(const Wrapper& other) : WrapperBase() {
511  // we have to do the heavy lifting to copy contents
512  _unwind_class guard((pointer_type)value_space);
513  pointer_type dp = reinterpret_cast<pointer_type>(value_space);
514  pointer_type sp = reinterpret_cast<pointer_type>(const_cast<char *>(other.value_space));
515  for(size_t i = 0; i < N; ++i, ++dp, ++sp) {
516  (void) new(dp) value_type(*sp);
517  ++(guard.already_built);
518  }
519  guard.space = NULL;
520  }
521 
522  void CopyTo(void* newSpace) const __TBB_override {
523  (void) new(newSpace) Wrapper(*this); // exceptions handled in copy constructor
524  }
525 
527  // have to destroy explicitly in reverse order
528  pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
529  for(size_t i = N; i > 0 ; --i ) vp[i-1].~value_type();
530  }
531 };
532 
533 // given a tuple, return the type of the element that has the maximum alignment requirement.
534 // Given a tuple and that type, return the number of elements of the object with the max
535 // alignment requirement that is at least as big as the largest object in the tuple.
536 
537 template<bool, class T1, class T2> struct pick_one;
538 template<class T1, class T2> struct pick_one<true , T1, T2> { typedef T1 type; };
539 template<class T1, class T2> struct pick_one<false, T1, T2> { typedef T2 type; };
540 
541 template< template<class> class Selector, typename T1, typename T2 >
542 struct pick_max {
543  typedef typename pick_one< (Selector<T1>::value > Selector<T2>::value), T1, T2 >::type type;
544 };
545 
546 template<typename T> struct size_of { static const int value = sizeof(T); };
547 
548 template< size_t N, class Tuple, template<class> class Selector > struct pick_tuple_max {
549  typedef typename pick_tuple_max<N-1, Tuple, Selector>::type LeftMaxType;
550  typedef typename tbb::flow::tuple_element<N-1, Tuple>::type ThisType;
552 };
553 
554 template< class Tuple, template<class> class Selector > struct pick_tuple_max<0, Tuple, Selector> {
556 };
557 
558 // is the specified type included in a tuple?
559 template<class Q, size_t N, class Tuple>
561  typedef typename tbb::flow::tuple_element<N-1, Tuple>::type T_i;
563 };
564 
565 template<class Q, class Tuple>
566 struct is_element_of<Q,0,Tuple> {
569 };
570 
571 // allow the construction of types that are listed tuple. If a disallowed type
572 // construction is written, a method involving this type is created. The
573 // type has no definition, so a syntax error is generated.
575 
576 template<typename T, bool BUILD_IT> struct do_if;
577 template<typename T>
578 struct do_if<T, true> {
579  static void construct(void *mySpace, const T& x) {
580  (void) new(mySpace) Wrapper<T>(x);
581  }
582 };
583 template<typename T>
584 struct do_if<T, false> {
585  static void construct(void * /*mySpace*/, const T& x) {
586  // This method is instantiated when the type T does not match any of the
587  // element types in the Tuple in variant<Tuple>.
589  }
590 };
591 
592 // Tuple tells us the allowed types that variant can hold. It determines the alignment of the space in
593 // Wrapper, and how big Wrapper is.
594 //
595 // the object can only be tested for type, and a read-only reference can be fetched by cast_to<T>().
596 
599 template<typename TagType, typename T0, typename T1=tagged_null_type, typename T2=tagged_null_type, typename T3=tagged_null_type,
600  typename T4=tagged_null_type, typename T5=tagged_null_type, typename T6=tagged_null_type,
601  typename T7=tagged_null_type, typename T8=tagged_null_type, typename T9=tagged_null_type>
602 class tagged_msg {
603  typedef tbb::flow::tuple<T0, T1, T2, T3, T4
604  //TODO: Should we reject lists longer than a tuple can hold?
605  #if __TBB_VARIADIC_MAX >= 6
606  , T5
607  #endif
608  #if __TBB_VARIADIC_MAX >= 7
609  , T6
610  #endif
611  #if __TBB_VARIADIC_MAX >= 8
612  , T7
613  #endif
614  #if __TBB_VARIADIC_MAX >= 9
615  , T8
616  #endif
617  #if __TBB_VARIADIC_MAX >= 10
618  , T9
619  #endif
620  > Tuple;
621 
622 private:
623  class variant {
624  static const size_t N = tbb::flow::tuple_size<Tuple>::value;
627  static const size_t MaxNBytes = (sizeof(Wrapper<MaxSizeType>)+sizeof(AlignType)-1);
628  static const size_t MaxNElements = MaxNBytes/sizeof(AlignType);
631  static const size_t MaxSize = sizeof(SpaceType);
632 
633  public:
635 
636  template<typename T>
637  variant( const T& x ) {
639  }
640 
641  variant(const variant& other) {
642  const WrapperBase * h = punned_cast<const WrapperBase *>(&(other.my_space));
643  h->CopyTo(&my_space);
644  }
645 
646  // assignment must destroy and re-create the Wrapper type, as there is no way
647  // to create a Wrapper-to-Wrapper assign even if we find they agree in type.
648  void operator=( const variant& rhs ) {
649  if(&rhs != this) {
650  WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
651  h->~WrapperBase();
652  const WrapperBase *ch = punned_cast<const WrapperBase *>(&(rhs.my_space));
653  ch->CopyTo(&my_space);
654  }
655  }
656 
657  template<typename U>
658  const U& variant_cast_to() const {
659  const Wrapper<U> *h = dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space));
660  if(!h) {
662  }
663  return h->value();
664  }
665  template<typename U>
666  bool variant_is_a() const { return dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space)) != NULL; }
667 
668  bool variant_is_default_constructed() const {return variant_is_a<default_constructed>();}
669 
671  WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
672  h->~WrapperBase();
673  }
674  }; //class variant
675 
676  TagType my_tag;
678 
679 public:
680  tagged_msg(): my_tag(TagType(~0)), my_msg(){}
681 
682  template<typename T, typename R>
683  tagged_msg(T const &index, R const &value) : my_tag(index), my_msg(value) {}
684 
685  #if __TBB_CONST_REF_TO_ARRAY_TEMPLATE_PARAM_BROKEN
686  template<typename T, typename R, size_t N>
687  tagged_msg(T const &index, R (&value)[N]) : my_tag(index), my_msg(value) {}
688  #endif
689 
690  void set_tag(TagType const &index) {my_tag = index;}
691  TagType tag() const {return my_tag;}
692 
693  template<typename V>
694  const V& cast_to() const {return my_msg.template variant_cast_to<V>();}
695 
696  template<typename V>
697  bool is_a() const {return my_msg.template variant_is_a<V>();}
698 
700 }; //class tagged_msg
701 
702 // template to simplify cast and test for tagged_msg in template contexts
703 template<typename V, typename T>
704 const V& cast_to(T const &t) { return t.template cast_to<V>(); }
705 
706 template<typename V, typename T>
707 bool is_a(T const &t) { return t.template is_a<V>(); }
708 
709 enum op_stat { WAIT = 0, SUCCEEDED, FAILED };
710 
711 } // namespace internal
712 
713 #endif /* __TBB__flow_graph_types_impl_H */
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
#define __TBB_override
Definition: tbb_stddef.h:244
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
virtual void CopyTo(void *) const
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
T punned_cast(U *ptr)
Cast between unrelated pointer types.
Definition: tbb_stddef.h:318
tbb::flow::tuple_element< N-1, Tuple >::type T_i
tbb::flow::tuple< T0, T1, T2, T3, T4 > Tuple
const_iterator begin() const __TBB_NOEXCEPT(true)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
#define __TBB_NOEXCEPT(expression)
Definition: tbb_stddef.h:114
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
static const size_t t2_align
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
type_plus_align< T1, T2, remainder > type
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
type_plus_align< T1, T2, 0 > just_pair
Detects whether two given types are the same.
tagged_msg(T const &index, R const &value)
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 >, PT< KeyTrait3 > > type
static const size_t remainder
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
pick_tuple_max< N, Tuple, alignment_of >::type AlignType
void const char const char int ITT_FORMAT __itt_group_sync p
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 >, PT< KeyTrait3 >, PT< KeyTrait4 > > type
initializer_list_wrapper(const initializer_list_wrapper< T > &ilw) __TBB_NOEXCEPT(true)
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
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
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type > > type
pick_one<(Selector< T1 >::value > Selector< T2 >::value), T1, T2 >::type type
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type >, PT< typename tbb::flow::tuple_element< 1, TypeTuple >::type > > type
const ArrayType & value() const
static const size_t t1_align
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
internal::type_to_key_function_body< T, K > TtoK
bool is_a(T const &t)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
Wrapper(const Wrapper &other)
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
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
Wrapper(const Wrapper &other)
tbb::flow::tuple_element< 0, Tuple >::type T_i
initializer_list_wrapper(std::initializer_list< T > il) __TBB_NOEXCEPT(true)
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
pick_tuple_max< N, Tuple, size_of >::type MaxSizeType
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
size_t size() const __TBB_NOEXCEPT(true)
tbb::aligned_space< AlignType, MaxNElements > SpaceType
static const size_t extra_bytes
const value_type & value() const
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
void CopyTo(void *newSpace) const __TBB_override
tbb::flow::tuple_element< N-1, Tuple >::type ThisType
static void construct(void *, const T &x)
initializer_list_wrapper(initializer_list_wrapper< T > &&ilw) __TBB_NOEXCEPT(true)
const V & cast_to(T const &t)
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 > > type
pick_tuple_max< N-1, Tuple, Selector >::type LeftMaxType
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
static const size_t max_align
type mimicking std::pair but with trailing fill to ensure each element of an array
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
const_iterator end() const __TBB_NOEXCEPT(true)
tbb::flow::tuple_element< 0, Tuple >::type type
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 4, TypeTuple >::type > KeyTrait4
Wrapper(const ArrayType &other)
void operator=(const variant &rhs)
void set_tag(TagType const &index)
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
pick_max< Selector, LeftMaxType, ThisType >::type type
static void construct(void *mySpace, const T &x)
void CopyTo(void *newSpace) const __TBB_override

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.