Learn from a complete pipeline

 // Resources are linked by binding the same object to adjacent shader ports.
 shdr::pipeline pipeline = shdr::dispatch(affine, shdr::extent((count + 63) / 64)) >> // Start with enough 64-wide groups to cover all original inputs.
 shdr::dispatch(clip, shdr::extent((count + 31) / 32)) >> // Run the linked clip shader with its own 32-wide workgroup size.
 shdr::dispatch(sum, shdr::extent(1)); // Finish with one deterministic reduction invocation over the clipped resource.
 run.run(pipeline); // Execute the configured pipeline on the requested backend.
 float expected = 0.0f; // Start the independent host reference sum at zero.
 const shdr::buffer<float>& read_input = input; // Use a constant buffer view so GPU writes synchronize before host reads.
 for (unsigned i = 0; i < count; ++i) // Apply the same scale, offset and clipping formula to every original input.
 expected += std::min(8.0f, std::max(0.0f, read_input.data()[i] * 2.0f + 1.0f)); // Accumulate the independent reference from the original inputs.
 const shdr::buffer<float>& read_result = result; // Use a constant buffer view so GPU writes synchronize before host reads.
 shdr_examples::require_close(read_result.data()[0], expected, "pipeline sum"); // Check the computed value against the independent reference.
 std::cout << (run.gpu() ? "GPU" : "CPU") << " buffer pipeline: " << read_result.data()[0] // Write this part of the example result or diagnostic.
 << "\n"; // Write this part of the example result or diagnostic.

    auto shader = shdr::make_kernel("affine_kernel"); // Create the linked affine kernel instance.
    shader->set<unsigned>("count", element_count); // Supply this shader uniform with its typed application value.
    shdr::pipeline pipeline(shdr::dispatch(*shader, shdr::extent((element_count + 63) / 64))); // Add a shader dispatch with the required workgroup counts.
    std::unique_ptr<shdr::executor> workers; // Declare workers for the following calculation.
    if (!runner.gpu()) // Check this condition before entering the following branch.
        workers.reset(new shdr::executor(2, slot_count)); // Apply reset to these arguments.
    if (runner.gpu()) { // Check this condition before entering the following branch.
        // Initial program compilation and every slot's allocation/upload happen
        // before entering the polling loop.
        for (unsigned index = 0; index < slot_count; ++index) { // Iterate over index for this calculation.
            shader->bind("input_values", slots[index].input) // Connect this shader port to its application resource.
                .bind("output_values", slots[index].output); // Connect this shader port to its application resource.
            pipeline.prepare(*runner.device()); // Apply prepare to these arguments.
        } // End this block.
    } // End this block.

        const shdr::extent groups((count + 63) / 64); // Construct groups with these initial values.
        auto pipeline = shdr::dispatch(*gaussian_x, groups) >> // Add a shader dispatch with the required workgroup counts.
                        shdr::dispatch(*gaussian_y, groups) >> shdr::dispatch(*sobel, groups) >> // Add a shader dispatch with the required workgroup counts.
                        shdr::dispatch(*tensor, groups) >> shdr::dispatch(*harris, groups) >> // Add a shader dispatch with the required workgroup counts.
                        shdr::dispatch(*nonmax, groups); // Add a shader dispatch with the required workgroup counts.
        run.run(pipeline); // Execute the configured pipeline on the requested backend.

        const std::vector<float> expected_blur = gaussian_reference(input, width, height); // Set expected blur from this expression.
        const std::vector<glsl::vec2> expected_gradients = // Set expected gradients from this expression.
            gradient_reference(expected_blur, width, height); // Apply gradient reference to these arguments.
        const std::vector<float> expected_response = // Set expected response from this expression.
            harris_reference(expected_gradients, width, height, harris_k); // Apply harris reference to these arguments.
        const shdr::buffer<float>& read_blur = blurred; // Use a constant buffer view so GPU writes synchronize before host reads.
        const shdr::buffer<glsl::vec2>& read_gradients = gradients; // Use a constant buffer view so GPU writes synchronize before host reads.

#include "fft_checks.hpp" // Check FFT, spectral masks, and input windows.
#include "signal_filters_checks.hpp" // Check causal FIR and streaming biquad filters.
int main(int argc, char** argv) { // Run every signal example with the same selected backend.
 try { // Report dimension or numerical errors as a failed example.
 shdr_examples::runner run(argc, argv); // Use CPU by default or the requested GPU profile.
 shdr_examples::check_fft1d(run); // Validate the forward and inverse complex transforms.
 shdr_examples::check_frequency_filters(run); // Validate all frequency-domain filter modes.
 shdr_examples::check_signal_windows(run); // Validate windowed spectral analysis.
 shdr_examples::check_signal_filters( // Validate FIR responses and persistent biquad state.
 run); // Validate FIR responses and persistent biquad state.
 std::cout << (run.gpu() ? "GPU" : "CPU") // Report the completed real-data processing check.
 << " signal pipelines passed\n"; // Show which backend completed the checks.
 return 0; // All processing and reference comparisons succeeded.
#ifdef SHDR_HAVE_EGL // The optional EGL backend can identify unavailable contexts.
 } catch (const shdr_examples::context_unavailable& // Select the profiles supplied by the driver.

        reference_decoder reference; // Declare reference for the following calculation.
        const std::vector<uvec4> expected = reference.decode(words); // Set expected from this expression.
        runner.run(decoder.reset_pipeline()); // Execute the configured pipeline on the requested backend.
        compare(decoder, expected, reference); // Apply compare to these arguments.
        runner.run(decoder.reset_pipeline()); // Execute the configured pipeline on the requested backend.
        compare(decoder, expected, reference); // Apply compare to these arguments.
    } // End this block.
    shdr_examples::evt3_decoder decoder(6013); // Construct decoder with these initial values.
    words = shdr_examples::evt3_random_words(6013, 897); // Set words from this expression.
    decoder.load(words); // Apply load to these arguments.
    reference_decoder reference; // Declare reference for the following calculation.
    const std::vector<uvec4> expected = reference.decode(words); // Set expected from this expression.
    runner.run(decoder.reset_pipeline()); // Execute the configured pipeline on the requested backend.
    compare(decoder, expected, reference); // Apply compare to these arguments.
} // End this block.

 shdr::dispatch(*affine, shdr::extent((count + 63u) / 64u)) >> // Dispatch the affine stage with its configured geometry.
 shdr::dispatch(*clamp, shdr::extent((count + 31u) / 32u), shdr::backend::cpu) >> // Dispatch the clamp stage with its configured geometry.
 shdr::dispatch(*sum, shdr::extent(1)); // Force one stage onto CPU in a mixed pipeline.
 data::evaluate( // Compare the complete real-data pipeline outputs on CPU and the requested GPU backend.
 run, // Select the same execution backend for this complete case.
 "NASA mixed CPU/GPU resources", // Use the exact diagnostic or comparison label for this case.
 hybrid, // Validate real-data ownership changes between backends.
 {&clipped_check, &total_check}); // Validate real-data ownership changes between backends.
 if (run.gpu()) { // Exercise the library's headless asynchronous GPU path.
 stages.prepare(*run.device()); // Compile programs and allocate resources before polling.
 auto completion = // Queue the GPU work and obtain its completion fence.
 stages.submit(*run.device()); // Queue the GPU work and obtain its completion fence.
 while (!completion.ready()) { // Poll the completion fence from the context thread.
 std::this_thread:: // Allow other application work while processing remains in flight.
 yield(); // Allow other application work while processing remains in flight.