| /oneTBB/doc/main/tbb_userguide/ |
| H A D | Mapping_Nodes2Tasks.rst | 10 three calls to try_put spawn three tasks; each one applies the lambda
12 has unlimited concurrency, these tasks can execute concurrently if there
14 there are no tasks executing in the graph. As with other ``wait_for_all``
16 idly during this time, but instead can join in executing other tasks
34 limit of 1 and therefore does not spawn all tasks immediately. Instead,
35 it sequentially spawns tasks to execute its body, λ\ :sub:`m`, on the
36 messages in the order that they arrive. When all tasks are complete, the
44 Likewise, the body tasks execute the lambda expressions and then put
47 used to execute tasks from the oneTBB work pool while it is waiting.
51 execute all of the tasks that can be executed in parallel. If there are
[all …]
|
| H A D | work_isolation.rst | 11 group of tasks to complete might execute other available tasks. In
32 The blocked thread is allowed to take tasks belonging to the first
63 ways to *isolate* execution of a parallel construct, for its tasks to
64 not interfere with other simultaneously running tasks.
81 // from taking tasks of the outer parallel_for.
92 calling thread to process only tasks scheduled in the scope of the
97 inside an isolated region, a thread can only execute tasks spawned
98 within the region and their child tasks spawned by other threads. The
99 thread is prohibited from executing any outer level tasks or tasks
131 // from taking tasks related to the outer parallel loop.
|
| H A D | Task-Based_Programming.rst | 9 your program in terms of *logical tasks*, not threads, for several
42 one logical thread per physical thread, and mapping tasks to logical
47 The key advantage of tasks versus logical threads is that tasks are much
72 tasks, the scheduler usually does a good job of assigning tasks to
79 Design your programs to try to create many more tasks than there are
80 threads, and let the task scheduler choose the mapping from tasks to
84 Finally, the main advantage of using tasks instead of threads is that
89 have to deal with the relatively coarse grain of threads. With tasks,
90 you can concentrate on the logical dependences between tasks, and leave
|
| H A D | When_Task-Based_Programming_Is_Inappropriate.rst | 10 algorithms composed from non-blocking tasks. It still works if the tasks
13 is blocked, it is not working on any tasks. Blocking typically occurs
16 anyway, no matter how many threads it has. If you have blocking tasks,
18 designed so that you can safely mix your own threads with |full_name| tasks.
|
| H A D | How_Task_Scheduler_Works.rst | 14 The scheduler runs tasks in a way that tries to achieve several targets simultaneously:
23 - **Strike when the cache is hot**. The deepest tasks are the most recently created tasks and there…
24 …Also, if they can be completed, tasks that depend on it can continue executing, and though not the…
25 they are still warmer than the older tasks deeper in the dequeue.
30 tasks.
32 Each thread has its deque of tasks that are ready to run. When a
35 When a thread participates in the evaluation of tasks, it constantly executes
|
| H A D | Dependence_Graph.rst | 9 computations. At runtime, the library spawns and schedules tasks to
110 in the wait_for_all, its thread can participate in executing other tasks
129 task to execute the body of A. Likewise, the body tasks execute the
132 this case the calling thread may be used to execute tasks from the
137 execute all of the tasks that can be executed concurrently in parallel.
138 If there are fewer threads, then some tasks that are spawned will need
|
| H A D | Graph_Object.rst | 11 operations such as waiting for all tasks related to the graph to
16 The code below creates a graph object and then waits for all tasks
19 or edges, and therefore no tasks are spawned.
|
| H A D | Cancellation_Without_An_Exception.rst | 9 Calling ``cancel_group_execution()`` cancels all tasks in its ``task_group_context``, which is expl…
32 // Cancel related tasks.
|
| H A D | communicate_with_nodes.rst | 77 If you want to wait until all of the tasks spawned by these graphs are
81 call to g.wait_for_all() returns immediately because there are no tasks
82 yet active in g; the only tasks that have been spawned by then belong to
99 // all tasks are done
|
| H A D | Floating_Point_Settings.rst | 6 To propagate CPU-specific settings for floating-point computations to tasks executed by the task sc…
30 …o most parallel algorithms, including ``flow::graph``, to ensure that all tasks related to this al…
41 * Floating-point settings are applied to all tasks executed within a task arena, if they are captur…
|
| H A D | Nodes.rst | 125 other tasks have been spawned. You can also use any specific value, such
128 thread. So while a graph may spawn many tasks, only the number of
130 these tasks.
146 The library spawns three tasks, each one applying n's lambda expression
|
| H A D | Cancellation_and_Nested_Parallelism.rst | 49 b. Cancel tasks in C.
61 b. Cancel tasks in B and, by downwards propagation, in D.
73 b. Cancel tasks in A and, by downwards propagation, in E, F, and G.
|
| H A D | estimate_flow_graph_performance.rst | 43 ``multifunction_nodes`` execute within spawned tasks by default. This
47 granularity of tasks therefore also apply to node bodies as well. If
|
| H A D | Flow_Graph_resource_tips.rst | 8 your graph, or control the maximum number of tasks in the work pool.
|
| H A D | cancelling_nested_parallelism.rst | 12 to an exception, any tasks started by parallel algorithms or flow graphs
|
| H A D | avoid_dynamic_node_removal.rst | 23 premature deletion of memory that will be later touched by tasks in the
|
| H A D | attach_flow_graph_to_arena.rst | 7 |short_name| ``task_arena`` interface provides mechanisms to guide tasks
|
| /oneTBB/doc/GSG/ |
| H A D | intro.rst | 9 …mplify parallel programming by breaking computation into parallel running tasks. Within a single p…
13 Here you can see one of the possible executions of tasks by threads.
25 … without worrying about oversubscribing a system, which happens when more tasks are assigned to a …
|
| /oneTBB/doc/main/tbb_userguide/design_patterns/ |
| H A D | Agglomeration.rst | 147 #. **P**\ artitioning - break the program into the smallest tasks
152 between tasks. When using oneTBB, communication is usually cache
154 ones happen between tasks helps guide the agglomeration step.
157 #. **A**\ gglomeration – combine tasks into larger tasks. His book
161 #. **M**\ apping – map tasks onto processors. The oneTBB task
|
| H A D | Non-Preemptive_Priorities.rst | 23 chooses tasks using rules based on scalability concerns. The rules
24 are based on the order in which tasks were spawned or enqueued, and
25 are oblivious to the contents of tasks. However, sometimes it is best
51 Put the work in a shared work pile. Decouple tasks from specific
119 collection of work and fires off tasks through the ``oneapi::tbb::task_group::run`` interface
|
| H A D | Local_Serializer.rst | 15 as tasks. The order of operations can be important. For example,
20 okay. Hence the goal is to establish serial ordering of tasks
21 associated with a given object, but not constrain ordering of tasks
258 unfair. If the ``Serializer`` has a continual stream of tasks, the
259 thread operating on it will keep servicing those tasks to the
|
| /oneTBB/doc/main/intro/ |
| H A D | intro_os.rst | 12 library, you specify tasks, not threads, and let the library map tasks
|
| /oneTBB/doc/index/ |
| H A D | index_intro.rst | 4 It is a flexible performance library that let you break computation into parallel running tasks.
|
| /oneTBB/examples/parallel_for/tachyon/ |
| H A D | README.md | 18 …hreading Building Blocks (oneTBB) and `blocked_range` to parallelize over tasks that are groups of…
19 …rallel version that uses oneTBB and `blocked_range2d` to parallelize over tasks that are rectangul…
|
| /oneTBB/doc/main/tbb_userguide/Migration_Guide/ |
| H A D | Task_API.rst | 11 Spawning of individual tasks
13 For most use cases, the spawning of individual tasks can be replaced with the use of either
18 ``ChildTask2`` tasks that can execute in parallel with each other and waiting on the ``RootTask`` is
388 queue of tasks ready for execution via ``oneapi::tbb::task_group::run``, but bypassed to the execut…
|