| /oneTBB/doc/main/tbb_userguide/ |
| H A D | use_limiter_node.rst | 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
30 objects at once.
76 objects at once. The ``limiter_node`` has a threshold of 3, and will
84 again. So in this example, at most four big objects exist at a time, the
|
| H A D | always_use_wait_for_all.rst | 27 // program will fail when f and g are destroyed at the
32 In the function above, the graph g and its node f are destroyed at the
37 g.wait_for_all() at the end of the function prevents the premature
|
| H A D | Automatic_Chunking.rst | 15 Typically a loop needs to take at least a million clock cycles to
17 at least 500 microseconds on a 2 GHz processor might benefit from
|
| H A D | Exceptions_and_Cancellation.rst | 53 Data.at(i) += 1;
70 with only 1000 elements. Hence the expression ``Data.at(i)`` sometimes
73 exception thrown at the call site to ``parallel_for``.
|
| H A D | catching_exceptions.rst | 10 of the graph's nodes are canceled and the exception is rethrown at the
42 graph to be canceled and the exception to be rethrown at the call to
64 instead to catch the exception at the call to wait_for_all:
|
| H A D | Lock_Pathologies.rst | 25 - Each thread holds at least one lock on a mutex, and is waiting on
33 Think of classic gridlock at an intersection – each car has
38 - Avoid needing to hold two locks at the same time. Break your
|
| H A D | Memory_Allocation.rst | 17 only one thread to allocate at a time.
54 The functionality of ``cache_aligned_allocator<T>`` comes at some
55 cost in space, because it must allocate at least one cache line’s
|
| H A D | Using_Circular_Buffers.rst | 11 circular buffer of size at least ``ntoken``, where ``ntoken`` is the
16 The reason this works is that at most ``ntoken`` items can be in flight,
|
| H A D | appendix_A.rst | 35 evicted data, at the cost of hundreds of cycles for each cache miss. Or
43 it is now going to hold it for at least as long as it takes for its next
44 turn at a time slice to come up. Any other threads waiting on the lock
|
| H A D | Linux_C_Dynamic_Memory_Interface_Replacement.rst | 34 You can do the replacement either by loading the proxy library at
41 scalable memory allocator library at program load time. For that you may
|
| H A D | Containers.rst | 17 thread operate on the container at a time, but that approach eliminates
35 Notice that highly-concurrent containers come at a cost. They typically
|
| H A D | Task-Based_Programming.rst | 54 typically a small routine, and also, cannot be preempted at the task
85 they let you think at a higher, task-based, level. With thread-based
86 programming, you are forced to think at the low level of physical
|
| H A D | use_nested_flow_graphs.rst | 125 It is only necessary to call ``h.wait_for_all()`` at the end of each
128 of ``b``, it was necessary to call ``h.wait_for_all`` at the end of each
129 invocation since the graph was destroyed at the end of the scope. So it
|
| H A D | Controlling_Chunking_os.rst | 85 overhead. Case B shows how a large grainsize reduces this proportion, at
93 should take at least 100,000 clock cycles to execute. For example, if a
94 single iteration takes 100 clocks, then the ``grainsize`` needs to be at
102 normally requires at least one clock per iteration. In most cases,
|
| H A D | Flow_Graph_Reservation.rst | 9 ``key_matching`` and ``tag_matching``. ``join_nodes`` need messages at
12 messages from its inputs until it has a message at each input. To create
13 an output message it temporarily reserves a message at each input port,
46 input port has at least one edge in a pull state, and will only attempt
48 messages, at least one of the predecessors to each of the reserving
|
| H A D | Cook_Until_Done_parallel_do.rst | 16 can be safely processed in parallel, and processing each item takes at
33 If ``Foo`` takes at least a few thousand instructions to run, you can
|
| H A D | Summary_of_Loops_and_Pipelines.rst | 8 They let you design your software at a high task-pattern level and not worry about low-level manipu…
|
| H A D | use_make_edge.rst | 24 topology at runtime.
|
| /oneTBB/examples/graph/som/ |
| H A D | som.hpp | 84 return w.at(indx); in operator []()
87 return w.at(indx); in operator []()
151 SOM_element &at(int xVal, int yVal) { in at() function in SOMap
154 SOM_element &at(search_result_type const &s) { in at() function in SOMap
|
| /oneTBB/examples/concurrent_priority_queue/shortpath/ |
| H A D | shortpath.cpp | 169 vertex_id at = predecessor[dst]; in make_path() local
170 if (at == N) in make_path()
172 else if (at == src) { in make_path()
177 make_path(src, at, path); in make_path()
|
| H A D | README.md | 35 * `start` - node to start path at.
36 * `end` - node to end path at.
|
| /oneTBB/test/tbb/ |
| H A D | test_enumerable_thread_specific.cpp | 195 my_vec.at(i).push_back((T)(maxval * i + j)); in flog_segmented_interator()
229 my_vec.at(i).push_back((T)(maxval * (i/2) + j)); in flog_segmented_interator()
267 my_vec.at(i).push_back((T)(maxval * (i/2) + j)); in flog_segmented_interator()
296 my_vec.at(i).insert(std::make_pair<Key,Val>(maxval * i + j, 2*(maxval*i + j))); in flog_segmented_iterator_map()
|
| /oneTBB/cmake/compilers/ |
| H A D | MSVC.cmake | 5 # You may obtain a copy of the License at
31 # More info can be found at
|
| /oneTBB/test/common/ |
| H A D | doctest.h | 1555 , m_at(at) {}
1626 ExpressionDecomposer(assertType::Enum at);
3884 const char* assertString(assertType::Enum at) {
3891 switch(at) {
3924 const char* failureString(assertType::Enum at) {
4139 bool checkIfShouldThrow(assertType::Enum at) {
4339 : m_at(at) {}
4925 void addAssert(assertType::Enum at) {
4930 void addFailedAssert(assertType::Enum at) {
6045 return failureString(at);
[all …]
|
| /oneTBB/src/tbbbind/def/ |
| H A D | mac64-tbbbind.def | 5 # You may obtain a copy of the License at
|