| /oneTBB/doc/main/tbb_userguide/ |
| H A D | Using_Circular_Buffers.rst | 8 allocating and freeing the items passed between pipeline filters. If the
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
|
| H A D | Cook_Until_Done_parallel_do.rst | 14 arrays instead of linked lists, because accessing items in a linked list
15 is inherently serial. But if you are limited to linked lists, the items
83 ``parallel_for_each`` does not terminate until all items have been
|
| H A D | appendix_A.rst | 23 has to evict items from cache and put them back into main memory.
24 Typically, it chooses the least recently used items in the cache. (The
|
| H A D | When_Not_to_Use_Queues.rst | 30 do other work until a value shows up. It also tries to keep items hot in
|
| H A D | Containers.rst | 13 and update items in the container. Typical C++ STL containers do not
|
| H A D | use_limiter_node.rst | 19 argument sets the maximum number of items that should be allowed to pass
|
| H A D | Working_on_the_Assembly_Line_pipeline.rst | 154 - The *mode* specifies whether the filter processes items in parallel,
189 process items in the same order. Thus if an item arrives at
|
| /oneTBB/doc/main/tbb_userguide/Migration_Guide/ |
| H A D | Task_API.rst | 126 std::vector<int> items = { 0, 1, 2, 3, 4, 5, 6, 7 };
129 root.set_ref_count(items.size() + 1);
131 for (std::size_t i = 0; i < items.size(); ++i) {
151 std::vector<int> items = { 0, 1, 2, 3, 4, 5, 6, 7 };
154 items.begin(), items.end(),
177 std::vector<int> items = { 0, 1, 2, 3, 4, 5, 6, 7 };
180 for (std::size_t i = 0; i < items.size(); ++i) {
181 tg.run([&i = items[i], &tg] {
318 std::vector<int> items(10, 0);
319 std::atomic<std::size_t> tasks_left{items.size()};
[all …]
|
| /oneTBB/src/tbbmalloc/ |
| H A D | shared_utils.h | 105 void parseFile(const char* file, const parseFileItem (&items)[N]) {
116 if (!found[i] && 1 == sscanf(buf, items[i].format, &items[i].value)) {
|
| /oneTBB/doc/main/tbb_userguide/design_patterns/ |
| H A D | Wavefront.rst | 13 Perform computations on items in a data set, where the computation on
14 an item uses results from computations on predecessor items.
32 - Dependence constraints between items form an acyclic graph.
47 ``oneapi::tbb::parallel_for_each`` to process items. Associate an atomic
49 predecessors. Invoke ``oneapi::tbb::parallel_for_each`` to process the items that
62 If the overhead of counting individual items is excessive, aggregate
63 items into blocks, and do the wavefront over the blocks.
|
| H A D | Elementwise.rst | 13 Initiate similar independent computations across items in a data set,
23 Many serial algorithms sweep over a set of items and do an
43 If the number of items is known in advance, use
|
| H A D | Local_Serializer.rst | 46 Sequence the work items using a FIFO (first-in first-out structure).
55 number of items waiting and in flight. The example explains the
203 std::atomic<int> count; // Count of queued items and in-flight item
273 The pattern generalizes to constraints on work items more general
277 ``Serializer::noteCompletion`` runs all previously constrained items
|
| H A D | Odd-Even_Communication.rst | 41 - Dependencies between items form a bipartite graph.
|
| H A D | Non-Preemptive_Priorities.rst | 35 - Given multiple work items, there is a rule for which item should
41 items in flight. If preemptive priorities are necessary, then
|
| H A D | GUI_Thread.rst | 71 by the GUI thread; items in blue are executed by another thread.
|
| H A D | Reduction.rst | 22 Many serial algorithms sweep over a set of items to collect summary
|
| /oneTBB/doc/main/reference/ |
| H A D | concurrent_lru_cache_cls.rst | 22 The container permits multiple threads to concurrently retrieve items from it.
24 The container tracks which items are in use by returning a proxy
28 The container stores all the items that are currently in use plus a limited
29 number of unused items. Excessive unused items are erased according to
|
| /oneTBB/test/common/ |
| H A D | concurrent_associative_common.h | 676 FillTable(Container& table, int items, bool asymptotic)
677 : my_table(table), my_items(items), my_asymptotic(asymptotic)
679 REQUIRE((!(items&1) && items > 100));
779 int items = 2000;
781 int items = 20000;
790 items = 4 * items / (num_threads + 2);
791 items_inserted = items + (num_threads - 2) * items / 4;
793 items_inserted = items;
801 atomic_byte_type* array = new atomic_byte_type[items];
802 std::memset(static_cast<void*>(array), 0, items * sizeof(atomic_byte_type));
[all …]
|
| H A D | concurrent_ordered_common.h | 138 int items = 1000; in test_concurrent_order() local
143 for (int i = 0; i < items; i += step) { in test_concurrent_order()
147 for (int i = items; i > 0; i -= step) { in test_concurrent_order()
|
| /oneTBB/doc/main/intro/ |
| H A D | notation.rst | 29 …ces and vertical bars indicate the choice of one item from a selection of two or more items.
|
| /oneTBB/include/oneapi/tbb/detail/ |
| H A D | _concurrent_queue_base.h | 85 return items[index];
90 return items[index];
97 value_type items[items_per_page]; member
|
| /oneTBB/examples/graph/fgbzip2/ |
| H A D | bzlib.cpp | 143 static void* default_bzalloc(void* opaque, Int32 items, Int32 size) { in default_bzalloc() argument
144 void* v = malloc(items * size); in default_bzalloc()
|
| /oneTBB/doc/ |
| H A D | Doxyfile.in | 12 # For lists, items can also be appended using:
1366 # The TOC_EXPAND flag can be set to YES to add extra items for group members to
2289 # number of items for each type to make the size more manageable. Set this to 0
|