| /oneTBB/doc/main/tbb_userguide/ |
| H A D | create_token_based_system.rst | 9 are available in the graph and a message will not be allowed to enter
10 the graph until it can be paired with an available token. When a message
11 is retired from the graph, its token is released, and can be paired with
12 a new message that will then be allowed to enter.
29 The buffer policy can be one of the following:
32 - ``queueing``. This type of policy causes inputs to be matched
44 A token-based system can be created by using reserving join_nodes.
49 ``token_t`` can be anything, for example it could be ``typedef int token_t;``.
114 buffered in the ``input_node``, awaiting a token to be paired with.
129 example, an ``input_node`` could be attached to the input of the
[all …]
|
| H A D | Flow_Graph_Buffering_in_Nodes.rst | 11 Broadcast-push, a message may be passed to one or to multiple
21 - The node stores the message to be forwarded later.
26 not desired, the node should be connected to a buffering node that does
27 store messages that cannot be pushed.
30 If a message has been stored by a node, there are two ways it can be
36 - A successor can be connected using ``make_edge()``.
|
| H A D | Using_Circular_Buffers.rst | 7 Circular buffers can sometimes be used to minimize the overhead of
10 both ``serial_in_order``, the items can be allocated and freed via a
16 The reason this works is that at most ``ntoken`` items can be in flight,
17 and items will be freed in the order that they were allocated. Hence by
22 not be retired in the same order they were allocated.
|
| H A D | Advanced_Topic_Other_Kinds_of_Iteration_Spaces.rst | 10 must specify how it can be split into subspaces by providing a basic splitting
12 methods. If your class is called ``R``, the methods and constructors should be
22 // True if range can be split into non-empty subranges
35 method ``is_divisible`` should return true if the range can be split
49 update ``r`` to be the first half, and set the constructed object as the
56 that return the values of the proportion. These values should be used to
68 The iteration space does not have to be linear. Look at
72 loop to be "recursively blocked" in a way that improves cache usage.
|
| H A D | Mutex_Flavors.rst | 10 performance. Mutexes can be described by the following qualities, also
21 light contention, so a non-scalable mutex may be better. When in
25 - **Fair**. Mutexes can be *fair* or *unfair*. A fair mutex lets
28 can be faster, because they let threads that are running go through
29 first, instead of the thread that is next in line which may be
36 repeatedly poll whether progress can be made, and if not, temporarily
47 user space. It would seem to be the worst of all possible worlds,
84 - ``null_mutex`` and ``null_rw_mutex`` do nothing. They can be useful
86 container template and know that some instantiations will be shared
87 by multiple threads and need internal locking, but others will be
[all …]
|
| H A D | Task_Scheduler_Bypass.rst | 8 the spawning of the new task to be executed by the current thread involves the next steps:
15 …llelism. These problems can be avoided by using "Task Scheduler Bypass" technique to directly poin…
17 the returned task becomes the first candidate for the next task to be executed by the thread. Furth…
|
| H A D | automatically-replacing-malloc.rst | 13 Replacements are provided by the proxy library (the library names can be
15 scalable memory allocator library should be taken from the same release
16 of oneTBB, otherwise the libraries may be mutually incompatible.
|
| H A D | Working_on_the_Assembly_Line_pipeline.rst | 12 frames do not depend on other frames, and so can be done on multiple
19 simple text processing example will be used to demonstrate the usage of
28 ``parallel_pipeline`` might be copied, its ``operator()`` should not
33 object's ``operator()`` be declared ``const``.
51 Assume that the raw file I/O is sequential. The squaring filter can be
55 raw I/O is sequential, the formatting of input and output can be moved
56 to the middle filter, and thus be parallel.
130 a serial in-order filter, each token must be processed serially in
133 might be a problem where the unordered filter in the middle keeps
137 maximum number of tokens that can be in flight. Once this limit is
[all …]
|
| H A D | Timing.rst | 33 Unlike some timing interfaces, ``tick_count`` is guaranteed to be safe
36 be converted to seconds.
42 some platforms, this means that the resolution of tick_count can not be
43 guaranteed to be consistent across platforms.
|
| H A D | Bandwidth_and_Cache_Affinity_os.rst | 8 good speedup when written as parallel loops. The cause could be
60 each iteration can be handed to the same thread that executed it before.
63 would be to declare it at a scope outside the iterative loop in
67 If the data does not fit across the system’s caches, there may be little
85 large to be carried in cache between loop invocations. The peak in the
87 should be considered a tool, not a cure-all, when there is a low ratio
|
| H A D | Containers.rst | 8 container classes. These containers can be used with raw Windows\* OS or
15 result in corrupting the container. STL containers can be wrapped in a
45 container object must not be invoked concurrently with another
47 the operation to be executed on an undefined object.
|
| H A D | Exceptions_and_Cancellation.rst | 18 also be cancelled as explained in :ref:`Cancellation_and_Nested_Parallelism`.
25 The exception thrown in step 3 might be the original exception, or might
26 merely be a summary of type ``captured_exception``. The latter usually
30 oneTBB might throw the original exception. So be sure your code can
|
| H A D | Concurrent_Queue_Classes.rst | 13 The check and popping have to be done in a single operation for sake of
33 the composition of those methods as shown in the example would not be
56 those two values, they will be popped in the same order that they were
63 appropriate when the synchronization has to be done at a higher level.
91 ``empty()`` is defined to be true if and only if ``size()`` is not
96 number of values, until memory runs out. It can be bounded by setting
|
| /oneTBB/doc/ |
| H A D | Doxyfile.in | 75 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
406 # namespace, or class. And the struct will be named TypeS. This can typically be
531 # scope will be hidden.
695 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
771 # be replaced by the version of the file (if it could be obtained via
870 # The EXCLUDE tag can be used to specify files and/or directories that should be
941 # will be ignored.
1113 # can be used to specify a prefix (or a list of prefixes) that should be ignored
1680 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
2165 # be listed.
[all …]
|
| /oneTBB/doc/main/tbb_userguide/design_patterns/ |
| H A D | Agglomeration.rst | 26 elementwise addition of two arrays can be done fully in parallel, but
28 time will be spent doing synchronization instead of useful addition.
37 - Individual computations can be done in parallel, but are small.
56 The block size should be chosen to be large enough to amortize
72 be independent too, and then only cache traffic issues must be
77 cycles, then it may be impractical to parallelize at all, because the
78 optimal agglomeration might be a single block,
95 There may be boundary to interior ratio effects. For example, if the
101 analysis, be careful to consider that information is transferred in
102 cache line units. For a given area, the perimeter may be minimized
|
| H A D | Odd-Even_Communication.rst | 13 Operations on data cannot be done entirely independently, but data
14 can be partitioned into two subsets such that all operations on a
24 Solvers for partial differential equations can often be modified to
26 nearest-neighbor communication, it may be possible to treat the grid
|
| H A D | Local_Serializer.rst | 14 responsiveness, operations requested by the user can be implemented
15 as tasks. The order of operations can be important. For example,
17 be operations to select text and delete selected text. Reversing the
18 order of "select" and "delete" operations on the same buffer would be
19 bad. However, commuting operations on different buffers might be
31 - Operations associated with a certain object must be performed in
35 - Serializing with a lock would be wasteful because threads would be
36 waiting at the lock when they could be doing useful work
53 The logic can be implemented without mutexes, by using
188 Step 2 could be done after step 3 in some contexts to increase
[all …]
|
| H A D | Reference_Counting.rst | 13 Destroy an object when it will no longer be used.
23 will not be used in the future. Reference counting is a common serial
76 zero. The following code would be an incorrect implementation of
79 would both be told incorrectly that they had removed the last
95 reference count, because there will be a timing hole between the
108 Atomic increment/decrement can be more than an order of magnitude
114 Weighted reference counting can be used to reduce costs if the
117 weights. A pointer ``x`` can be copied as a pointer ``x'`` without
|
| H A D | Lazy_Initialization.rst | 14 In parallel programming, initialization must also be guarded against race conditions.
24 of the object may be considerably high. In that case, the object
25 should be initialized only when needed. Lazy initialization is
71 …paired with ``collaborative_once_flag`` and will not be recalculated when ``collaborative_call_onc…
86 // Other threads won't be blocked on already taken collaborative_once_flag
|
| /oneTBB/doc/main/reference/ |
| H A D | task_group_extensions.rst | 63 As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed ne…
66 …The ``task_handle`` returned by the function must be created using ``*this`` ``task_group``. That …
70 As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed ne…
73 …The ``task_handle`` returned by the function must be created using ``*this`` ``task_group``. That …
78 As an optimization hint, ``F`` might return a ``task_handle``, which task object can be executed ne…
81 …The ``task_handle`` returned by the function must be created with ``*this`` ``task_group``. It mea…
|
| H A D | parallel_for_each_semantics.rst | 52 of the ``body`` with an object of type ``const value_type&`` or ``value_type&&`` to be well-formed.…
53 rvalue reference will be preferred.
57 …ference to ``value_type``, named requirements above are violated and the program can be ill-formed.
60 with an object of type ``reference`` to be well-formed.
66 execution of the ``Body`` is required to be well-formed.
|
| /oneTBB/doc/main/intro/ |
| H A D | notation.rst | 7 The following conventions may be used in this document.
35 - The ellipsis indicates that the previous item can be repeated several times.
36 … - \ ``filename`` ... Indicates that one or more filenames can be specified.
38 …- The ellipsis preceded by a comma indicates that the previous item can be repeated sever…
39 …- \ ``word`` ,... Indicates that one or more words can be specified. If more than on…
|
| /oneTBB/doc/main/tbb_userguide/Migration_Guide/ |
| H A D | Task_API.rst | 13 For most use cases, the spawning of individual tasks can be replaced with the use of either
43 The code above can be rewritten using ``oneapi::tbb::task_group``:
65 // Member to be called when object of this type are passed into
94 In TBB, cases when the amount of work is not known in advance and the work needs to be added during
143 The previous use case can be rewritten in oneTBB as follows:
168 The previous use case can be rewritten using ``oneapi::tbb::task_group`` as:
198 method. The functor will be copied in this case. However, its state can be shared among instances:
215 // Note that this might be concurrently accessing m_shared_data already
335 is not guaranteed to be executed next by the current thread.
367 In oneTBB, this can be done using ``oneapi::tbb::task_group``.
[all …]
|
| /oneTBB/examples/ |
| H A D | README.md | 13 | graph/logic_sim | An example of a collection of digital logic gates that can be easily composed i…
32 … seismic, tachyon, polygon_overlay) support different GUI modes, which may be defined via the `EXA…
38 …perior performance but can only be used if the Microsoft* DirectX* SDK is installed on your system…
40 …- `x` - `X11` based implementation. Also `libXext` may be required to display the output correctly.
|
| /oneTBB/examples/parallel_reduce/primes/ |
| H A D | README.md | 22 * `number` - the upper bound of range to search primes in, must be a positive integer.
23 * `grain-size` - the optional grain size, must be a positive integer.
24 * `n-of-repeats` - the number of the calculation repeats, must be a positive integer.
|