tile.h

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <string>
#include <vector>
 
#include "sdfg/structured_control_flow/structured_loop.h"
#include "sdfg/tiles/layout.h"
 
namespace sdfg {
namespace analysis {
class AnalysisManager;
}
namespace tiles {
 
class LocalityPlan; // produced by Tile::placement, see locality.h


enum class Level { Device, Group, Subgroup };

enum class Space { Global, Shared, Register };

enum class Role { Private, Cooperative };

class AxisSchedule {
    Level level_ = Level::Device;
    Space space_ = Space::Global; 
    bool has_scratchpad_ = false; 
    unsigned spatial_axis_ = 0; 
    symbolic::Integer parallel_size_ = symbolic::integer(0); 
    bool needs_sync_ = false;
    symbolic::Integer lanes_ = symbolic::integer(1); 
 
public:
    AxisSchedule() = default;
    AxisSchedule(
        Level level,
        Space space,
        bool has_scratchpad,
        unsigned spatial_axis = 0,
        symbolic::Integer parallel_size = symbolic::integer(0),
        bool needs_sync = false,
        symbolic::Integer lanes = symbolic::integer(1)
    );

    static std::optional<AxisSchedule> classify(const structured_control_flow::ScheduleType& sched);

    static std::optional<Level> classify_level(const structured_control_flow::ScheduleType& sched);

    static bool drives_cooperative_copy(const structured_control_flow::ScheduleType& sched);
 
    bool has_scratchpad() const {
        return has_scratchpad_;
    }
    Level level() const {
        return level_;
    }
    Space space() const {
        return space_;
    }
    unsigned spatial_axis() const {
        return spatial_axis_;
    }
    const symbolic::Integer& parallel_size() const {
        return parallel_size_;
    }
    bool needs_sync() const {
        return needs_sync_;
    }
    const symbolic::Integer& lanes() const {
        return lanes_;
    }
};

class TileAxis {
    symbolic::Symbol indvar_;
    Role role_ = Role::Private;
    AxisSchedule schedule_;
    symbolic::Expression init_ = symbolic::integer(0);
    symbolic::Integer stride_ = symbolic::integer(1);
 
public:
    TileAxis() = default;
    TileAxis(
        symbolic::Symbol indvar,
        Role role,
        AxisSchedule schedule,
        symbolic::Expression init = symbolic::integer(0),
        symbolic::Integer stride = symbolic::integer(1)
    );

    static std::vector<TileAxis> enclosing(
        structured_control_flow::StructuredLoop& loop,
        const symbolic::MultiExpression& bases,
        const symbolic::Expression& offset = symbolic::integer(0)
    );
 
    const symbolic::Symbol& indvar() const {
        return indvar_;
    }
    Role role() const {
        return role_;
    }
    const AxisSchedule& schedule() const {
        return schedule_;
    }
    const symbolic::Expression& init() const {
        return init_;
    }
    const symbolic::Integer& stride() const {
        return stride_;
    }
    bool cooperative() const {
        return role_ == Role::Cooperative;
    }
};

class Tile {
    std::string container_;
    Layout source_{symbolic::MultiExpression{}};
    std::vector<TileAxis> axes_; 
    bool reads_ = false;
    bool writes_ = false;
 
public:
    Tile() = default;
    Tile(std::string container, Layout source, std::vector<TileAxis> axes, bool reads, bool writes);
 
    const std::string& container() const {
        return container_;
    }
    const Layout& source() const {
        return source_;
    }
    const std::vector<TileAxis>& axes() const {
        return axes_;
    }
    bool reads() const {
        return reads_;
    }
    bool writes() const {
        return writes_;
    }
 
    bool cooperative() const;
    std::vector<TileAxis> cooperative_axes() const;
    std::vector<TileAxis> private_axes() const;

    Space required_space() const;

    LocalityPlan placement(structured_control_flow::StructuredLoop& loop, analysis::AnalysisManager& analysis_manager) const;
};
 
} // namespace tiles
} // namespace sdfg