tile_analysis.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "sdfg/analysis/analysis.h"
#include "sdfg/analysis/memory_layout_analysis.h"
#include "sdfg/structured_control_flow/control_flow_node.h"
#include "sdfg/structured_control_flow/structured_loop.h"
#include "sdfg/tiles/tile.h"
 
namespace sdfg {
namespace tiles {

class TileAnalysis : public analysis::Analysis {
private:
    mutable std::map<std::pair<const structured_control_flow::ControlFlowNode*, std::string>, std::optional<tiles::Tile>>
        tiles_;

    analysis::AnalysisManager* analysis_manager_ = nullptr;

    std::optional<tiles::Tile>
    compute_tile(const structured_control_flow::ControlFlowNode& scope, const std::string& container) const;
 
protected:
    void run(analysis::AnalysisManager& analysis_manager) override;
 
public:
    TileAnalysis(StructuredSDFG& sdfg);
 
    std::string name() const override {
        return "TileAnalysis";
    }

    const tiles::Tile* tile(const structured_control_flow::ControlFlowNode& scope, const std::string& container) const;

    struct AccessSummary {
        bool reads = false; 
        bool writes = false; 
        bool aliased = false; 
    };

    static AccessSummary
    summarize(const StructuredSDFG& sdfg, structured_control_flow::StructuredLoop& loop, const std::string& container);
};

bool is_constant_bounded(const analysis::MemoryTileGroup* group);

const std::vector<analysis::MemoryTileGroup>* tile_groups(
    structured_control_flow::StructuredLoop& loop,
    const std::string& container,
    analysis::AnalysisManager& analysis_manager
);

symbolic::Expression tile_element_count(const analysis::MemoryTileGroup* group);

const analysis::MemoryTileGroup* localizable_tile(
    structured_control_flow::StructuredLoop& loop,
    const std::string& container,
    analysis::AnalysisManager& analysis_manager
);
 
} // namespace tiles
} // namespace sdfg