kernel_builder.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "sdfg/builder/structured_sdfg_builder.h"
#include "sdfg/data_flow/access_node.h"
#include "sdfg/data_flow/library_nodes/math/cmath/cmath_node.h"
#include "sdfg/data_flow/tasklet.h"
#include "sdfg/structured_control_flow/block.h"
#include "sdfg/structured_control_flow/reduce.h"
#include "sdfg/structured_control_flow/sequence.h"
#include "sdfg/structured_control_flow/structured_loop.h"
#include "sdfg/types/type.h"
 
namespace sdfg {
namespace fp_math {

struct KernelValue {
    data_flow::AccessNode* node = nullptr;
    data_flow::Subset subset;
    std::shared_ptr<types::IType> base_type;
};

class BlockBuilder {
private:
    builder::StructuredSDFGBuilder& builder_;
    structured_control_flow::Block& block_;
    DebugInfo debug_info_;
 
    KernelValue result(types::PrimitiveType type);
    void connect(const KernelValue& value, data_flow::CodeNode& node, const std::string& connector);
 
public:
    BlockBuilder(builder::StructuredSDFGBuilder& builder, structured_control_flow::Block& block, DebugInfo debug_info);
 
    structured_control_flow::Block& block() {
        return block_;
    }

    KernelValue read(data_flow::AccessNode& node, const data_flow::Subset& subset, const types::IType& base_type);

    KernelValue read(const std::string& container, const data_flow::Subset& subset = {});
 
    KernelValue constant(double value, types::PrimitiveType type);

    KernelValue convert(const KernelValue& value, types::PrimitiveType type);
 
    KernelValue op(data_flow::TaskletCode code, const std::vector<KernelValue>& inputs, types::PrimitiveType type);
 
    KernelValue
    cmath(math::cmath::CMathFunction function, const std::vector<KernelValue>& inputs, types::PrimitiveType type);

    void store(
        const KernelValue& value,
        data_flow::AccessNode& node,
        const data_flow::Subset& subset,
        const types::IType& base_type
    );

    void store(const KernelValue& value, const std::string& container, const data_flow::Subset& subset = {});
};

class KernelBuilder {
private:
    builder::StructuredSDFGBuilder& builder_;
    structured_control_flow::Sequence& scope_;
    DebugInfo debug_info_;
    std::vector<std::string> buffers_;
 
public:
    KernelBuilder(builder::StructuredSDFGBuilder& builder, structured_control_flow::Sequence& scope, DebugInfo debug_info);
 
    builder::StructuredSDFGBuilder& builder() {
        return builder_;
    }
 
    structured_control_flow::Sequence& scope() {
        return scope_;
    }
 
    const DebugInfo& debug_info() const {
        return debug_info_;
    }

    std::string scalar(const std::string& prefix, types::PrimitiveType type);

    std::string buffer(const std::string& prefix, types::PrimitiveType type, const symbolic::Expression& count);

    structured_control_flow::StructuredLoop&
    map(structured_control_flow::Sequence& scope, const std::string& prefix, const symbolic::Expression& bound);

    structured_control_flow::StructuredLoop&
    for_loop(structured_control_flow::Sequence& scope, const std::string& prefix, const symbolic::Expression& bound);

    structured_control_flow::StructuredLoop& reduce(
        structured_control_flow::Sequence& scope,
        const std::string& prefix,
        const symbolic::Expression& bound,
        structured_control_flow::ReductionOperation operation,
        const std::string& accumulator
    );
 
    BlockBuilder block(structured_control_flow::Sequence& scope);

    void finish();
};
 
} // namespace fp_math
} // namespace sdfg