control.loop ≡

Execute body for a range of values starting from begin and ending before end, incrementing by step on each iteration.

Keep calling body while the condition returns true.

Spawn count threads executing body, which can be a lambda or a function taking one argument specifying the thread index from the range [0, count).

pipelined_for(x, [](uint4 i)
{
    // ...
});

void foo(uint8 i)
{
}

pipelined_for(256, foo);

Hardware

Each call to pipelined_for inserts a record into a FIFO. This FIFO holds the thread count and the values of captured variables. A finite state machine translates each FIFO record into thread_count calls to the inner function. A separate finite state machine unblocks the calling thread after thread_count threads have completed. Unblocking is achieved with a zero-width fifo.

void F(uint32 x, uint32 y)
{
    uint32 thread_count = x + 1;

    pipelined_for(thread_count, [y](uint32 tid)
    {
    });
}

Spawn a thread for each element of array arr calling body which can be a lambda or a function taking two arguments, the thread index and the element value.

uint32[10] a;
pipelined_for_each(a,  [](uint4 i, uint32 x)
{
    ...
});

Spawn threads that will execute the body closure until it returns false. If body has an argument, then the number of threads used is 2^bitsizeof(I). This should be larger than the depth of the body pipeline. If body does not have an argument, then the number of threads used is .options::max_threads_limit. The function returns after body returns false and all in-flight threads “drain” from the loop. When an instance of pipelined_do is called multiple times, the threads for subsequent calls will not start until all threads for earlier calls have started (although not necessarily exited).

pipelined_do([](index_t<32> i)
{
    // ...
    return !done;
});

pipelined_do([]()
{
    // ...
    return !done;
});

Spawn count threads executing body, which can be a lambda or a function taking one argument specifying the thread index from the range [0, count]. The function returns an array T[N] of values produced by body. N must not be greater than count.

auto a = pipelined_map<10>(x, [](uint4 i) -> uint32
{
    // ...
});

Hardware

The hardware generated for pipelined_map is similar to the hardware generated for pipelined_for. The thread collection finite state machine concatenates the return values from each inner thread into an array and returns that array to the caller.

uint32[4] F(uint32 x, uint32 y)
{
    uint32 thread_count = x + 1;

    uint32[4] result = pipelined_map
        ( thread_count,
              [y](uint32 tid) -> uint32
              {
                  return y + tid;
              }
        );

    return result;
}

Spawn count threads executing body, which can be a lambda or a function taking one argument specifying the thread index from the range [0, count]. The function returns result produced by last call to body.

auto a = pipelined_last(x, [](uint4 i)
{
    // ...
});

Hardware

The hardware generated for pipelined_last is similar to the hardware generated for pipelined_for. The thread collection finite state machine ignores the return value from all inner threads except the last one, where tid == (thread_count - 1). This value is returned to the caller. If the thread count is equal to 0, then default_value is returned.

uint32 F(uint32 x, uint32 y)
{
    uint32 thread_count = x + 1;

    uint32 result = pipelined_last
        (thread_count,
            [y](uint32 tid)
            {
                return y + tid;
            }
        );

    return result;
}

Spawn count threads executing body, which can be a lambda or a function taking one argument specifying the thread index from the range [0, count).

Threads execute across N instances of the function body. There are no ordering guarantees among threads spawned by one call to parallel_for. If there are two calls (A and B) to a single parallel_for call site, resulting in threads A0, A1, B0, B1 executing body, then thread A0 will begin executing body ahead of B0 and A1 will begin executing body ahead of B1.

count must be less than N.

parallel_for(x, [](uint4 i)
{
    // ...
});

void foo(uint8 i)
{
}

parallel_for(256, foo);

Hardware

Each call to parallel_for broadcasts captured variables to N FIFOs. Each of these FIFOs is associated with a pipeline which is an instance of body. After executing body, a counter is incremented, which is used to block the calling thread until all calls to body have completed.

void F(uint32 x, uint32 y)
{
    parallel_for(2, [x, y](index_t<2> tid)
    {
    });
}

Spawn a thread for each element of array arr calling body which can be a lambda or a function taking two arguments, the thread index and the element value.

Threads execute across N instances of the function body. There are no ordering guarantees among threads spawned by one call to parallel_for_each. If there are two calls (A and B) to a single parallel_for_each call site, resulting in threads A0, A1, B0, B1 executing body, then thread A0 will begin executing body ahead of B0 and A1 will begin executing body ahead of B1.

uint32[10] a;
parallel_for_each(a,  [](uint4 i, uint32 x)
{
    ...
});

Spawn count threads executing body, which can be a lambda or a function taking one argument specifying the thread index from the range [0, count]. The function returns an array T[N] of values produced by body. N must not be greater than count.

Threads execute across N instances of the function body. There are no ordering guarantees among threads spawned by one call to parallel_map. If there are two calls (A and B) to a single parallel_map call site, resulting in threads A0, A1, B0, B1 executing body, then thread A0 will begin executing body ahead of B0 and A1 will begin executing body ahead of B1.

auto a = parallel_map<4>(x, [](uint2 i) -> uint32
{
    // ...
});

Hardware

Each call to parallel_map broadcasts captured variables to N FIFOs. Each of these FIFOs is associated with a pipeline which is an instance of body. After executing body, the return result is placed into a FIFO. Results from all FIFOs are dequeued and returned.

void F(uint32 x, uint32 y)
{
    parallel_map<2>(2, [x, y](index_t<2> tid) -> uint32
    {
         return x + y;
    });
}