Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
task.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 
18 
19 #if !defined(__TBB_show_deprecation_message_task_H) && defined(__TBB_show_deprecated_header_message)
20 #define __TBB_show_deprecation_message_task_H
21 #pragma message("TBB Warning: tbb/task.h is deprecated. For details, please see Deprecated Features appendix in the TBB reference manual.")
22 #endif
23 
24 #if defined(__TBB_show_deprecated_header_message)
25 #undef __TBB_show_deprecated_header_message
26 #endif
27 
28 #ifndef __TBB_task_H
29 #define __TBB_task_H
30 
31 #define __TBB_task_H_include_area
33 
34 #include "tbb_stddef.h"
35 #include "tbb_machine.h"
36 #include "tbb_profiling.h"
37 #include <climits>
38 
39 typedef struct ___itt_caller *__itt_caller;
40 
41 namespace tbb {
42 
43 class task;
44 class task_list;
45 class task_group_context;
46 
47 // MSVC does not allow taking the address of a member that was defined
48 // privately in task_base and made public in class task via a using declaration.
49 #if _MSC_VER || (__GNUC__==3 && __GNUC_MINOR__<3)
50 #define __TBB_TASK_BASE_ACCESS public
51 #else
52 #define __TBB_TASK_BASE_ACCESS private
53 #endif
54 
55 namespace internal { //< @cond INTERNAL
56 
59  task* self;
61  public:
62  explicit allocate_additional_child_of_proxy( task& parent_ ) : self(NULL), parent(parent_) {
64  }
65  task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
66  void __TBB_EXPORTED_METHOD free( task& ) const;
67  };
68 
69  struct cpu_ctl_env_space { int space[sizeof(internal::uint64_t)/sizeof(int)]; };
70 } //< namespace internal @endcond
71 
72 namespace interface5 {
73  namespace internal {
75 
82  friend class tbb::task;
83 
85  static void spawn( task& t );
86 
88  static void spawn( task_list& list );
89 
91 
95  }
96 
98 
102  static void __TBB_EXPORTED_FUNC destroy( task& victim );
103  };
104  } // internal
105 } // interface5
106 
108 namespace internal {
109 
111  public:
113  virtual void spawn( task& first, task*& next ) = 0;
114 
116  virtual void wait_for_all( task& parent, task* child ) = 0;
117 
119  virtual void spawn_root_and_wait( task& first, task*& next ) = 0;
120 
122  // Have to have it just to shut up overzealous compilation warnings
123  virtual ~scheduler() = 0;
124 
126  virtual void enqueue( task& t, void* reserved ) = 0;
127  };
128 
130 
131  typedef intptr_t reference_count;
132 
133 #if __TBB_PREVIEW_RESUMABLE_TASKS
134  static const reference_count abandon_flag = reference_count(1) << (sizeof(reference_count)*CHAR_BIT - 2);
136 #endif
137 
139  typedef unsigned short affinity_id;
140 
141 #if __TBB_TASK_ISOLATION
142  typedef intptr_t isolation_tag;
145 #endif /* __TBB_TASK_ISOLATION */
146 
147 #if __TBB_TASK_GROUP_CONTEXT
148  class generic_scheduler;
149 
153  };
154 
157  public:
159  task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
160  void __TBB_EXPORTED_METHOD free( task& ) const;
161  };
162 #endif /* __TBB_TASK_GROUP_CONTEXT */
163 
165  public:
166  static task& __TBB_EXPORTED_FUNC allocate( size_t size );
167  static void __TBB_EXPORTED_FUNC free( task& );
168  };
169 
171  public:
172  task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
173  void __TBB_EXPORTED_METHOD free( task& ) const;
174  };
175 
177  public:
178  task& __TBB_EXPORTED_METHOD allocate( size_t size ) const;
179  void __TBB_EXPORTED_METHOD free( task& ) const;
180  };
181 
182 #if __TBB_PREVIEW_CRITICAL_TASKS
183  // TODO: move to class methods when critical task API becomes public
184  void make_critical( task& t );
185  bool is_critical( task& t );
186 #endif
187 
189 
203  class task_prefix {
204  private:
205  friend class tbb::task;
207  friend class tbb::task_list;
208  friend class internal::scheduler;
213 #if __TBB_PREVIEW_CRITICAL_TASKS
214  friend void make_critical( task& );
215  friend bool is_critical( task& );
216 #endif
217 
218 #if __TBB_TASK_ISOLATION
221 #else
222  intptr_t reserved_space_for_task_isolation_tag;
223 #endif /* __TBB_TASK_ISOLATION */
224 
225 #if __TBB_TASK_GROUP_CONTEXT
226 
231 #endif /* __TBB_TASK_GROUP_CONTEXT */
232 
234 
240 
241 #if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
242  union {
243 #endif /* __TBB_TASK_PRIORITY */
244 
248 
249 #if __TBB_TASK_PRIORITY
250 
253 #endif
254 
255 #if __TBB_PREVIEW_RESUMABLE_TASKS
256  scheduler* abandoned_scheduler;
258 #endif
259 #if __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS
260  };
261 #endif /* __TBB_TASK_PRIORITY || __TBB_PREVIEW_RESUMABLE_TASKS */
262 
264 
268 
270 
275 
277 
279  int depth;
280 
282 
283  unsigned char state;
284 
286 
292  unsigned char extra_state;
293 
295 
298 
300  tbb::task& task() {return *reinterpret_cast<tbb::task*>(this+1);}
301  };
302 
303 } // namespace internal
305 
306 #if __TBB_TASK_GROUP_CONTEXT
307 
308 #if __TBB_TASK_PRIORITY
309 namespace internal {
310  static const int priority_stride_v4 = INT_MAX / 4;
311 #if __TBB_PREVIEW_CRITICAL_TASKS
312  // TODO: move into priority_t enum when critical tasks become public feature
313  static const int priority_critical = priority_stride_v4 * 3 + priority_stride_v4 / 3 * 2;
314 #endif
315 }
316 
321 };
322 
323 #endif /* __TBB_TASK_PRIORITY */
324 
325 #if TBB_USE_CAPTURED_EXCEPTION
326  class tbb_exception;
327 #else
328  namespace internal {
329  class tbb_exception_ptr;
330  }
331 #endif /* !TBB_USE_CAPTURED_EXCEPTION */
332 
333 class task_scheduler_init;
334 namespace interface7 { class task_arena; }
335 using interface7::task_arena;
336 
338 
359 private:
361  friend class task_scheduler_init;
362  friend class task_arena;
363 
364 #if TBB_USE_CAPTURED_EXCEPTION
366 #else
368 #endif
369 
372  version_mask = 0xFFFF,
374  };
375 
376 public:
377  enum kind_type {
380  };
381 
382  enum traits_type {
384 #if __TBB_FP_CONTEXT
385  fp_settings = 0x0002ul << traits_offset,
386 #endif
388 #if TBB_USE_CAPTURED_EXCEPTION
389  default_traits = 0
390 #else
392 #endif /* !TBB_USE_CAPTURED_EXCEPTION */
393  };
394 
395 private:
396  enum state {
398  // the following enumerations must be the last, new 2^x values must go above
400  };
401 
402  union {
404  // TODO: describe asynchronous use, and whether any memory semantics are needed
406  uintptr_t _my_kind_aligner;
407  };
408 
411 
413 
416 
419 
421 
425  - 2 * sizeof(uintptr_t)- sizeof(void*) - sizeof(internal::context_list_node_t)
426  - sizeof(__itt_caller)
427 #if __TBB_FP_CONTEXT
429 #endif
430  ];
431 
432 #if __TBB_FP_CONTEXT
433 
437 #endif
438 
441 
443 
447 
450 
453 
455  uintptr_t my_state;
456 
457 #if __TBB_TASK_PRIORITY
458  intptr_t my_priority;
460 #endif /* __TBB_TASK_PRIORITY */
461 
464 
466 
467  char _trailing_padding[internal::NFS_MaxLineSize - 2 * sizeof(uintptr_t) - 2 * sizeof(void*)
468 #if __TBB_TASK_PRIORITY
469  - sizeof(intptr_t)
470 #endif /* __TBB_TASK_PRIORITY */
471  - sizeof(internal::string_index)
472  ];
473 
474 public:
476 
504  task_group_context ( kind_type relation_with_parent = bound,
505  uintptr_t t = default_traits )
506  : my_kind(relation_with_parent)
507  , my_version_and_traits(3 | t)
508  , my_name(internal::CUSTOM_CTX)
509  {
510  init();
511  }
512 
513  // Custom constructor for instrumentation of tbb algorithm
515  : my_kind(bound)
517  , my_name(name)
518  {
519  init();
520  }
521 
522  // Do not introduce standalone unbind method since it will break state propagation assumptions
524 
526 
534 
536 
544 
547 
549 
556 
557 #if __TBB_FP_CONTEXT
558 
567 #endif
568 
569 #if __TBB_TASK_PRIORITY
572 
575 #endif /* __TBB_TASK_PRIORITY */
576 
578  uintptr_t traits() const { return my_version_and_traits & traits_mask; }
579 
580 protected:
582 
583  void __TBB_EXPORTED_METHOD init ();
584 
585 private:
586  friend class task;
588 
592  static const kind_type dying = kind_type(detached+1);
593 
595  template <typename T>
596  void propagate_task_group_state ( T task_group_context::*mptr_state, task_group_context& src, T new_state );
597 
599  void bind_to ( internal::generic_scheduler *local_sched );
600 
602  void register_with ( internal::generic_scheduler *local_sched );
603 
604 #if __TBB_FP_CONTEXT
605  // TODO: Consider adding #else stub in order to omit #if sections in other code
607  void copy_fp_settings( const task_group_context &src );
608 #endif /* __TBB_FP_CONTEXT */
609 }; // class task_group_context
610 
611 #endif /* __TBB_TASK_GROUP_CONTEXT */
612 
614 
616 
618  void __TBB_EXPORTED_METHOD internal_set_ref_count( int count );
619 
621  internal::reference_count __TBB_EXPORTED_METHOD internal_decrement_ref_count();
622 
623 protected:
625  task() {prefix().extra_state=1;}
626 
627 public:
629  virtual ~task() {}
630 
632  virtual task* execute() = 0;
633 
635  enum state_type {
647  recycle
648 #if __TBB_RECYCLE_TO_ENQUEUE
649  ,to_enqueue
651 #endif
652 #if __TBB_PREVIEW_RESUMABLE_TASKS
653  ,to_resume
655 #endif
656  };
657 
658  //------------------------------------------------------------------------
659  // Allocating tasks
660  //------------------------------------------------------------------------
661 
665  }
666 
667 #if __TBB_TASK_GROUP_CONTEXT
671  }
672 #endif /* __TBB_TASK_GROUP_CONTEXT */
673 
675 
677  return *reinterpret_cast<internal::allocate_continuation_proxy*>(this);
678  }
679 
682  return *reinterpret_cast<internal::allocate_child_proxy*>(this);
683  }
684 
686  using task_base::allocate_additional_child_of;
687 
688 #if __TBB_DEPRECATED_TASK_INTERFACE
689 
694  void __TBB_EXPORTED_METHOD destroy( task& t );
695 #else /* !__TBB_DEPRECATED_TASK_INTERFACE */
696  using task_base::destroy;
698 #endif /* !__TBB_DEPRECATED_TASK_INTERFACE */
699 
700  //------------------------------------------------------------------------
701  // Recycling of tasks
702  //------------------------------------------------------------------------
703 
705 
712  __TBB_ASSERT( prefix().state==executing, "execute not running?" );
713  prefix().state = allocated;
714  }
715 
717 
720  __TBB_ASSERT( prefix().state==executing, "execute not running?" );
721  prefix().state = recycle;
722  }
723 
725  void recycle_as_child_of( task& new_parent ) {
726  internal::task_prefix& p = prefix();
727  __TBB_ASSERT( prefix().state==executing||prefix().state==allocated, "execute not running, or already recycled" );
728  __TBB_ASSERT( prefix().ref_count==0, "no child tasks allowed when recycled as a child" );
729  __TBB_ASSERT( p.parent==NULL, "parent must be null" );
730  __TBB_ASSERT( new_parent.prefix().state<=recycle, "corrupt parent's state" );
731  __TBB_ASSERT( new_parent.prefix().state!=freed, "parent already freed" );
732  p.state = allocated;
733  p.parent = &new_parent;
734 #if __TBB_TASK_GROUP_CONTEXT
735  p.context = new_parent.prefix().context;
736 #endif /* __TBB_TASK_GROUP_CONTEXT */
737  }
738 
740 
742  __TBB_ASSERT( prefix().state==executing, "execute not running, or already recycled" );
743  __TBB_ASSERT( prefix().ref_count==0, "no child tasks allowed when recycled for reexecution" );
744  prefix().state = reexecute;
745  }
746 
747 #if __TBB_RECYCLE_TO_ENQUEUE
748 
750  void recycle_to_enqueue() {
751  __TBB_ASSERT( prefix().state==executing, "execute not running, or already recycled" );
752  prefix().state = to_enqueue;
753  }
754 #endif /* __TBB_RECYCLE_TO_ENQUEUE */
755 
756  //------------------------------------------------------------------------
757  // Spawning and blocking
758  //------------------------------------------------------------------------
759 
761  void set_ref_count( int count ) {
762 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
763  internal_set_ref_count(count);
764 #else
765  prefix().ref_count = count;
766 #endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */
767  }
768 
770 
772  __TBB_FetchAndIncrementWacquire( &prefix().ref_count );
773  }
774 
776 
777  int add_ref_count( int count ) {
778  internal::call_itt_notify( internal::releasing, &prefix().ref_count );
779  internal::reference_count k = count+__TBB_FetchAndAddW( &prefix().ref_count, count );
780  __TBB_ASSERT( k>=0, "task's reference count underflowed" );
781  if( k==0 )
782  internal::call_itt_notify( internal::acquired, &prefix().ref_count );
783  return int(k);
784  }
785 
787 
789 #if TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT
790  return int(internal_decrement_ref_count());
791 #else
792  return int(__TBB_FetchAndDecrementWrelease( &prefix().ref_count ))-1;
793 #endif /* TBB_USE_THREADING_TOOLS||TBB_USE_ASSERT */
794  }
795 
797  using task_base::spawn;
798 
800  void spawn_and_wait_for_all( task& child ) {
801  prefix().owner->wait_for_all( *this, &child );
802  }
803 
805  void __TBB_EXPORTED_METHOD spawn_and_wait_for_all( task_list& list );
806 
808  static void spawn_root_and_wait( task& root ) {
809  root.prefix().owner->spawn_root_and_wait( root, root.prefix().next );
810  }
811 
813 
815  static void spawn_root_and_wait( task_list& root_list );
816 
818 
819  void wait_for_all() {
820  prefix().owner->wait_for_all( *this, NULL );
821  }
822 
824 #if __TBB_TASK_PRIORITY
825 
835 #endif /* __TBB_TASK_PRIORITY */
836  static void enqueue( task& t ) {
837  t.prefix().owner->enqueue( t, NULL );
838  }
839 
840 #if __TBB_TASK_PRIORITY
841  static void enqueue( task& t, priority_t p ) {
843 #if __TBB_PREVIEW_CRITICAL_TASKS
845  || p == internal::priority_critical, "Invalid priority level value");
846 #else
847  __TBB_ASSERT(p == priority_low || p == priority_normal || p == priority_high, "Invalid priority level value");
848 #endif
849  t.prefix().owner->enqueue( t, (void*)p );
850  }
851 #endif /* __TBB_TASK_PRIORITY */
852 
855 #if __TBB_TASK_PRIORITY
856  inline static void enqueue( task& t, task_arena& arena, priority_t p = priority_t(0) );
857 #else
858  inline static void enqueue( task& t, task_arena& arena);
859 #endif
860 
862  static task& __TBB_EXPORTED_FUNC self();
863 
865  task* parent() const {return prefix().parent;}
866 
868  void set_parent(task* p) {
869 #if __TBB_TASK_GROUP_CONTEXT
870  __TBB_ASSERT(!p || prefix().context == p->prefix().context, "The tasks must be in the same context");
871 #endif
872  prefix().parent = p;
873  }
874 
875 #if __TBB_TASK_GROUP_CONTEXT
876 
878  task_group_context* context() {return prefix().context;}
879 
881  task_group_context* group () { return prefix().context; }
882 #endif /* __TBB_TASK_GROUP_CONTEXT */
883 
885  bool is_stolen_task() const {
886  return (prefix().extra_state & 0x80)!=0;
887  }
888 
890  bool is_enqueued_task() const {
891  // es_task_enqueued = 0x10
892  return (prefix().extra_state & 0x10)!=0;
893  }
894 
895 #if __TBB_PREVIEW_RESUMABLE_TASKS
896  typedef void* suspend_point;
898 
900  template <typename F>
901  static void suspend(F f);
902 
904  static void resume(suspend_point tag);
905 #endif
906 
907  //------------------------------------------------------------------------
908  // Debugging
909  //------------------------------------------------------------------------
910 
912  state_type state() const {return state_type(prefix().state);}
913 
915  int ref_count() const {
916 #if TBB_USE_ASSERT
917 #if __TBB_PREVIEW_RESUMABLE_TASKS
918  internal::reference_count ref_count_ = prefix().ref_count & ~internal::abandon_flag;
919 #else
920  internal::reference_count ref_count_ = prefix().ref_count;
921 #endif
922  __TBB_ASSERT( ref_count_==int(ref_count_), "integer overflow error");
923 #endif
924 #if __TBB_PREVIEW_RESUMABLE_TASKS
925  return int(prefix().ref_count & ~internal::abandon_flag);
926 #else
927  return int(prefix().ref_count);
928 #endif
929  }
930 
932  bool __TBB_EXPORTED_METHOD is_owned_by_current_thread() const;
933 
934  //------------------------------------------------------------------------
935  // Affinity
936  //------------------------------------------------------------------------
937 
939 
941 
943  void set_affinity( affinity_id id ) {prefix().affinity = id;}
944 
946  affinity_id affinity() const {return prefix().affinity;}
947 
949 
953  virtual void __TBB_EXPORTED_METHOD note_affinity( affinity_id id );
954 
955 #if __TBB_TASK_GROUP_CONTEXT
956 
967  void __TBB_EXPORTED_METHOD change_group ( task_group_context& ctx );
968 
970 
971  bool cancel_group_execution () { return prefix().context->cancel_group_execution(); }
972 
974  bool is_cancelled () const { return prefix().context->is_group_execution_cancelled(); }
975 #else
976  bool is_cancelled () const { return false; }
977 #endif /* __TBB_TASK_GROUP_CONTEXT */
978 
979 #if __TBB_TASK_PRIORITY
980  __TBB_DEPRECATED void set_group_priority ( priority_t p ) { prefix().context->set_priority(p); }
982 
984  __TBB_DEPRECATED priority_t group_priority () const { return prefix().context->priority(); }
985 
986 #endif /* __TBB_TASK_PRIORITY */
987 
988 private:
990  friend class task_list;
991  friend class internal::scheduler;
993 #if __TBB_TASK_GROUP_CONTEXT
995 #endif /* __TBB_TASK_GROUP_CONTEXT */
999 
1001 
1003  return reinterpret_cast<internal::task_prefix*>(const_cast<task*>(this))[-1];
1004  }
1005 #if __TBB_PREVIEW_CRITICAL_TASKS
1006  friend void internal::make_critical( task& );
1007  friend bool internal::is_critical( task& );
1008 #endif
1009 }; // class task
1010 
1011 #if __TBB_PREVIEW_CRITICAL_TASKS
1012 namespace internal {
1013 inline void make_critical( task& t ) { t.prefix().extra_state |= 0x8; }
1014 inline bool is_critical( task& t ) { return bool((t.prefix().extra_state & 0x8) != 0); }
1015 } // namespace internal
1016 #endif /* __TBB_PREVIEW_CRITICAL_TASKS */
1017 
1018 #if __TBB_PREVIEW_RESUMABLE_TASKS
1019 namespace internal {
1020  template <typename F>
1021  static void suspend_callback(void* user_callback, task::suspend_point tag) {
1022  // Copy user function to a new stack to avoid a race when the previous scheduler is resumed.
1023  F user_callback_copy = *static_cast<F*>(user_callback);
1024  user_callback_copy(tag);
1025  }
1026  void __TBB_EXPORTED_FUNC internal_suspend(void* suspend_callback, void* user_callback);
1027  void __TBB_EXPORTED_FUNC internal_resume(task::suspend_point);
1028  task::suspend_point __TBB_EXPORTED_FUNC internal_current_suspend_point();
1029 }
1030 
1031 template <typename F>
1032 inline void task::suspend(F f) {
1033  internal::internal_suspend((void*)internal::suspend_callback<F>, &f);
1034 }
1035 inline void task::resume(suspend_point tag) {
1036  internal::internal_resume(tag);
1037 }
1038 #endif
1039 
1041 
1044  return NULL;
1045  }
1046 };
1047 
1049 namespace internal {
1050  template<typename F>
1051  class function_task : public task {
1052 #if __TBB_ALLOW_MUTABLE_FUNCTORS
1053  // TODO: deprecated behavior, remove
1054  F my_func;
1055 #else
1056  const F my_func;
1057 #endif
1059  my_func();
1060  return NULL;
1061  }
1062  public:
1063  function_task( const F& f ) : my_func(f) {}
1064 #if __TBB_CPP11_RVALUE_REF_PRESENT
1065  function_task( F&& f ) : my_func( std::move(f) ) {}
1066 #endif
1067  };
1068 } // namespace internal
1070 
1072 
1075 private:
1078  friend class task;
1080 public:
1082  task_list() : first(NULL), next_ptr(&first) {}
1083 
1086 
1088  bool empty() const {return !first;}
1089 
1091  void push_back( task& task ) {
1092  task.prefix().next = NULL;
1093  *next_ptr = &task;
1094  next_ptr = &task.prefix().next;
1095  }
1096 #if __TBB_TODO
1097  // TODO: add this method and implement&document the local execution ordering. See more in generic_scheduler::local_spawn
1099  void push_front( task& task ) {
1100  if( empty() ) {
1101  push_back(task);
1102  } else {
1103  task.prefix().next = first;
1104  first = &task;
1105  }
1106  }
1107 #endif
1108  task& pop_front() {
1110  __TBB_ASSERT( !empty(), "attempt to pop item from empty task_list" );
1111  task* result = first;
1112  first = result->prefix().next;
1113  if( !first ) next_ptr = &first;
1114  return *result;
1115  }
1116 
1118  void clear() {
1119  first=NULL;
1120  next_ptr=&first;
1121  }
1122 };
1123 
1125  t.prefix().owner->spawn( t, t.prefix().next );
1126 }
1127 
1129  if( task* t = list.first ) {
1130  t->prefix().owner->spawn( *t, *list.next_ptr );
1131  list.clear();
1132  }
1133 }
1134 
1135 inline void task::spawn_root_and_wait( task_list& root_list ) {
1136  if( task* t = root_list.first ) {
1137  t->prefix().owner->spawn_root_and_wait( *t, *root_list.next_ptr );
1138  root_list.clear();
1139  }
1140 }
1141 
1142 } // namespace tbb
1143 
1144 inline void *operator new( size_t bytes, const tbb::internal::allocate_root_proxy& ) {
1146 }
1147 
1148 inline void operator delete( void* task, const tbb::internal::allocate_root_proxy& ) {
1150 }
1151 
1152 #if __TBB_TASK_GROUP_CONTEXT
1153 inline void *operator new( size_t bytes, const tbb::internal::allocate_root_with_context_proxy& p ) {
1154  return &p.allocate(bytes);
1155 }
1156 
1157 inline void operator delete( void* task, const tbb::internal::allocate_root_with_context_proxy& p ) {
1158  p.free( *static_cast<tbb::task*>(task) );
1159 }
1160 #endif /* __TBB_TASK_GROUP_CONTEXT */
1161 
1162 inline void *operator new( size_t bytes, const tbb::internal::allocate_continuation_proxy& p ) {
1163  return &p.allocate(bytes);
1164 }
1165 
1166 inline void operator delete( void* task, const tbb::internal::allocate_continuation_proxy& p ) {
1167  p.free( *static_cast<tbb::task*>(task) );
1168 }
1169 
1170 inline void *operator new( size_t bytes, const tbb::internal::allocate_child_proxy& p ) {
1171  return &p.allocate(bytes);
1172 }
1173 
1174 inline void operator delete( void* task, const tbb::internal::allocate_child_proxy& p ) {
1175  p.free( *static_cast<tbb::task*>(task) );
1176 }
1177 
1178 inline void *operator new( size_t bytes, const tbb::internal::allocate_additional_child_of_proxy& p ) {
1179  return &p.allocate(bytes);
1180 }
1181 
1182 inline void operator delete( void* task, const tbb::internal::allocate_additional_child_of_proxy& p ) {
1183  p.free( *static_cast<tbb::task*>(task) );
1184 }
1185 
1187 #undef __TBB_task_H_include_area
1188 
1189 #endif /* __TBB_task_H */
tbb::task_list
A list of children.
Definition: task.h:1074
tbb::task::state_type
state_type
Enumeration of task states that the scheduler considers.
Definition: task.h:635
tbb::task::parent
task * parent() const
task on whose behalf this task is working, or NULL if this is a root.
Definition: task.h:865
__TBB_DEPRECATED
#define __TBB_DEPRECATED
Definition: tbb_config.h:636
tbb::task::~task
virtual ~task()
Destructor.
Definition: task.h:629
tbb::task_group_context::my_priority
intptr_t my_priority
Priority level of the task group (in normalized representation)
Definition: task.h:459
tbb::internal::task_prefix::next
tbb::task * next
"next" field for list of task
Definition: task.h:297
_deprecated_header_message_guard.h
tbb::task::add_ref_count
int add_ref_count(int count)
Atomically adds to reference count and returns its new value.
Definition: task.h:777
tbb::task::recycle_as_continuation
void recycle_as_continuation()
Change this to be a continuation of its former self.
Definition: task.h:711
internal
Definition: _flow_graph_async_msg_impl.h:24
tbb::task_group_context::itt_caller
__itt_caller itt_caller
Used to set and maintain stack stitching point for Intel Performance Tools.
Definition: task.h:418
tbb::task_group_context::my_exception
exception_container_type * my_exception
Pointer to the container storing exception being propagated across this task group.
Definition: task.h:449
tbb::internal::task_prefix::context
task_group_context * context
Shared context that is used to communicate asynchronous state changes.
Definition: task.h:230
tbb::task::enqueue
static void enqueue(task &t)
Enqueue task for starvation-resistant execution.
Definition: task.h:836
tbb::internal::task_prefix::isolation
isolation_tag isolation
The tag used for task isolation.
Definition: task.h:220
tbb::task::spawn_and_wait_for_all
void spawn_and_wait_for_all(task &child)
Similar to spawn followed by wait_for_all, but more efficient.
Definition: task.h:800
tbb::task_group_context::~task_group_context
__TBB_EXPORTED_METHOD ~task_group_context()
tbb::task::affinity_id
internal::affinity_id affinity_id
An id as used for specifying affinity.
Definition: task.h:940
tbb::task_group_context::my_owner
internal::generic_scheduler * my_owner
Scheduler instance that registered this context in its thread specific list.
Definition: task.h:452
tbb::task::cancel_group_execution
bool cancel_group_execution()
Initiates cancellation of all tasks in this cancellation group and its subordinate groups.
Definition: task.h:971
tbb::task_group_context::_trailing_padding
char _trailing_padding[internal::NFS_MaxLineSize - 2 *sizeof(uintptr_t) - 2 *sizeof(void *) - sizeof(intptr_t) - sizeof(internal::string_index)]
Trailing padding protecting accesses to frequently used members from false sharing.
Definition: task.h:472
tbb::task_group_context::task_group_context
task_group_context(kind_type relation_with_parent=bound, uintptr_t t=default_traits)
Default & binding constructor.
Definition: task.h:504
tbb::task_group_context
Used to form groups of tasks.
Definition: task.h:358
tbb::internal::task_prefix::task
tbb::task & task()
The task corresponding to this task_prefix.
Definition: task.h:300
tbb::internal::allocate_root_with_context_proxy::my_context
task_group_context & my_context
Definition: task.h:156
tbb::task_group_context::fp_settings
@ fp_settings
Definition: task.h:385
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
tbb::task::executing
@ executing
task is running, and will be destroyed after method execute() completes.
Definition: task.h:637
id
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 id
Definition: ittnotify_static.h:172
tbb::internal::task_prefix::extra_state
unsigned char extra_state
Miscellaneous state that is not directly visible to users, stored as a byte for compactness.
Definition: task.h:292
tbb::task_group_context::traits
uintptr_t traits() const
Returns the context's trait.
Definition: task.h:578
tbb::task::ref_count
int ref_count() const
The internal reference count.
Definition: task.h:915
tbb::internal::scheduler::spawn
virtual void spawn(task &first, task *&next)=0
For internal use only.
tbb::internal::no_assign
Base class for types that should not be assigned.
Definition: tbb_stddef.h:322
count
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 count
Definition: ittnotify_static.h:145
tbb::internal::allocate_continuation_proxy
Definition: task.h:170
tbb::task_group_context::concurrent_wait
@ concurrent_wait
Definition: task.h:387
tbb::task_group_context::propagate_task_group_state
void propagate_task_group_state(T task_group_context::*mptr_state, task_group_context &src, T new_state)
Propagates any state change detected to *this, and as an optimisation possibly also upward along the ...
tbb::task_list::next_ptr
task ** next_ptr
Definition: task.h:1077
tbb::internal::function_task
Definition: task.h:1051
tbb::task::is_enqueued_task
bool is_enqueued_task() const
True if the task was enqueued.
Definition: task.h:890
tbb::task_group_context::reset
void __TBB_EXPORTED_METHOD reset()
Forcefully reinitializes the context after the task tree it was associated with is completed.
tbb::task_group_context::version_traits_word_layout
version_traits_word_layout
Definition: task.h:370
tbb::internal::scheduler::spawn_root_and_wait
virtual void spawn_root_and_wait(task &first, task *&next)=0
For internal use only.
tbb::internal::context_list_node_t
Definition: task.h:150
tbb::internal::priority_critical
static const int priority_critical
Definition: task.h:313
tbb::task::increment_ref_count
void increment_ref_count()
Atomically increment reference count.
Definition: task.h:771
tbb::internal::scheduler::enqueue
virtual void enqueue(task &t, void *reserved)=0
For internal use only.
tbb::task_group_context::priority
__TBB_DEPRECATED_IN_VERBOSE_MODE priority_t priority() const
Retrieves current priority of the current task group.
tbb::internal::function_task::function_task
function_task(F &&f)
Definition: task.h:1065
tbb
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::internal::first
Container::iterator first(Container &c)
Definition: _range_iterator.h:46
tbb::interface5::internal::task_base::spawn
static void spawn(task &t)
Schedule task for execution when a worker becomes available.
Definition: task.h:1124
tbb::task::decrement_ref_count
int decrement_ref_count()
Atomically decrement reference count and returns its new value.
Definition: task.h:788
tbb::task
Base class for user-defined tasks.
Definition: task.h:615
tbb::task_group_context::binding_completed
static const kind_type binding_completed
Definition: task.h:590
tbb::priority_normal
@ priority_normal
Definition: task.h:318
tbb::empty_task::execute
task * execute() __TBB_override
Should be overridden by derived classes.
Definition: task.h:1043
tbb::interface5::internal::task_base::destroy
static void __TBB_EXPORTED_FUNC destroy(task &victim)
Destroy a task.
Definition: task.cpp:212
tbb::interface5::internal::task_base
Base class for methods that became static in TBB 3.0.
Definition: task.h:80
tbb::task_list::first
task * first
Definition: task.h:1076
tbb::task::allocate_root
static internal::allocate_root_proxy allocate_root()
Returns proxy for overloaded new that allocates a root task.
Definition: task.h:663
tbb::internal::generic_scheduler
Work stealing task scheduler.
Definition: scheduler.h:137
tbb::task_group_context::traits_offset
@ traits_offset
Definition: task.h:371
tbb::internal::allocate_child_proxy::allocate
task &__TBB_EXPORTED_METHOD allocate(size_t size) const
Definition: task.cpp:114
tbb::internal::task_prefix::owner
scheduler * owner
Obsolete. The scheduler that owns the task.
Definition: task.h:247
tbb::task::group_priority
__TBB_DEPRECATED priority_t group_priority() const
Retrieves current priority of the task group this task belongs to.
Definition: task.h:984
tbb::task_group_context::is_group_execution_cancelled
bool __TBB_EXPORTED_METHOD is_group_execution_cancelled() const
Returns true if the context received cancellation request.
tbb::internal::tbb_exception_ptr
Exception container that preserves the exact copy of the original exception.
Definition: tbb_exception.h:325
tbb::task_group_context::my_kind
__TBB_atomic kind_type my_kind
Flavor of this context: bound or isolated.
Definition: task.h:405
tbb::task_group_context::detached
static const kind_type detached
Definition: task.h:591
tbb::internal::scheduler::wait_for_all
virtual void wait_for_all(task &parent, task *child)=0
For internal use only.
tbb::internal::task_prefix::depth
int depth
Obsolete. Used to be scheduling depth before TBB 2.2.
Definition: task.h:279
size
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 size
Definition: ittnotify_static.h:109
tbb::task_group_context::state
state
Definition: task.h:396
tbb::task::affinity
affinity_id affinity() const
Current affinity of this task.
Definition: task.h:946
__TBB_TASK_BASE_ACCESS
#define __TBB_TASK_BASE_ACCESS
Definition: task.h:52
tbb::task::allocate_continuation
internal::allocate_continuation_proxy & allocate_continuation()
Returns proxy for overloaded new that allocates a continuation task of *this.
Definition: task.h:676
tbb::interface7::task_arena
Definition: task_arena.h:228
tbb::task_group_context::cancel_group_execution
bool __TBB_EXPORTED_METHOD cancel_group_execution()
Initiates cancellation of all tasks in this cancellation group and its subordinate groups.
tbb::interface5::internal::task_base::allocate_additional_child_of
static tbb::internal::allocate_additional_child_of_proxy allocate_additional_child_of(task &t)
Like allocate_child, except that task's parent becomes "t", not this.
Definition: task.h:93
tbb::task::prefix
internal::task_prefix & prefix(internal::version_tag *=NULL) const
Get reference to corresponding task_prefix.
Definition: task.h:1002
tbb_profiling.h
tbb::internal::priority_stride_v4
static const int priority_stride_v4
Definition: task.h:310
tbb::task_group_context::bound
@ bound
Definition: task.h:379
tbb::task::set_ref_count
void set_ref_count(int count)
Set reference count.
Definition: task.h:761
tbb::task::set_parent
void set_parent(task *p)
sets parent task pointer to specified value
Definition: task.h:868
tbb::task::allocate_child
internal::allocate_child_proxy & allocate_child()
Returns proxy for overloaded new that allocates a child task of *this.
Definition: task.h:681
tbb::internal::task_prefix::state
unsigned char state
A task::state_type, stored as a byte for compactness.
Definition: task.h:283
__TBB_atomic
#define __TBB_atomic
Definition: tbb_stddef.h:237
tbb::internal::allocate_root_with_context_proxy::free
void __TBB_EXPORTED_METHOD free(task &) const
tbb::task_group_context::version_mask
@ version_mask
Definition: task.h:372
tbb::internal::allocate_root_proxy
Definition: task.h:164
tbb::task::recycle_as_safe_continuation
void recycle_as_safe_continuation()
Recommended to use, safe variant of recycle_as_continuation.
Definition: task.h:719
tbb::task_list::task_list
task_list()
Construct empty list.
Definition: task.h:1082
tbb::priority_t
priority_t
Definition: task.h:317
tbb::internal::acquired
@ acquired
Definition: tbb_profiling.h:129
tbb::internal::is_critical
bool is_critical(task &t)
Definition: task.h:1014
tbb::task_group_context::register_pending_exception
void __TBB_EXPORTED_METHOD register_pending_exception()
Records the pending exception, and cancels the task group.
tbb::task::wait_for_all
void wait_for_all()
Wait for reference count to become one, and set reference count to zero.
Definition: task.h:819
tbb::internal::allocate_root_proxy::free
static void __TBB_EXPORTED_FUNC free(task &)
Definition: task.cpp:47
__TBB_FetchAndDecrementWrelease
#define __TBB_FetchAndDecrementWrelease(P)
Definition: tbb_machine.h:311
tbb::task_group_context::exception_container_type
internal::tbb_exception_ptr exception_container_type
Definition: task.h:367
tbb::internal::affinity_id
unsigned short affinity_id
An id as used for specifying affinity.
Definition: task.h:139
int
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 d int
Definition: ittnotify_static.h:217
tbb::task_group_context::my_state
uintptr_t my_state
Internal state (combination of state flags, currently only may_have_children).
Definition: task.h:455
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
tbb::task_group_context::bind_to
void bind_to(internal::generic_scheduler *local_sched)
Registers this context with the local scheduler and binds it to its parent context.
tbb::internal::function_task::function_task
function_task(const F &f)
Definition: task.h:1063
tbb::internal::cpu_ctl_env_space
Definition: task.h:69
tbb::task_group_context::_leading_padding
char _leading_padding[internal::NFS_MaxLineSize - 2 *sizeof(uintptr_t) - sizeof(void *) - sizeof(internal::context_list_node_t) - sizeof(__itt_caller) - sizeof(internal::cpu_ctl_env_space)]
Leading padding protecting accesses to frequently used members from false sharing.
Definition: task.h:430
tbb::task::freed
@ freed
task object is on free list, or is going to be put there, or was just taken off.
Definition: task.h:645
tbb::internal::allocate_child_proxy
Definition: task.h:176
tbb::internal::context_list_node_t::my_prev
context_list_node_t * my_prev
Definition: task.h:151
tbb::internal::no_isolation
const isolation_tag no_isolation
Definition: task.h:144
tbb::task_group_context::my_cancellation_requested
uintptr_t my_cancellation_requested
Specifies whether cancellation was requested for this task group.
Definition: task.h:440
tbb::task_scheduler_init
Class delimiting the scope of task scheduler activity.
Definition: task_scheduler_init.h:66
tbb::internal::allocate_root_with_context_proxy
Definition: task.h:155
tbb::internal::task_prefix::ref_count
__TBB_atomic reference_count ref_count
Reference count used for synchronization.
Definition: task.h:274
tbb::task_group_context::my_parent
task_group_context * my_parent
Pointer to the context of the parent cancellation group. NULL for isolated contexts.
Definition: task.h:410
tbb::task_group_context::capture_fp_settings
void __TBB_EXPORTED_METHOD capture_fp_settings()
Captures the current FPU control settings to the context.
tbb::task_group_context::low_unused_state_bit
@ low_unused_state_bit
Definition: task.h:399
tbb::task_list::clear
void clear()
Clear the list.
Definition: task.h:1118
tbb::task_group_context::register_with
void register_with(internal::generic_scheduler *local_sched)
Registers this context with the local scheduler.
tbb::internal::allocate_continuation_proxy::allocate
task &__TBB_EXPORTED_METHOD allocate(size_t size) const
Definition: task.cpp:96
tbb::task::recycle_to_reexecute
void recycle_to_reexecute()
Schedule this for reexecution after current execute() returns.
Definition: task.h:741
tbb::task_list::empty
bool empty() const
True if list is empty; false otherwise.
Definition: task.h:1088
tbb::internal::NFS_MaxLineSize
const size_t NFS_MaxLineSize
Compile-time constant that is upper bound on cache line/sector size.
Definition: tbb_stddef.h:216
tbb::internal::task_prefix::origin
scheduler * origin
The scheduler that allocated the task, or NULL if the task is big.
Definition: task.h:239
tbb::internal::context_list_node_t::my_next
context_list_node_t * my_next
Definition: task.h:152
tbb::task_group_context::set_priority
__TBB_DEPRECATED_IN_VERBOSE_MODE void set_priority(priority_t)
Changes priority of the task group.
tbb::task_group_context::isolated
@ isolated
Definition: task.h:378
tbb::task_group_context::default_traits
@ default_traits
Definition: task.h:391
tbb::task_group_context::my_cpu_ctl_env
internal::cpu_ctl_env_space my_cpu_ctl_env
Space for platform-specific FPU settings.
Definition: task.h:436
parent
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 parent
Definition: ittnotify_static.h:176
tbb::priority_low
@ priority_low
Definition: task.h:319
tbb::internal::scheduler
Definition: task.h:110
tbb::internal::no_copy
Base class for types that should not be copied or assigned.
Definition: tbb_stddef.h:330
tbb::internal::allocate_additional_child_of_proxy::parent
task & parent
Definition: task.h:60
tbb::task::reexecute
@ reexecute
task to be rescheduled.
Definition: task.h:639
_warning_suppress_disable_notice.h
tbb::internal::isolation_tag
intptr_t isolation_tag
A tag for task isolation.
Definition: task.h:143
tbb::task_list::~task_list
~task_list()
Destroys the list, but does not destroy the task objects.
Definition: task.h:1085
__TBB_override
#define __TBB_override
Definition: tbb_stddef.h:240
tbb::internal::allocate_additional_child_of_proxy
Definition: task.h:57
tbb::internal::allocate_additional_child_of_proxy::allocate
task &__TBB_EXPORTED_METHOD allocate(size_t size) const
Definition: task.cpp:128
tbb::task::state
state_type state() const
Current execution state.
Definition: task.h:912
tbb::internal::string_index
string_index
Definition: tbb_profiling.h:28
__TBB_EXPORTED_FUNC
#define __TBB_EXPORTED_FUNC
Definition: scalable_allocator.h:38
tbb::task::context
task_group_context * context()
This method is deprecated and will be removed in the future.
Definition: task.h:878
tbb::task_group_context::exact_exception
@ exact_exception
Definition: task.h:383
tbb::task_group_context::traits_type
traits_type
Definition: task.h:382
tbb_machine.h
tbb::internal::function_task::my_func
const F my_func
Definition: task.h:1056
tbb::internal::suppress_unused_warning
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
Definition: tbb_stddef.h:398
tbb::internal::allocate_additional_child_of_proxy::free
void __TBB_EXPORTED_METHOD free(task &) const
Definition: task.cpp:134
task
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 * task
Definition: ittnotify_static.h:119
tbb::internal::allocate_root_proxy::allocate
static task &__TBB_EXPORTED_FUNC allocate(size_t size)
Definition: task.cpp:35
tbb::task::group
task_group_context * group()
Pointer to the task group descriptor.
Definition: task.h:881
tbb::empty_task
task that does nothing. Useful for synchronization.
Definition: task.h:1042
tbb::task_group_context::dying
static const kind_type dying
Definition: task.h:592
tbb::task::set_affinity
void set_affinity(affinity_id id)
Set affinity for this task.
Definition: task.h:943
tbb::task::is_stolen_task
bool is_stolen_task() const
True if task was stolen from the task pool of another thread.
Definition: task.h:885
tbb::internal::allocate_root_with_context_proxy::allocate_root_with_context_proxy
allocate_root_with_context_proxy(task_group_context &ctx)
Definition: task.h:158
tbb::task::spawn_root_and_wait
static void spawn_root_and_wait(task &root)
Spawn task allocated by allocate_root, wait for it to complete, and deallocate it.
Definition: task.h:808
tbb::internal::releasing
@ releasing
Definition: tbb_profiling.h:129
tbb::internal::allocate_child_proxy::free
void __TBB_EXPORTED_METHOD free(task &) const
Definition: task.cpp:121
tbb::task_group_context::next_state_value
@ next_state_value
Definition: task.h:399
tbb::task_group_context::task_group_context
task_group_context(internal::string_index name)
Definition: task.h:514
tbb::task::ready
@ ready
task is in ready pool, or is going to be put there, or was just taken off.
Definition: task.h:641
tbb::internal::reference_count
intptr_t reference_count
A reference count.
Definition: task.h:131
__itt_caller
struct ___itt_caller * __itt_caller
Definition: task.h:39
tbb::task_group_context::init
void __TBB_EXPORTED_METHOD init()
Out-of-line part of the constructor.
tbb::task_group_context::may_have_children
@ may_have_children
Definition: task.h:397
tbb::priority_high
@ priority_high
Definition: task.h:320
name
void const char const char int ITT_FORMAT __itt_group_sync x void const char * name
Definition: ittnotify_static.h:93
tbb::internal::task_prefix
Memory prefix to a task object.
Definition: task.h:203
tbb::task_group_context::kind_type
kind_type
Definition: task.h:377
__TBB_DEPRECATED_IN_VERBOSE_MODE
#define __TBB_DEPRECATED_IN_VERBOSE_MODE
Definition: tbb_config.h:647
tbb_stddef.h
tbb::task_group_context::my_node
internal::context_list_node_t my_node
Used to form the thread specific list of contexts without additional memory allocation.
Definition: task.h:415
tbb::task_group_context::my_version_and_traits
uintptr_t my_version_and_traits
Version for run-time checks and behavioral traits of the context.
Definition: task.h:446
_warning_suppress_enable_notice.h
tbb::task_group_context::copy_fp_settings
void copy_fp_settings(const task_group_context &src)
Copies FPU control setting from another context.
p
void const char const char int ITT_FORMAT __itt_group_sync p
Definition: ittnotify_static.h:91
__TBB_EXPORTED_METHOD
#define __TBB_EXPORTED_METHOD
Definition: tbb_stddef.h:98
tbb::internal::call_itt_notify
void call_itt_notify(notify_type, void *)
Definition: tbb_profiling.h:276
tbb::internal::allocate_root_with_context_proxy::allocate
task &__TBB_EXPORTED_METHOD allocate(size_t size) const
tbb::task_group_context::traits_mask
@ traits_mask
Definition: task.h:373
tbb::task::task
task()
Default constructor.
Definition: task.h:625
tbb::task_group_context::my_name
internal::string_index my_name
Description of algorithm for scheduler based instrumentation.
Definition: task.h:463
tbb::internal::make_critical
void make_critical(task &t)
Definition: task.h:1013
tbb::internal::task_prefix::parent
tbb::task * parent
The task whose reference count includes me.
Definition: task.h:267
tbb::task_group_context::binding_required
static const kind_type binding_required
Definition: task.h:589
tbb::internal::allocate_additional_child_of_proxy::self
task * self
No longer used, but retained for binary layout compatibility. Always NULL.
Definition: task.h:59
tbb::tbb_exception
Interface to be implemented by all exceptions TBB recognizes and propagates across the threads.
Definition: tbb_exception.h:137
tbb::internal::function_task::execute
task * execute() __TBB_override
Should be overridden by derived classes.
Definition: task.h:1058
tbb::internal::version_tag_v3
Definition: tbb_stddef.h:405
__TBB_FetchAndIncrementWacquire
#define __TBB_FetchAndIncrementWacquire(P)
Definition: tbb_machine.h:310
tbb::internal::cpu_ctl_env_space::space
int space[sizeof(internal::uint64_t)/sizeof(int)]
Definition: task.h:69
tbb::internal::task_prefix::next_offloaded
task * next_offloaded
Pointer to the next offloaded lower priority task.
Definition: task.h:252
tbb::task_group_context::_my_kind_aligner
uintptr_t _my_kind_aligner
Definition: task.h:406
tbb::internal::task_prefix::make_critical
friend void make_critical(task &)
Definition: task.h:1013
tbb::task::allocated
@ allocated
task object is freshly allocated or recycled.
Definition: task.h:643
tbb::internal::task_prefix::is_critical
friend bool is_critical(task &)
Definition: task.h:1014
tbb::task_list::push_back
void push_back(task &task)
Push task onto back of list.
Definition: task.h:1091
tbb::internal::allocate_additional_child_of_proxy::allocate_additional_child_of_proxy
allocate_additional_child_of_proxy(task &parent_)
Definition: task.h:62
tbb::task::recycle_as_child_of
void recycle_as_child_of(task &new_parent)
Change this to be a child of new_parent.
Definition: task.h:725
tbb::internal::scheduler::~scheduler
virtual ~scheduler()=0
Pure virtual destructor;.
Definition: scheduler.cpp:72
tbb::internal::allocate_continuation_proxy::free
void __TBB_EXPORTED_METHOD free(task &) const
Definition: task.cpp:105
tbb::internal::task_prefix::affinity
affinity_id affinity
Definition: task.h:294
tbb::task::is_cancelled
bool is_cancelled() const
Returns true if the context has received cancellation request.
Definition: task.h:974

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.