gpu_reduce_dispatcher.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "sdfg/analysis/analysis.h"
#include "sdfg/codegen/dispatchers/node_dispatcher.h"
#include "sdfg/codegen/instrumentation/instrumentation_info.h"
#include "sdfg/codegen/language_extension.h"
#include "sdfg/codegen/utils.h"
#include "sdfg/structured_control_flow/reduce.h"
#include "sdfg/symbolic/symbolic.h"
#include "sdfg/targets/gpu/gpu_types.h"
#include "sdfg/types/type.h"
 
namespace sdfg {
namespace gpu {

class GPUReduceDispatcher : public codegen::NodeDispatcher {
protected:
    structured_control_flow::Reduce& node_;
 
    // --- Backend policy hooks -------------------------------------------------

    virtual std::string schedule_value() const = 0;

    virtual codegen::TargetType target_type() const = 0;

    virtual std::unique_ptr<codegen::LanguageExtension> create_device_language_extension() const = 0;

    virtual bool is_device_pointer_storage(const types::StorageType& storage) const = 0;

    virtual std::string kernel_file_extension() const = 0;

    virtual void emit_kernel_includes(codegen::CodeSnippetFactory& library_snippet_factory) const = 0;

    virtual void emit_library_preamble(codegen::PrettyPrinter& library_stream) const = 0;

    virtual void emit_kernel_call(
        codegen::PrettyPrinter& main_stream,
        const std::string& kernel_name,
        symbolic::Expression& num_blocks,
        symbolic::Expression& block_size,
        std::vector<std::string>& arguments_device
    ) = 0;
 
    // --- Shared implementation ------------------------------------------------

    bool is_nested_in_gpu_kernel();
 
    void dispatch_header(
        codegen::PrettyPrinter& stream, const std::string& kernel_name, std::vector<std::string>& arguments_declaration
    );

    void dispatch_reduce_core(
        codegen::CodeSnippetFactory& library_snippet_factory,
        codegen::PrettyPrinter& library_stream,
        GPUDimension dimension,
        bool declare_scope_variables,
        std::vector<std::string>& scope_variables
    );

    void dispatch_atomic_merge(
        codegen::PrettyPrinter& library_stream,
        codegen::CodeSnippetFactory& library_snippet_factory,
        const structured_control_flow::ReductionInfo& reduction
    );
 
public:
    GPUReduceDispatcher(
        codegen::LanguageExtension& language_extension,
        StructuredSDFG& sdfg,
        analysis::AnalysisManager& analysis_manager,
        structured_control_flow::Reduce& node,
        codegen::InstrumentationPlan& instrumentation_plan,
        codegen::ArgCapturePlan& arg_capture_plan
    );
 
    void dispatch_node(
        codegen::PrettyPrinter& main_stream,
        codegen::PrettyPrinter& globals_stream,
        codegen::CodeSnippetFactory& library_snippet_factory
    ) override;
 
    codegen::InstrumentationInfo instrumentation_info() const override;
};
 
} // namespace gpu
} // namespace sdfg