software_pipelining.h

Go to the documentation of this file.

#pragma once
 
#include <set>
#include <string>
#include <vector>
 
#include "sdfg/transformations/transformation.h"
 
namespace sdfg {
class Function;
namespace structured_control_flow {
class ControlFlowNode;
class StructuredLoop;
} // namespace structured_control_flow
namespace transformations {

class SoftwarePipelining : public Transformation {
    structured_control_flow::StructuredLoop& loop_;
    size_t stages_;
    // When the loop stages two operands and shared memory can only hold a
    // double buffer of one of them at the target occupancy, pipeline just the
    // first (name-ordered) operand and leave the rest single-buffered +
    // synchronous. This keeps occupancy (fewer shared bytes) while still
    // overlapping the costlier operand's global load.
    bool single_operand_;
    // Register-staged mode: keep one shared buffer and split each staging copy into a
    // load into registers (issued for panel p+1 before compute p) and a store into the
    // buffer after compute p, fenced by barriers:
    //   prologue: copy panel 0; barrier
    //   for p: [p+1 < n: load p+1 -> regs]; compute p; barrier; [p+1 < n: regs -> buf]; barrier
    bool register_staged_;
 
public:
    explicit SoftwarePipelining(
        structured_control_flow::StructuredLoop& loop,
        size_t stages = 2,
        bool single_operand = false,
        bool register_staged = false
    );
 
    virtual std::string name() const override;

    static std::set<std::string>
    copied_in_buffers(const Function& function, structured_control_flow::ControlFlowNode& root);

    static std::vector<structured_control_flow::StructuredLoop*>
    staging_panels(const Function& function, structured_control_flow::ControlFlowNode& root);
 
    virtual bool
    can_be_applied(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) override;
 
    virtual void apply(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) override;
 
    virtual void to_json(nlohmann::json& j) const override;
 
    static SoftwarePipelining from_json(builder::StructuredSDFGBuilder& builder, const nlohmann::json& j);
};
 
} // namespace transformations
} // namespace sdfg