library_node.h

Go to the documentation of this file.

 
#pragma once
 
#include <optional>
#include <string>
#include <vector>
 
#include "sdfg/data_flow/code_node.h"
#include "sdfg/data_flow/pointer_metadata.h"
#include "sdfg/graph/graph.h"
#include "sdfg/symbolic/symbolic.h"
 
namespace sdfg {
 
namespace builder {
class SDFGBuilder;
class StructuredSDFGBuilder;
} // namespace builder
 
namespace data_flow {
 
typedef StringEnum LibraryNodeCode;

typedef StringEnum ImplementationType;

inline ImplementationType ImplementationType_NONE{""};

struct SubgroupAccess {
    std::vector<std::vector<std::vector<int64_t>>> lanes;
};

class LibraryNode : public CodeNode {
    friend class sdfg::builder::SDFGBuilder;
    friend class sdfg::builder::StructuredSDFGBuilder;
 
protected:
    LibraryNodeCode code_; 
    bool side_effect_; 
 
    ImplementationType implementation_type_; 

    LibraryNode(
        size_t element_id,
        const DebugInfo& debug_info,
        const graph::Vertex vertex,
        DataFlowGraph& parent,
        const LibraryNodeCode& code,
        const std::vector<std::string>& outputs,
        const std::vector<std::string>& inputs,
        const bool side_effect,
        const ImplementationType& implementation_type
    );
 
public:
    LibraryNode(const LibraryNode& data_node) = delete;
    LibraryNode& operator=(const LibraryNode&) = delete;
 
    virtual ~LibraryNode() = default;
 
    ElementType type_id() const override {
        return ElementType::LibraryNode;
    }
 
    static bool classof(const Element& element) {
        return element.type_id() == ElementType::LibraryNode;
    }

    const LibraryNodeCode& code() const;

    const ImplementationType& implementation_type() const;

    [[deprecated("use set_implementationtype(impl_type)")]]
    ImplementationType& implementation_type();
 
    void set_implementation_type(const ImplementationType& impl_type);

    [[nodiscard]] bool side_effect() const override;

    virtual std::string toStr() const;

    virtual symbolic::SymbolSet symbols() const = 0;

    virtual symbolic::Expression flop() const;

    virtual PointerAccessType pointer_access_type(int input_idx) const {
        return nullptr;
    }
 
    PointerAccessType pointer_access_type(const Memlet& edge) const;

    virtual bool relocalize_operand(int input_idx, const math::tensor::TensorLayout& packed) {
        return false;
    }

    virtual bool can_relocalize_operand(int input_idx, const math::tensor::TensorLayout& packed) const {
        return false;
    }

    virtual std::optional<SubgroupAccess> operand_access(int input_idx, unsigned subgroup_size) const {
        return std::nullopt;
    }
    EdgeRemoveOption can_remove_out_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const override;
 
    EdgeRemoveOption can_remove_in_edge(const data_flow::DataFlowGraph& graph, const Memlet* memlet) const override;
 
    bool pointer_use_creates_side_effects(const DataFlowGraph& dataflow, const Function& func);
};
 
} // namespace data_flow
} // namespace sdfg