block_dispatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include "sdfg/codegen/dispatchers/node_dispatcher.h"
#include "sdfg/data_flow/library_node.h"
 
namespace sdfg {
namespace codegen {
 
class BlockDispatcher : public NodeDispatcher {
private:
    const structured_control_flow::Block& node_;
 
public:
    BlockDispatcher(
        LanguageExtension& language_extension,
        StructuredSDFG& sdfg,
        analysis::AnalysisManager& analysis_manager,
        structured_control_flow::Block& node,
        InstrumentationPlan& instrumentation_plan,
        ArgCapturePlan& arg_capture_plan
    );
 
    void dispatch_node(
        PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
    ) override;
};
 
class AssignmentDispatcher : public NodeDispatcher {
private:
    const structured_control_flow::AssignmentBlock& node_;
 
public:
    AssignmentDispatcher(
        LanguageExtension& language_extension,
        StructuredSDFG& sdfg,
        analysis::AnalysisManager& analysis_manager,
        structured_control_flow::AssignmentBlock& node,
        InstrumentationPlan& instrumentation_plan,
        ArgCapturePlan& arg_capture_plan
    );
 
    void dispatch_node(
        PrettyPrinter& main_stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory
    ) override;
};
 
class DataFlowDispatcher {
private:
    LanguageExtension& language_extension_;
    const Function& function_;
    const data_flow::DataFlowGraph& data_flow_graph_;
    const InstrumentationPlan& instrumentation_plan_;
 
    void dispatch_ref(PrettyPrinter& stream, const data_flow::Memlet& memlet);
 
    void dispatch_deref_src(PrettyPrinter& stream, const data_flow::Memlet& memlet);
 
    void dispatch_deref_dst(PrettyPrinter& stream, const data_flow::Memlet& memlet);
 
    void dispatch_tasklet(PrettyPrinter& stream, const data_flow::Tasklet& tasklet);
 
    void dispatch_library_node(
        PrettyPrinter& stream,
        PrettyPrinter& globals_stream,
        CodeSnippetFactory& library_snippet_factory,
        const data_flow::LibraryNode& libnode
    );
 
public:
    DataFlowDispatcher(
        LanguageExtension& language_extension,
        const Function& function,
        const data_flow::DataFlowGraph& data_flow_graph,
        const InstrumentationPlan& instrumentation_plan
    );
 
    void dispatch(PrettyPrinter& stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory);
};
 
struct CodegenOutput {
    PrettyPrinter& stream;
    PrettyPrinter& globals_stream;
    CodeSnippetFactory& library_snippet_factory;
    LanguageExtension& language_extension;
};

struct DispatchInput {
    const std::string expr;
    const data_flow::Memlet& edge;
    bool is_locally_modifiable;
 
    DispatchInput(std::string expr, const data_flow::Memlet& edge, bool is_locally_modifiable)
        : expr(std::move(expr)), edge(edge), is_locally_modifiable(is_locally_modifiable) {
    }
};
 
struct DispatchOutput {
    const std::string* local_name;
    std::unique_ptr<types::IType> out_type;
    bool used;
 
    DispatchOutput(const std::string* local_name, std::unique_ptr<types::IType> out_type, bool used)
        : local_name(local_name), out_type(std::move(out_type)), used(used) {
    }
};

class LibraryNodeDispatcher {
protected:
    LanguageExtension& language_extension_; 
    const Function& function_; 
    const data_flow::DataFlowGraph& data_flow_graph_; 
    const data_flow::LibraryNode& node_; 
 
public:
    LibraryNodeDispatcher(
        LanguageExtension& language_extension,
        const Function& function,
        const data_flow::DataFlowGraph& data_flow_graph,
        const data_flow::LibraryNode& node
    );
 
    virtual ~LibraryNodeDispatcher() = default;

    virtual bool begin_node(PrettyPrinter& stream) {
        return false;
    }

    virtual void end_node(PrettyPrinter& stream, bool has_declaration) {
    }

    virtual void
    dispatch(PrettyPrinter& stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory);

    virtual void
    dispatch_code(PrettyPrinter& stream, PrettyPrinter& globals_stream, CodeSnippetFactory& library_snippet_factory) {
    }
 
    virtual void dispatch_code_with_edges(
        CodegenOutput& out, std::vector<DispatchInput>& inputs, std::vector<DispatchOutput>& outputs
    );

    virtual InstrumentationInfo instrumentation_info() const;
 
protected:
    void require_locally_modifiable_var(CodegenOutput& out, DispatchInput& input) const;

    void pre_allocate_output(CodegenOutput& out, DispatchOutput& output, const std::string& var_name) const;

    void register_output(DispatchOutput& output, const std::string& result_identifier) const;

    void copy_output(CodegenOutput& out, const DispatchOutput& output, const data_flow::Memlet& oedge) const;
};
 
} // namespace codegen
} // namespace sdfg