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-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__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
26namespace 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#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT
57 template<int N, template<class> class PT, typename... Args>
58 struct wrap_tuple_elements<N, PT, tbb::flow::tuple<Args...> >{
59 typedef typename tbb::flow::tuple<PT<Args>... > type;
60 };
61
62 template<int N, template<class> class PT, typename KeyTraits, typename... Args>
63 struct wrap_key_tuple_elements<N, PT, KeyTraits, tbb::flow::tuple<Args...> > {
64 typedef typename KeyTraits::key_type K;
65 typedef typename KeyTraits::hash_compare_type KHash;
66 typedef typename tbb::flow::tuple<PT<KeyTrait<K, KHash, Args> >... > type;
67 };
68#else
69 template<template<class> class PT, typename TypeTuple>
70 struct wrap_tuple_elements<1, PT, TypeTuple> {
71 typedef typename tbb::flow::tuple<
74 };
75
76 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
77 struct wrap_key_tuple_elements<1, PT, KeyTraits, TypeTuple > {
78 typedef typename KeyTraits::key_type K;
79 typedef typename KeyTraits::hash_compare_type KHash;
81 typedef typename tbb::flow::tuple< PT<KeyTrait0> > type;
82 };
83
84 template<template<class> class PT, typename TypeTuple>
85 struct wrap_tuple_elements<2, PT, TypeTuple> {
86 typedef typename tbb::flow::tuple<
90 };
91
92 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
93 struct wrap_key_tuple_elements<2, PT, KeyTraits, TypeTuple> {
94 typedef typename KeyTraits::key_type K;
95 typedef typename KeyTraits::hash_compare_type KHash;
98 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1> > type;
99 };
100
101 template<template<class> class PT, typename TypeTuple>
102 struct wrap_tuple_elements<3, PT, TypeTuple> {
103 typedef typename tbb::flow::tuple<
108 };
109
110 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
111 struct wrap_key_tuple_elements<3, PT, KeyTraits, TypeTuple> {
112 typedef typename KeyTraits::key_type K;
113 typedef typename KeyTraits::hash_compare_type KHash;
117 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2> > type;
118 };
119
120 template<template<class> class PT, typename TypeTuple>
121 struct wrap_tuple_elements<4, PT, TypeTuple> {
122 typedef typename tbb::flow::tuple<
128 };
129
130 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
131 struct wrap_key_tuple_elements<4, PT, KeyTraits, TypeTuple> {
132 typedef typename KeyTraits::key_type K;
133 typedef typename KeyTraits::hash_compare_type KHash;
138 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
139 PT<KeyTrait3> > type;
140 };
141
142 template<template<class> class PT, typename TypeTuple>
143 struct wrap_tuple_elements<5, PT, TypeTuple> {
144 typedef typename tbb::flow::tuple<
151 };
152
153 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
154 struct wrap_key_tuple_elements<5, PT, KeyTraits, TypeTuple> {
155 typedef typename KeyTraits::key_type K;
156 typedef typename KeyTraits::hash_compare_type KHash;
162 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>,
163 PT<KeyTrait3>, PT<KeyTrait4> > type;
164 };
165
166#if __TBB_VARIADIC_MAX >= 6
167 template<template<class> class PT, typename TypeTuple>
168 struct wrap_tuple_elements<6, PT, TypeTuple> {
169 typedef typename tbb::flow::tuple<
176 type;
177 };
178
179 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
180 struct wrap_key_tuple_elements<6, PT, KeyTraits, TypeTuple> {
181 typedef typename KeyTraits::key_type K;
182 typedef typename KeyTraits::hash_compare_type KHash;
189 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
190 PT<KeyTrait4>, PT<KeyTrait5> > type;
191 };
192#endif
193
194#if __TBB_VARIADIC_MAX >= 7
195 template<template<class> class PT, typename TypeTuple>
196 struct wrap_tuple_elements<7, PT, TypeTuple> {
197 typedef typename tbb::flow::tuple<
205 type;
206 };
207
208 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
209 struct wrap_key_tuple_elements<7, PT, KeyTraits, TypeTuple> {
210 typedef typename KeyTraits::key_type K;
211 typedef typename KeyTraits::hash_compare_type KHash;
219 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
220 PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6> > type;
221 };
222#endif
223
224#if __TBB_VARIADIC_MAX >= 8
225 template<template<class> class PT, typename TypeTuple>
226 struct wrap_tuple_elements<8, PT, TypeTuple> {
227 typedef typename tbb::flow::tuple<
236 type;
237 };
238
239 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
240 struct wrap_key_tuple_elements<8, PT, KeyTraits, TypeTuple> {
241 typedef typename KeyTraits::key_type K;
242 typedef typename KeyTraits::hash_compare_type KHash;
251 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
252 PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7> > type;
253 };
254#endif
255
256#if __TBB_VARIADIC_MAX >= 9
257 template<template<class> class PT, typename TypeTuple>
258 struct wrap_tuple_elements<9, PT, TypeTuple> {
259 typedef typename tbb::flow::tuple<
269 type;
270 };
271
272 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
273 struct wrap_key_tuple_elements<9, PT, KeyTraits, TypeTuple> {
274 typedef typename KeyTraits::key_type K;
275 typedef typename KeyTraits::hash_compare_type KHash;
285 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
286 PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8> > type;
287 };
288#endif
289
290#if __TBB_VARIADIC_MAX >= 10
291 template<template<class> class PT, typename TypeTuple>
292 struct wrap_tuple_elements<10, PT, TypeTuple> {
293 typedef typename tbb::flow::tuple<
304 type;
305 };
306
307 template<template<class> class PT, typename KeyTraits, typename TypeTuple>
308 struct wrap_key_tuple_elements<10, PT, KeyTraits, TypeTuple> {
309 typedef typename KeyTraits::key_type K;
310 typedef typename KeyTraits::hash_compare_type KHash;
321 typedef typename tbb::flow::tuple< PT<KeyTrait0>, PT<KeyTrait1>, PT<KeyTrait2>, PT<KeyTrait3>,
322 PT<KeyTrait4>, PT<KeyTrait5>, PT<KeyTrait6>, PT<KeyTrait7>, PT<KeyTrait8>,
323 PT<KeyTrait9> > type;
324 };
325#endif
326#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_VARIADIC_TUPLE_PRESENT */
327
328#if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
329 template< int... S > class sequence {};
330
331 template< int N, int... S >
332 struct make_sequence : make_sequence < N - 1, N - 1, S... > {};
333
334 template< int... S >
335 struct make_sequence < 0, S... > {
336 typedef sequence<S...> type;
337 };
338#endif /* __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT */
339
340#if __TBB_INITIALIZER_LISTS_PRESENT
341 // Until C++14 std::initializer_list does not guarantee life time of contained objects.
342 template <typename T>
344 public:
345 typedef T value_type;
346 typedef const T& reference;
347 typedef const T& const_reference;
348 typedef size_t size_type;
349
350 typedef T* iterator;
351 typedef const T* const_iterator;
352
353 initializer_list_wrapper( std::initializer_list<T> il ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( il.size()*sizeof( T ) )) ) {
354 iterator dst = my_begin;
355 for ( typename std::initializer_list<T>::const_iterator src = il.begin(); src != il.end(); ++src )
356 new (dst++) T( *src );
357 my_end = dst;
358 }
359
360 initializer_list_wrapper( const initializer_list_wrapper<T>& ilw ) __TBB_NOEXCEPT( true ) : my_begin( static_cast<T*>(malloc( ilw.size()*sizeof( T ) )) ) {
361 iterator dst = my_begin;
362 for ( typename std::initializer_list<T>::const_iterator src = ilw.begin(); src != ilw.end(); ++src )
363 new (dst++) T( *src );
364 my_end = dst;
365 }
366
367#if __TBB_CPP11_RVALUE_REF_PRESENT
369 ilw.my_begin = ilw.my_end = NULL;
370 }
371#endif /* __TBB_CPP11_RVALUE_REF_PRESENT */
372
374 if ( my_begin )
375 free( my_begin );
376 }
377
378 const_iterator begin() const __TBB_NOEXCEPT(true) { return my_begin; }
379 const_iterator end() const __TBB_NOEXCEPT(true) { return my_end; }
380 size_t size() const __TBB_NOEXCEPT(true) { return (size_t)(my_end - my_begin); }
381
382 private:
385 };
386#endif /* __TBB_INITIALIZER_LISTS_PRESENT */
387
389//* will have the correct alignment
390 template<typename T1, typename T2, size_t REM>
392 char first[sizeof(T1)];
394 char fill1[REM];
395 };
396
397 template<typename T1, typename T2>
398 struct type_plus_align<T1,T2,0> {
399 char first[sizeof(T1)];
401 };
402
403 template<class U> struct alignment_of {
404 typedef struct { char t; U padded; } test_alignment;
405 static const size_t value = sizeof(test_alignment) - sizeof(U);
406 };
407
408 // T1, T2 are actual types stored. The space defined for T1 in the type returned
409 // is a char array of the correct size. Type T2 should be trivially-constructible,
410 // T1 must be explicitly managed.
411 template<typename T1, typename T2>
413 static const size_t t1_align = alignment_of<T1>::value;
414 static const size_t t2_align = alignment_of<T2>::value;
416 static const size_t max_align = t1_align < t2_align ? t2_align : t1_align;
417 static const size_t extra_bytes = sizeof(just_pair) % max_align;
418 static const size_t remainder = extra_bytes ? max_align - extra_bytes : 0;
419 public:
421 }; // aligned_pair
422
423// support for variant type
424// type we use when we're not storing a value
426
427// type which contains another type, tests for what type is contained, and references to it.
428// internal::Wrapper<T>
429// void CopyTo( void *newSpace) : builds a Wrapper<T> copy of itself in newSpace
430
431// struct to allow us to copy and test the type of objects
433 virtual ~WrapperBase() {}
434 virtual void CopyTo(void* /*newSpace*/) const { }
435};
436
437// Wrapper<T> contains a T, with the ability to test what T is. The Wrapper<T> can be
438// constructed from a T, can be copy-constructed from another Wrapper<T>, and can be
439// examined via value(), but not modified.
440template<typename T>
441struct Wrapper: public WrapperBase {
442 typedef T value_type;
443 typedef T* pointer_type;
444private:
446public:
447 const value_type &value() const { return value_space; }
448
449private:
451
452 // on exception will ensure the Wrapper will contain only a trivially-constructed object
458 }
459 };
460public:
461 explicit Wrapper( const T& other ) : value_space(other) { }
462 explicit Wrapper(const Wrapper& other) : value_space(other.value_space) { }
463
464 void CopyTo(void* newSpace) const __TBB_override {
465 _unwind_space guard((pointer_type)newSpace);
466 (void) new(newSpace) Wrapper(value_space);
467 guard.space = NULL;
468 }
470};
471
472// specialization for array objects
473template<typename T, size_t N>
474struct Wrapper<T[N]> : public WrapperBase {
475 typedef T value_type;
476 typedef T* pointer_type;
477 // space must be untyped.
478 typedef T ArrayType[N];
479private:
480 // The space is not of type T[N] because when copy-constructing, it would be
481 // default-initialized and then copied to in some fashion, resulting in two
482 // constructions and one destruction per element. If the type is char[ ], we
483 // placement new into each element, resulting in one construction per element.
484 static const size_t space_size = sizeof(ArrayType) / sizeof(char);
485 char value_space[space_size];
486
487
488 // on exception will ensure the already-built objects will be destructed
489 // (the value_space is a char array, so it is already trivially-destructible.)
490 struct _unwind_class {
493 _unwind_class(pointer_type p) : space(p), already_built(0) {}
495 if(space) {
496 for(size_t i = already_built; i > 0 ; --i ) space[i-1].~value_type();
498 }
499 }
500 };
501public:
502 const ArrayType &value() const {
503 char *vp = const_cast<char *>(value_space);
504 return reinterpret_cast<ArrayType &>(*vp);
505 }
506
507private:
509public:
510 // have to explicitly construct because other decays to a const value_type*
511 explicit Wrapper(const ArrayType& other) {
512 _unwind_class guard((pointer_type)value_space);
513 pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
514 for(size_t i = 0; i < N; ++i ) {
515 (void) new(vp++) value_type(other[i]);
516 ++(guard.already_built);
517 }
518 guard.space = NULL;
519 }
520 explicit Wrapper(const Wrapper& other) : WrapperBase() {
521 // we have to do the heavy lifting to copy contents
522 _unwind_class guard((pointer_type)value_space);
523 pointer_type dp = reinterpret_cast<pointer_type>(value_space);
524 pointer_type sp = reinterpret_cast<pointer_type>(const_cast<char *>(other.value_space));
525 for(size_t i = 0; i < N; ++i, ++dp, ++sp) {
526 (void) new(dp) value_type(*sp);
527 ++(guard.already_built);
528 }
529 guard.space = NULL;
530 }
531
532 void CopyTo(void* newSpace) const __TBB_override {
533 (void) new(newSpace) Wrapper(*this); // exceptions handled in copy constructor
534 }
535
537 // have to destroy explicitly in reverse order
538 pointer_type vp = reinterpret_cast<pointer_type>(&value_space);
539 for(size_t i = N; i > 0 ; --i ) vp[i-1].~value_type();
540 }
541};
542
543// given a tuple, return the type of the element that has the maximum alignment requirement.
544// Given a tuple and that type, return the number of elements of the object with the max
545// alignment requirement that is at least as big as the largest object in the tuple.
546
547template<bool, class T1, class T2> struct pick_one;
548template<class T1, class T2> struct pick_one<true , T1, T2> { typedef T1 type; };
549template<class T1, class T2> struct pick_one<false, T1, T2> { typedef T2 type; };
550
551template< template<class> class Selector, typename T1, typename T2 >
552struct pick_max {
554};
555
556template<typename T> struct size_of { static const int value = sizeof(T); };
557
558template< size_t N, class Tuple, template<class> class Selector > struct pick_tuple_max {
559 typedef typename pick_tuple_max<N-1, Tuple, Selector>::type LeftMaxType;
560 typedef typename tbb::flow::tuple_element<N-1, Tuple>::type ThisType;
562};
563
564template< class Tuple, template<class> class Selector > struct pick_tuple_max<0, Tuple, Selector> {
566};
567
568// is the specified type included in a tuple?
569template<class Q, size_t N, class Tuple>
571 typedef typename tbb::flow::tuple_element<N-1, Tuple>::type T_i;
573};
574
575template<class Q, class Tuple>
576struct is_element_of<Q,0,Tuple> {
579};
580
581// allow the construction of types that are listed tuple. If a disallowed type
582// construction is written, a method involving this type is created. The
583// type has no definition, so a syntax error is generated.
585
586template<typename T, bool BUILD_IT> struct do_if;
587template<typename T>
588struct do_if<T, true> {
589 static void construct(void *mySpace, const T& x) {
590 (void) new(mySpace) Wrapper<T>(x);
591 }
592};
593template<typename T>
594struct do_if<T, false> {
595 static void construct(void * /*mySpace*/, const T& x) {
596 // This method is instantiated when the type T does not match any of the
597 // element types in the Tuple in variant<Tuple>.
599 }
600};
601
602// Tuple tells us the allowed types that variant can hold. It determines the alignment of the space in
603// Wrapper, and how big Wrapper is.
604//
605// the object can only be tested for type, and a read-only reference can be fetched by cast_to<T>().
606
609template<typename TagType, typename T0, typename T1=tagged_null_type, typename T2=tagged_null_type, typename T3=tagged_null_type,
610 typename T4=tagged_null_type, typename T5=tagged_null_type, typename T6=tagged_null_type,
611 typename T7=tagged_null_type, typename T8=tagged_null_type, typename T9=tagged_null_type>
613 typedef tbb::flow::tuple<T0, T1, T2, T3, T4
614 //TODO: Should we reject lists longer than a tuple can hold?
615 #if __TBB_VARIADIC_MAX >= 6
616 , T5
617 #endif
618 #if __TBB_VARIADIC_MAX >= 7
619 , T6
620 #endif
621 #if __TBB_VARIADIC_MAX >= 8
622 , T7
623 #endif
624 #if __TBB_VARIADIC_MAX >= 9
625 , T8
626 #endif
627 #if __TBB_VARIADIC_MAX >= 10
628 , T9
629 #endif
631
632private:
633 class variant {
637 static const size_t MaxNBytes = (sizeof(Wrapper<MaxSizeType>)+sizeof(AlignType)-1);
638 static const size_t MaxNElements = MaxNBytes/sizeof(AlignType);
639 typedef typename tbb::aligned_space<AlignType, MaxNElements> SpaceType;
641 static const size_t MaxSize = sizeof(SpaceType);
642
643 public:
645
646 template<typename T>
647 variant( const T& x ) {
649 }
650
651 variant(const variant& other) {
652 const WrapperBase * h = punned_cast<const WrapperBase *>(&(other.my_space));
653 h->CopyTo(&my_space);
654 }
655
656 // assignment must destroy and re-create the Wrapper type, as there is no way
657 // to create a Wrapper-to-Wrapper assign even if we find they agree in type.
658 void operator=( const variant& rhs ) {
659 if(&rhs != this) {
660 WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
661 h->~WrapperBase();
662 const WrapperBase *ch = punned_cast<const WrapperBase *>(&(rhs.my_space));
663 ch->CopyTo(&my_space);
664 }
665 }
666
667 template<typename U>
668 const U& variant_cast_to() const {
669 const Wrapper<U> *h = dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space));
670 if(!h) {
672 }
673 return h->value();
674 }
675 template<typename U>
676 bool variant_is_a() const { return dynamic_cast<const Wrapper<U>*>(punned_cast<const WrapperBase *>(&my_space)) != NULL; }
677
678 bool variant_is_default_constructed() const {return variant_is_a<default_constructed>();}
679
681 WrapperBase *h = punned_cast<WrapperBase *>(&my_space);
682 h->~WrapperBase();
683 }
684 }; //class variant
685
686 TagType my_tag;
688
689public:
690 tagged_msg(): my_tag(TagType(~0)), my_msg(){}
691
692 template<typename T, typename R>
693 tagged_msg(T const &index, R const &value) : my_tag(index), my_msg(value) {}
694
695 #if __TBB_CONST_REF_TO_ARRAY_TEMPLATE_PARAM_BROKEN
696 template<typename T, typename R, size_t N>
697 tagged_msg(T const &index, R (&value)[N]) : my_tag(index), my_msg(value) {}
698 #endif
699
700 void set_tag(TagType const &index) {my_tag = index;}
701 TagType tag() const {return my_tag;}
702
703 template<typename V>
704 const V& cast_to() const {return my_msg.template variant_cast_to<V>();}
705
706 template<typename V>
707 bool is_a() const {return my_msg.template variant_is_a<V>();}
708
710}; //class tagged_msg
711
712// template to simplify cast and test for tagged_msg in template contexts
713template<typename V, typename T>
714const V& cast_to(T const &t) { return t.template cast_to<V>(); }
715
716template<typename V, typename T>
717bool is_a(T const &t) { return t.template is_a<V>(); }
718
720
721} // namespace internal
722
723#endif /* __TBB__flow_graph_types_impl_H */
#define __TBB_NOEXCEPT(expression)
Definition: tbb_stddef.h:110
#define __TBB_override
Definition: tbb_stddef.h:240
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_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
void const char const char int ITT_FORMAT __itt_group_sync p
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
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_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type type
The graph class.
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
T punned_cast(U *ptr)
Cast between unrelated pointer types.
Definition: tbb_stddef.h:314
const V & cast_to(T const &t)
bool is_a(T const &t)
internal::type_to_key_function_body< T, K > TtoK
tbb::flow::tuple< PT< typename tbb::flow::tuple_element< 0, TypeTuple >::type > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
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< 1, TypeTuple >::type > KeyTrait1
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
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< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
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< 1, TypeTuple >::type > KeyTrait1
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
tbb::flow::tuple< PT< KeyTrait0 >, PT< KeyTrait1 >, PT< KeyTrait2 >, PT< KeyTrait3 > > type
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 0, TypeTuple >::type > KeyTrait0
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
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
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
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 3, TypeTuple >::type > KeyTrait3
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 2, TypeTuple >::type > KeyTrait2
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 4, TypeTuple >::type > KeyTrait4
KeyTrait< K, KHash, typename tbb::flow::tuple_element< 1, TypeTuple >::type > KeyTrait1
const_iterator begin() const __TBB_NOEXCEPT(true)
size_t size() const __TBB_NOEXCEPT(true)
const_iterator end() const __TBB_NOEXCEPT(true)
initializer_list_wrapper(const initializer_list_wrapper< T > &ilw) __TBB_NOEXCEPT(true)
initializer_list_wrapper(initializer_list_wrapper< T > &&ilw) __TBB_NOEXCEPT(true)
initializer_list_wrapper(std::initializer_list< T > il) __TBB_NOEXCEPT(true)
type mimicking std::pair but with trailing fill to ensure each element of an array
static const size_t t2_align
static const size_t t1_align
static const size_t remainder
static const size_t max_align
static const size_t extra_bytes
type_plus_align< T1, T2, remainder > type
type_plus_align< T1, T2, 0 > just_pair
virtual void CopyTo(void *) const
Wrapper(const Wrapper &other)
void CopyTo(void *newSpace) const __TBB_override
const value_type & value() const
Wrapper(const Wrapper &other)
Wrapper(const ArrayType &other)
void CopyTo(void *newSpace) const __TBB_override
const ArrayType & value() const
pick_one<(Selector< T1 >::value >Selector< T2 >::value), T1, T2 >::type type
pick_tuple_max< N-1, Tuple, Selector >::type LeftMaxType
pick_max< Selector, LeftMaxType, ThisType >::type type
tbb::flow::tuple_element< N-1, Tuple >::type ThisType
tbb::flow::tuple_element< 0, Tuple >::type type
tbb::flow::tuple_element< N-1, Tuple >::type T_i
tbb::flow::tuple_element< 0, Tuple >::type T_i
static void construct(void *mySpace, const T &x)
static void construct(void *, const T &x)
tbb::flow::tuple< T0, T1, T2, T3, T4 > Tuple
tagged_msg(T const &index, R const &value)
void set_tag(TagType const &index)
tbb::aligned_space< AlignType, MaxNElements > SpaceType
pick_tuple_max< N, Tuple, alignment_of >::type AlignType
void operator=(const variant &rhs)
pick_tuple_max< N, Tuple, size_of >::type MaxSizeType
Detects whether two given types are the same.

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.