wavefront

# Wavefront Parallelism

Problem Formulation
wavefront_1WavefrontComputingFormulation
Wavefront Task Graph
wavefront_1WavefrontTaskGraph

We study the wavefront parallelism, which is a common pattern in dynamic programming to sweep elements in a diagonal direction.

# 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 wavefront. Each point in the wavefront can be computed in parallel. The following example shows a wavefront parallelism in a 2D matrix.

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.

# 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.

    #include<taskflow/taskflow.hpp>

    intmain(){
    tf::Executorexecutor;
    tf::Taskflowtaskflow;
    intnum_blocks=3;
    std::vector<std::vector<tf::Task>>node(num_blocks);

    //createnum_blocks*num_blocksplaceholdertasks
    for(auto&n:node){
    for(inti=0;i<num_blocks;i++){
    n.emplace_back(taskflow.placeholder());
    }
    }

    //scaneachblockandcreatedependencies
    for(inti=num_blocks;--i>=0;){
    for(intj=num_blocks;--j>=0;){
    //deferredtaskassignment
    node[i][j].work([=](){printf("computeblock(%d,%d)",i,j);});

    //wavefrontdependency
    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();

    //dumpthetaskflow
    taskflow.dump(std::cout);
    }

The figure below shows the wavefront parallelism in a 3x3 grid:

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.