80 lines
2.3 KiB
Text
80 lines
2.3 KiB
Text
namespace tf {
|
|
|
|
/** @page wavefront Wavefront Parallelism
|
|
|
|
We study the wavefront parallelism, which is a common pattern in dynamic programming to sweep elements
|
|
in a diagonal direction.
|
|
|
|
@tableofcontents
|
|
|
|
@section WavefrontComputingFormulation Problem Formulation
|
|
|
|
The computation starts at a singular point at a corner of a data plan (e.g., grid) and propagates its effect
|
|
diagonally to other elements.
|
|
This sweep of computation is known as @em wavefront.
|
|
Each point in the wavefront can be computed in parallel.
|
|
The following example shows a wavefront parallelism in a 2D matrix.
|
|
|
|
@image html images/wavefront_1.png width=70%
|
|
|
|
We partition the 9x9 grid into a 3x3 block and assign a task to one block.
|
|
The wavefront propagates task dependencies from the top-left block all the way
|
|
to the bottom-right block.
|
|
Each task precedes two tasks, one to the right and another below.
|
|
|
|
@section WavefrontTaskGraph Wavefront Task Graph
|
|
|
|
We can describe the wavefront parallelism in a simple two-level loop.
|
|
Since we need to address the two tasks upper and left to a task when creating its dependencies,
|
|
we use a 2D vector to pre-allocate all tasks via tf::Taskflow::placeholder.
|
|
|
|
@code{.cpp}
|
|
#include <taskflow/taskflow.hpp>
|
|
|
|
int main() {
|
|
tf::Executor executor;
|
|
tf::Taskflow taskflow;
|
|
int num_blocks = 3;
|
|
std::vector<std::vector<tf::Task>> node(num_blocks);
|
|
|
|
// create num_blocks*num_blocks placeholder tasks
|
|
for(auto &n : node){
|
|
for(int i=0; i<num_blocks; i++){
|
|
n.emplace_back(taskflow.placeholder());
|
|
}
|
|
}
|
|
|
|
// scan each block and create dependencies
|
|
for( int i=num_blocks; --i>=0; ) {
|
|
for( int j=num_blocks; --j>=0; ) {
|
|
// deferred task assignment
|
|
node[i][j].work([=]() { printf("compute block (%d, %d)", i, j); });
|
|
|
|
// wavefront dependency
|
|
if(j+1 < num_blocks) node[i][j].precede(node[i][j+1]);
|
|
if(i+1 < num_blocks) node[i][j].precede(node[i+1][j]);
|
|
}
|
|
}
|
|
|
|
executor.run(taskflow).wait();
|
|
|
|
// dump the taskflow
|
|
taskflow.dump(std::cout);
|
|
}
|
|
@endcode
|
|
|
|
The figure below shows the wavefront parallelism in a 3x3 grid:
|
|
|
|
@dotfile images/wavefront_2.dot
|
|
|
|
Wavefront parallelism has many variations in different applications,
|
|
for instance, Smith-Waterman sequencing, video encoding algorithms, image analysis,
|
|
and pipeline parallelism.
|
|
The parallel pattern exhibits in a diagonal direction.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|