reduce.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "sdfg/structured_control_flow/control_flow_node.h"
#include "sdfg/structured_control_flow/sequence.h"
#include "sdfg/structured_control_flow/structured_loop.h"
#include "sdfg/symbolic/symbolic.h"
 
namespace sdfg {
 
namespace builder {
class StructuredSDFGBuilder;
}
namespace structured_control_flow {

enum class ReductionOperation { Add, Mul, Min, Max };

std::string reduction_operation_to_string(ReductionOperation op);

ReductionOperation reduction_operation_from_string(const std::string& value);

enum class RescaleBase { E, Two };
 
std::string rescale_base_to_string(RescaleBase base);

RescaleBase rescale_base_from_string(const std::string& value);

struct ReductionInfo {
    ReductionOperation operation;
    std::string container;
    symbolic::Expression original_index = SymEngine::null;
    // Anchor (`Max`) container this `Add` is relative to; empty for a plain reduction.
    std::string rescale = "";
    RescaleBase rescale_base = RescaleBase::E;
};

class Reduce : public StructuredLoop {
    friend class sdfg::builder::StructuredSDFGBuilder;
 
private:
    std::vector<ReductionInfo> reductions_;
 
    Reduce(
        size_t element_id,
        const DebugInfo& debug_info,
        ControlFlowNode* parent,
        symbolic::Symbol indvar,
        symbolic::Expression init,
        symbolic::Expression update,
        symbolic::Condition condition,
        std::vector<ReductionInfo> reductions,
        const ScheduleType& schedule_type
    );
 
    static constexpr size_t REQUIRED_ELEMENT_IDS = StructuredLoop::REQUIRED_ELEMENT_IDS;
 
public:
    Reduce(const Reduce& node) = delete;
    Reduce& operator=(const Reduce&) = delete;
 
    ElementType type_id() const override {
        return ElementType::Reduce;
    }
 
    static bool classof(const Element& element) {
        return element.type_id() == ElementType::Reduce;
    }
 
    bool accept(visitor::ActualStructuredSDFGVisitor& visitor) override;
 
    void validate(const Function& function) const override;
 
    void replace(const symbolic::Expression old_expression, const symbolic::Expression new_expression) override;
 
    void replace(const symbolic::ExpressionMapping& replacements) override;

    const std::vector<ReductionInfo>& reductions() const;

    void replace_reduction_container(const std::string& old_name, const std::string& new_name);
 
    void original_index(const std::string& container, symbolic::Expression index);
};
 
} // namespace structured_control_flow
} // namespace sdfg