pointer_metadata.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <nlohmann/json.hpp>
#include <optional>
 
#include "sdfg/data_flow/library_nodes/math/tensor/tensor_layout.h"
#include "sdfg/symbolic/symbolic.h"
#include "symengine/subs.h"
 
namespace sdfg::data_flow {
 
class PointerAccessMeta;
class MemoryAccessPattern;
 
template<typename T>
struct PtrMetaDeleter {
    bool should_delete_;
 
    PtrMetaDeleter(bool should_delete = true) : should_delete_(should_delete) {
    }
 
    void operator()(T* ptr) const {
        if (should_delete_) {
            delete ptr;
        }
    }
};
 
typedef PtrMetaDeleter<PointerAccessMeta> PtrAccessDeleter;
typedef PtrMetaDeleter<MemoryAccessPattern> AccessPatternsDeleter;
typedef std::unique_ptr<PointerAccessMeta, PtrAccessDeleter> PointerAccessType;
typedef std::unique_ptr<MemoryAccessPattern, AccessPatternsDeleter> MemoryAccessPatternType;
 
class MemoryAccessPattern {
public:
    virtual ~MemoryAccessPattern() = default;

    virtual bool empty() const = 0;

    virtual bool every_element_accessed() const = 0;

    virtual const math::tensor::TensorLayout* layout() const {
        return nullptr;
    }
 
    MemoryAccessPatternType ref() const;
 
    virtual void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) = 0;
    virtual void replace(const symbolic::ExpressionMapping& replacements) = 0;
 
    virtual MemoryAccessPatternType clone() const = 0;
 
    virtual void serialize_to_json(nlohmann::json& entry) = 0;
};
 
class ConvexAccessPattern : public MemoryAccessPattern {
private:
    symbolic::Expression size_;
    bool not_sparse_ = false;
 
public:
    ConvexAccessPattern(symbolic::Expression size, bool not_sparse = false) : size_(size), not_sparse_(not_sparse) {
    }
 
    symbolic::Expression size() const {
        return size_;
    }
 
    bool empty() const override {
        return symbolic::null_safe_eq(size_, symbolic::zero());
    }
 
    bool every_element_accessed() const override {
        return not_sparse_;
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override {
        size_ = symbolic::subs(size_, old_expression, new_expression);
    }
    void replace(const symbolic::ExpressionMapping& replacements) override {
        size_ = SymEngine::subs(size_, replacements);
    }
 
    MemoryAccessPatternType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
 
    static MemoryAccessPatternType create(symbolic::Expression size, bool not_sparse = false);
};
 
class NoAccessPattern : public MemoryAccessPattern {
private:
    NoAccessPattern() {
    }
 
public:
    bool empty() const override {
        return true;
    }
 
    bool every_element_accessed() const override {
        return true;
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override {
    }
    void replace(const symbolic::ExpressionMapping& replacements) override {
    }
 
    static MemoryAccessPatternType instance();
 
    void serialize_to_json(nlohmann::json& entry) override;
 
    MemoryAccessPatternType clone() const override;
};

class TensorLayoutPattern : public MemoryAccessPattern {
private:
    math::tensor::TensorLayout layout_;
    bool not_sparse_ = false;
 
public:
    TensorLayoutPattern(math::tensor::TensorLayout layout, bool not_sparse = false)
        : layout_(std::move(layout)), not_sparse_(not_sparse) {
    }
 
    bool empty() const override {
        return symbolic::null_safe_eq(layout_.total_elements(), symbolic::zero());
    }
 
    bool every_element_accessed() const override {
        return not_sparse_;
    }
 
    const math::tensor::TensorLayout* layout() const override {
        return &layout_;
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override {
        layout_.replace_symbols(old_expression, new_expression);
    }
    void replace(const symbolic::ExpressionMapping& replacements) override {
        layout_.replace_symbols(replacements);
    }
 
    MemoryAccessPatternType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
 
    static MemoryAccessPatternType create(math::tensor::TensorLayout layout, bool not_sparse = false);
};
 
class PointerAccessMeta {
protected:
    PointerAccessMeta() = default;
 
public:
    virtual ~PointerAccessMeta() = default;

    virtual bool no_capture() const = 0;

    virtual bool may_contain_reads() const = 0;

    virtual bool may_contain_writes() const = 0;
 
    virtual bool invalidated_after() const = 0;

    virtual MemoryAccessPatternType access_read_pattern() const = 0;
    virtual MemoryAccessPatternType access_write_pattern() const = 0;
 
    PointerAccessType ref() const;
 
    virtual void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) = 0;
    virtual void replace(const symbolic::ExpressionMapping& replacements) = 0;
 
    virtual PointerAccessType clone() const = 0;
 
    virtual void serialize_to_json(nlohmann::json& entry) = 0;
 
    static PointerAccessType create_read_only(
        const symbolic::Expression& size,
        bool no_capture,
        std::optional<math::tensor::TensorLayout> layout = std::nullopt,
        bool every_element_read = false
    );
    static PointerAccessType create_invalidate();
    static PointerAccessType create_full_write_only(
        const symbolic::Expression& size,
        bool no_capture,
        std::optional<math::tensor::TensorLayout> layout = std::nullopt
    );
    static PointerAccessType
    create_generic(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture);
};
 

class PointerReadOnly : public PointerAccessMeta {
private:
    MemoryAccessPatternType read_pattern_;
    bool no_capture_;
 
public:
    PointerReadOnly(MemoryAccessPatternType read_pattern, bool no_capture = false);

    bool no_capture() const override {
        return no_capture_;
    }
 
    bool may_contain_reads() const override {
        return true;
    }
    bool may_contain_writes() const override {
        return false;
    }
 
    bool invalidated_after() const override {
        return false;
    }

    MemoryAccessPatternType access_read_pattern() const override;
 
    MemoryAccessPatternType access_write_pattern() const override;
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
    void replace(const symbolic::ExpressionMapping& replacements) override;
 
    PointerAccessType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
};

class PointerFullWriteOnly : public PointerAccessMeta {
private:
    MemoryAccessPatternType write_pattern_;
    bool no_capture_;
 
public:
    PointerFullWriteOnly(MemoryAccessPatternType write_pattern, bool no_capture = false);

    MemoryAccessPatternType access_write_pattern() const override;
 
    MemoryAccessPatternType access_read_pattern() const override;
 
    bool no_capture() const override {
        return no_capture_;
    }
 
    bool may_contain_reads() const override {
        return false;
    }
    bool may_contain_writes() const override {
        return true;
    }
 
    bool invalidated_after() const override {
        return false;
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
    void replace(const symbolic::ExpressionMapping& replacements) override;
 
    PointerAccessType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
};

class PointerGenericAccess : public PointerAccessMeta {
private:
    MemoryAccessPatternType read_pattern_;
    MemoryAccessPatternType write_pattern_;
    bool no_capture_;
 
public:
    PointerGenericAccess(MemoryAccessPatternType read_pattern, MemoryAccessPatternType write_pattern, bool no_capture);

    MemoryAccessPatternType access_read_pattern() const override;
    MemoryAccessPatternType access_write_pattern() const override;
 
    bool no_capture() const override {
        return no_capture_;
    }
 
    bool may_contain_reads() const override;
 
    bool may_contain_writes() const override;
 
    bool invalidated_after() const override {
        return false;
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
    void replace(const symbolic::ExpressionMapping& replacements) override;
 
    PointerAccessType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
};

class PointerInvalidate : public PointerAccessMeta {
public:
    bool no_capture() const override {
        return true;
    }
 
    bool may_contain_reads() const override {
        return false;
    }
    bool may_contain_writes() const override {
        return false;
    }
 
    bool invalidated_after() const override {
        return true;
    }
 
    MemoryAccessPatternType access_read_pattern() const override {
        return NoAccessPattern::instance();
    }
    MemoryAccessPatternType access_write_pattern() const override {
        return NoAccessPattern::instance();
    }
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override {
    }
    void replace(const symbolic::ExpressionMapping& replacements) override {
    }
 
    PointerAccessType clone() const override;
 
    void serialize_to_json(nlohmann::json& entry) override;
};
 
class PointerAccessMetaSerializer {
    friend class PointerAccessMeta;
 
public:
    static std::vector<PointerAccessType> deserialize_list(nlohmann::json::const_reference list);
    static std::vector<PointerAccessType>
    deserialize_list(nlohmann::json::const_iterator key, const nlohmann::json& parent);
 
    static PointerAccessType deserialize_read_only(nlohmann::json::const_reference entry);
    static PointerAccessType deserialize_write_only(nlohmann::json::const_reference entry);
    static PointerAccessType deserialize_generic(nlohmann::json::const_reference entry);
 
    static MemoryAccessPatternType deserialize_convex_pattern(nlohmann::json::const_reference entry);
    static MemoryAccessPatternType deserialize_tensor_layout_pattern(nlohmann::json::const_reference entry);
    static MemoryAccessPatternType deserialize_access_pattern(nlohmann::json::const_reference entry);
 
    static nlohmann::json serialize(const std::vector<PointerAccessType>& vector);
 
    static PointerAccessType deserialize(const nlohmann::json& entry);
};
 
 
} // namespace sdfg::data_flow