| /oneTBB/doc/ |
| H A D | Doxyfile.in | 98 # documentation (similar to Javadoc). Set to NO to disable this.
524 # and Mac users are advised to set this option to NO.
551 # which file to include in order to use the member.
1068 # specified. Set to NO to disable this.
1366 # The TOC_EXPAND flag can be set to YES to add extra items for group members to
1511 # output directory to force them to be regenerated.
1738 # to HTML_HEADER.
2215 # set to NO
2382 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
2387 # Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
[all …]
|
| /oneTBB/doc/main/tbb_userguide/ |
| H A D | Flow_Graph_Reservation.rst | 28 edge to push state, and tries to reserve the next node connected by
33 messages and try to push the resulting message to any nodes connected
34 to it.
119 ``bn`` attempts to forward 2 to ``jn``. ``jn`` does not accept the value
148 ``buf1`` attempts to forward 3 to ``jn``. ``jn`` does not accept the
170 ``buf2`` attempts to forward 4 to ``jn``. ``jn`` does not accept the
206 Now the task spawned to run ``jn`` runs.
209 - ``jn`` tries to reserve ``bn``, which fails. The arc to ``bn``
233 ``jn`` attempts to reserve again.
237 to ``jn`` is in push state.
[all …]
|
| H A D | communicate_with_nodes.rst | 7 All graph nodes require a reference to a graph object as one of the
8 arguments to their constructor. It is only safe to construct edges
10 topology of your graph to the runtime library. Connecting two nodes in
11 different graphs can make it difficult to reason about whole graph
12 operations, such as calls to graph::wait_for_all and exception handling.
13 To optimize performance, the library may make calls to a node's
18 instead use explicit calls to try_put. This will prevent the runtime
20 nodes, and therefore make it easier to reason about events that cross
74 consider m2 to be a predecessor of n1 since no edge exists.
78 done, you need to call the function wait_for_all on both graphs.
[all …]
|
| H A D | Nodes.rst | 16 types are used to construct a graph.
41 - The graph the node belongs to.
43 … the concurrency limit to control how many invocations of the node are allowed to proceed con…
45 …ined function object, or lambda expression, that is applied to the incoming message to generate…
72 messages to it, either by connecting it to other nodes using edges or by
85 You can then wait for the messages to be processed by calling
97 3, the node n will spawn a task to apply the body to the first input, 1.
99 body to 2. And likewise, the node will wait for that task to complete
100 before spawning a third task to apply the body to 3. The calls to
104 task will be spawned to process the next buffered message.
[all …]
|
| H A D | Flow_Graph_Buffering_in_Nodes.rst | 8 to communicate data and to enforce dependencies. If a node passes a
9 message successfully to any successor, no further action is taken with
11 Broadcast-push, a message may be passed to one or to multiple
13 connected to the node, and whether the message is pushed or pulled.
16 There are times when a node cannot successfully push a message to any
17 successor. In this case what happens to the message depends on the type
21 - The node stores the message to be forwarded later.
26 not desired, the node should be connected to a buffering node that does
31 passed to another node:
34 - A successor to the node can pull the message using ``try_get()`` or
[all …]
|
| H A D | create_token_based_system.rst | 7 A more flexible solution to limit the number of messages in a flow graph
8 is to use tokens. In a token-based system, a limited number of tokens
9 are available in the graph and a message will not be allowed to enter
12 a new message that will then be allowed to enter.
32 - ``queueing``. This type of policy causes inputs to be matched
41 those together to form an output tuple.
114 buffered in the ``input_node``, awaiting a token to be paired with.
118 use any type for a token, including objects or pointers to arrays.
124 free list of big objects using a cycle back to the ``buffer_node``.
129 example, an ``input_node`` could be attached to the input of the
[all …]
|
| H A D | broadcast_or_send.rst | 3 Sending to One or Multiple Successors
8 their output to a single successor or broadcast to all successors. The
9 following predefined nodes push messages to a single successor:
18 Other nodes push messages to all successors that will accept them.
21 The nodes that push to only a single successor are all buffer nodes.
22 Their purpose is to hold messages temporarily, until they are consumed
68 is sent to either f1 or f2, but not both.
81 next or "100", which has a higher priority? In any case, trying to
90 But what if you really do want both f1 and f2 to receive all of the
93 each value to both queues through a broadcast_node, as shown below:
[all …]
|
| H A D | Floating_Point_Settings.rst | 6 To propagate CPU-specific settings for floating-point computations to tasks executed by the task sc…
9 * The ``task_group_context`` class has a method to capture the current floating-point settings.
30 …en pass the task group context to most parallel algorithms, including ``flow::graph``, to ensure t…
31 It is possible to execute the parallel algorithms with different floating-point settings captured t…
33 …to a task group context prevail over the settings captured during task scheduler initialization. I…
36 In a nested call to a parallel algorithm that does not use the context of a task group with explici…
41 * Floating-point settings are applied to all tasks executed within a task arena, if they are captur…
46 * A call to a oneTBB parallel algorithm does not change the floating-point settings of the calling …
49 The guarantees above apply only to the following conditions:
57 * oneTBB task scheduler observers are not used to set or modify floating point settings.
[all …]
|
| H A D | Mapping_Nodes2Tasks.rst | 3 Flow Graph Basics: Mapping Nodes to Tasks
9 m will be referred to as λ\ :sub:`n` and λ\ :sub:`m`, respectively. The
10 three calls to try_put spawn three tasks; each one applies the lambda
32 As each task from n finishes, it puts its output to m, since m is a
35 it sequentially spawns tasks to execute its body, λ\ :sub:`m`, on the
37 call to ``wait_for_all`` returns.
42 try_put return control to the calling thread quickly, after either
45 the result to any successor nodes. Only the call to ``wait_for_all``
50 The above timeline shows the sequence when there are enough threads to
52 fewer threads, some spawned tasks will need to wait until a thread is
[all …]
|
| H A D | Task-Based_Programming.rst | 8 poor way to do multithreaded programming. It is much better to formulate
13 - Matching parallelism to available resources
37 threads to keep the physical threads working. *Oversubscription* occurs
39 Oversubscription usually leads to *time sliced* execution of logical
42 one logical thread per physical thread, and mapping tasks to logical
69 The scheduler does *load balancing*. In addition to using the right
70 number of threads, it is important to distribute work evenly across
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
86 programming, you are forced to think at the low level of physical
[all …]
|
| H A D | destroy_graphs_outside_main_thread.rst | 6 Make sure to enqueue a task to wait for and destroy graphs that run outside the main thread.
8 You may not always want to block the main application thread by calling
9 wait_for_all(). However, it is safest to call wait_for_all on a graph
10 before destroying it. A common solution is to enqueue a task to build
11 and wait for the graph to complete. For example, assume you really do
12 not want to call a wait_for_all in the example from :ref:`always_use_wait_for_all`,
40 it's not clear when. If you need to use the results of the enqueued
42 need to use some mechanism to signal from the enqueued task that the
|
| H A D | Guiding_Task_Scheduler_Execution.rst | 6 By default, the task scheduler tries to use all available computing resources. In some cases,
7 you may want to configure the task scheduler to use only some of them.
13 |full_name| provides the ``task_arena`` interface to guide tasks execution within the arena by:
18 To set the limitation, you have to customize the ``task_arena::constraints`` and then pass
19 it to the ``task_arena`` instance during the construction or initialization.
21 The structure ``task_arena::constraints`` allows to specify the following restrictions:
33 The following examples show how to use these interfaces:
41 assign a NUMA node identifier to the ``task_arena::constraints::numa_id`` field.
81 .. rubric:: Limiting the maximum number of threads simultaneously scheduled to one core
88 The example shows how to allow only one thread to run on each core at a time:
[all …]
|
| H A D | Predefined_Node_Types.rst | 26 …When activated, it executes a user body to generate its output. Its body is invoked if downstream …
29 …- A single-input single-output node that broadcasts its output to all successors. Has generic inpu…
31 …to all successors. It has a single input that requires 1 or more inputs of type continue_msg …
35 …- A single-input, single-output node that broadcasts each message received to all successors. I…
37 …to one successor. The order in which the messages are sent are node specific (see the Developer …
39 …bines one message from each input port to create a tuple that is broadcast to all successors. Th…
43 …to all successors. After broadcast, the nodes retain the last message received, so it is availab…
45 …to all successors. The main input type and output type are of the same generic type. The node…
47 …- A multi-input, single-output node that broadcasts its output message to all of its successors…
49 …s a tuple of references to ports that border it. This allows for the corresponding ports of the …
[all …]
|
| H A D | attach_flow_graph_to_arena.rst | 3 Attach Flow Graph to an Arbitrary Task Arena
7 |short_name| ``task_arena`` interface provides mechanisms to guide tasks
10 cases, you may want to apply such mechanisms when a flow graph executes.
12 During its construction, a ``graph`` object attaches to the arena, in which the constructing
15 This example shows how to set the most performant core type as the preferred one
25 A ``graph`` object can be reattached to a different ``task_arena`` by calling
26 the ``graph::reset()`` function. It reinitializes and reattaches the ``graph`` to
29 This example shows how to reattach existing graph to an arena with the most performant
31 of the graph, it is spawned in the arena of a graph it is attached to, disregarding
40 See the following topics to learn more:
|
| H A D | Flow_Graph_Message_Passing_Protocol.rst | 8 messages between nodes. A node may not be able to receive and process a
9 message from its predecessor. For a graph to operate most-efficiently,
11 state to pull so when the successor is able to handle a message it can
12 query its predecessor to see if a message is available. If the edge did
13 not reverse from push to pull, the predecessor node would have to
14 repeatedly attempt to forward its message until the successor accepts
19 try to pull a message from a predecessor.
25 switch from pull to push mode.
|
| H A D | use_limiter_node.rst | 7 One way to limit resource consumption is to use a limiter_node to set a
18 The first argument is a reference to the graph it belongs to. The second
19 argument sets the maximum number of items that should be allowed to pass
24 allowed to pass. When a message leaves the controlled part of the graph,
25 a message can be sent to the decrement port on the ``limiter_node`` to
26 decrement the count, allowing additional messages to pass through. In
28 user wants to allow at most three big objects to reach the ``function_node``
29 at a time, and to prevent the ``input_node`` from generating all ``M`` big
80 value. The ``function_node`` has its output, a ``continue_msg``, sent to the
|
| H A D | Memory_Allocation.rst | 8 allocator templates that are similar to the STL template class
16 might have to compete for a single shared pool in a way that allows
17 only one thread to allocate at a time.
20 Use the ``scalable_allocator<T>`` template to avoid scalability
30 to the other, even if the two processors are dealing with different
32 cache lines can take hundreds of clocks to move.
35 Use the ``cache_aligned_allocator<T>`` template to always allocate on
37 ``cache_aligned_allocator`` are guaranteed to not have false sharing.
43 template classes.The following code shows how to declare an STL vector
63 the ``scalable_`` prefix in their names, as well as the way to easily
[all …]
|
| /oneTBB/doc/main/reference/ |
| H A D | concurrent_lru_cache_cls.rst | 7 To enable this feature, define the ``TBB_PREVIEW_CONCURRENT_LRU_CACHE`` macro to 1.
18 A ``concurrent_lru_cache`` container maps keys to values with the ability
19 to limit the number of stored unused values. For each key, there is at most one item
22 The container permits multiple threads to concurrently retrieve items from it.
29 number of unused items. Excessive unused items are erased according to
111 **Returns**: a ``handle`` object holding reference to the matching value.
130 from ``other`` to the newly constructed object. Upon completion,
131 ``other`` no longer refers to any value.
147 completion ``other`` no longer refers to any value.
149 **Returns**: a reference to ``*this``.
[all …]
|
| /oneTBB/doc/GSG/ |
| H A D | integrate.rst | 6 If you want to improve the performance and scalability of your application, you can integrate oneTB…
7 For example, you may want to integrate oneTBB if your application needs to process large amounts of…
9 To integrate oneTBB, you need to:
14 However, you can use CMake* and the pkg-config tool to simplify the process of integrating oneTBB i…
15 See the instructions below to learn how to use the tools.
27 To add oneTBB to another project using CMake*, add the following commands to your ``CMakeLists.txt`…
40 The pkg-config tool is used to simplify the compilation line by retrieving information about packag…
44 provide the full path to search for included files and libraries, or provide a line as the followin…
57 -I<path-to>/tbb/latest/lib/pkgconfig/../..//include
59 ``--libs`` provides the Intel(R) oneTBB library name and the search path to find it:
[all …]
|
| /oneTBB/ |
| H A D | third-party-programs.txt | 27 used to endorse or promote products derived from this software
142 …to take away your freedom to share and change the works. By contrast, the GNU General Public Licen…
154 …to deny users access to install or run modified versions of the software inside them, although the…
252 …to a covered work in accord with this section, you must place, in the relevant source files, a sta…
282 …to enforce a patent (such as an express permission to practice a patent or covenant not to sue for…
318 How to Apply These Terms to Your New Programs
319 …op a new program, and you want it to be of the greatest possible use to the public, the best way t…
321 …to the program. It is safest to attach them to the start of each source file to most effectively s…
344 This is free software, and you are welcome to redistribute it
396 copies of the Software, and to permit persons to whom the Software is
[all …]
|
| H A D | README.md | 5 to complex applications, even if you are not a threading expert.
8 …f scalability. oneTBB provides you with functions, interfaces, and classes to parallelize and scal…
9 All you have to do is to use the templates.
12 * oneTBB enables you to specify logical parallelism instead of threads.
19 Refer to oneTBB [examples](examples) and [samples](https://github.com/oneapi-src/oneAPI-samples/tre…
32 * [Migrating from TBB to oneTBB](https://oneapi-src.github.io/oneTBB/main/tbb_userguide/Migration_G…
40 See [Installation from Sources](INSTALL.md) to learn how to install oneTBB.
43 See our [documentation](./SUPPORT.md) to learn how to request help.
45 ## How to Contribute
47 to learn more.
[all …]
|
| /oneTBB/doc/main/tbb_userguide/design_patterns/ |
| H A D | GUI_Thread.rst | 12 A user interface thread must remain responsive to user requests, and
24 responsive to user requests even while the application has long
25 computations running. For example, the user might want to press a
26 "cancel" button to stop the long running computation. If the GUI
28 able to respond to user requests.
40 - The GUI thread needs to offload work onto other threads without
41 waiting for the work to complete.
45 dedicated to doing the offloaded work.
66 When finished, the task posts an event to the GUI thread to indicate that the work is done.
139 to a worker thread and immediately returns.
[all …]
|
| /oneTBB/doc/main/intro/ |
| H A D | Benefits.rst | 8 without having to be a threading expert. Typically you can improve
11 expertise grows, you may want to dive into more complex subjects that
15 There are a variety of approaches to parallel programming, ranging from
16 using platform-dependent threading primitives to exotic new languages.
23 - **oneTBB enables you to specify logical parallelism instead of
27 that are close to the hardware. Direct programming with threads
28 forces you to efficiently map logical tasks onto threads. In
37 result, general-purpose packages tend to be low-level tools that
53 multiple threads to work on different parts of a collection.
74 - The expression ``*i<*j`` is true if the item pointed to by
[all …]
|
| /oneTBB/examples/graph/binpack/ |
| H A D | README.md | 4 …to a `queue_node`. Multiple function nodes set about taking values from this `queue_node` and pack…
15 * `make perf_run_binpack` - executes the example with suggested parameters to measure the oneTBB pe…
23 * `#threads` - the number of threads to use; a range of the form low\[:high\] where low and optiona…
24 * `verbose` - prints diagnostic output to screen.
25 * `silent` - limits output to timing info; overrides verbose.
26 * `N` - number of values to pack.
28 * `#packers` - number of concurrent bin packers to use (`default=#threads`).
|
| /oneTBB/examples/parallel_for_each/parallel_preorder/ |
| H A D | README.md | 2 Example that uses `parallel_for_each` to do parallel preorder traversal of a sparse graph.
9 …ciated field `ref_count` that is an atomic integer. Initialize `ref_count` to the number of inputs…
10 3. Update each cell in `root_set`, by applying a `parallel_for_each` to a `root_set`.
13 …2. If the count became zero, add the cell to the set of cells to be updated, by calling `feeder::a…
19 **Note:** It is important to understand that this example is unlikely to show speedup if the cell v…
20 * The smaller value type causes each `Cell` to be significantly smaller than a cache line, which le…
21 * The time to update the cells becomes very small, and consequently the overhead of `parallel_for_e…
32 * `make perf_run_parallel_preorder` - executes the example with suggested parameters to measure the…
33 * `make light_test_parallel_preorder` - executes the example with suggested parameters to reduce ex…
41 * `n-of-threads` - the number of threads to use; a range of the form low\[:high\], where low and op…
[all …]
|