Definition.h

Go to the documentation of this file.

#ifndef HALIDE_DEFINITION_H
#define HALIDE_DEFINITION_H
 
/** \file
 * Defines the internal representation of a halide function's definition and related classes
 */
 
#include "Expr.h"
#include "IntrusivePtr.h"
#include "Schedule.h"
 
#include <map>
 
namespace Halide {
 
namespace Internal {
struct DefinitionContents;
struct FunctionContents;
class ReductionDomain;
}  // namespace Internal
 
namespace Internal {
 
class IRVisitor;
class IRMutator;
struct Specialization;
 
/** A Function definition which can either represent a init or an update
 * definition. A function may have different definitions due to specialization,
 * which are stored in 'specializations' (Not possible from the front-end, but
 * some scheduling directives may potentially cause this divergence to occur).
 * Although init definition may have multiple values (RHS) per specialization, it
 * must have the same LHS (i.e. same pure dimension variables). The update
 * definition, on the other hand, may have different LHS/RHS per specialization.
 * Note that, while the Expr in LHS/RHS may be different across specializations,
 * they must have the same number of dimensions and the same pure dimensions.
 */
class Definition {
 
    IntrusivePtr<DefinitionContents> contents;
 
public:
    /** Construct a Definition from an existing DefinitionContents pointer. Must be non-null */
    explicit Definition(const IntrusivePtr<DefinitionContents> &);
 
    /** Construct a Definition with the supplied args, values, and reduction domain. */
    Definition(const std::vector<Expr> &args, const std::vector<Expr> &values,
               const ReductionDomain &rdom, bool is_init);
 
    /** Construct a Definition with deserialized data. */
    Definition(bool is_init, const Expr &predicate, const std::vector<Expr> &args, const std::vector<Expr> &values,
               const StageSchedule &schedule, const std::vector<Specialization> &specializations);
 
    /** Construct an undefined Definition object. */
    Definition();
 
    /** Return a copy of this Definition. */
    Definition get_copy() const;
 
    /** Equality of identity */
    bool same_as(const Definition &other) const {
        return contents.same_as(other.contents);
    }
 
    /** Definition objects are nullable. Does this definition exist? */
    bool defined() const;
 
    /** Is this an init definition; otherwise it's an update definition */
    bool is_init() const;
 
    /** Pass an IRVisitor through to all Exprs referenced in the
     * definition. */
    void accept(IRVisitor *) const;
 
    /** Pass an IRMutator through to all Exprs referenced in the
     * definition. */
    void mutate(IRMutator *);
 
    /** Get the default (no-specialization) arguments (left-hand-side) of the definition.
     *
     * Warning: Any Vars in the Exprs are not qualified with the Func name, so
     * the Exprs may contain names which collide with names provided by
     * unique_name.
     */
    // @{
    const std::vector<Expr> &args() const;
    std::vector<Expr> &args();
    // @}
 
    /** Get the default (no-specialization) right-hand-side of the definition.
     *
     * Warning: Any Vars in the Exprs are not qualified with the Func name, so
     * the Exprs may contain names which collide with names provided by
     * unique_name.
     */
    // @{
    const std::vector<Expr> &values() const;
    std::vector<Expr> &values();
    // @}
 
    /** Get the predicate on the definition */
    // @{
    const Expr &predicate() const;
    Expr &predicate();
    // @}
 
    /** Split predicate into vector of ANDs. If there is no predicate (i.e. this
     * definition is always valid), this returns an empty vector. */
    std::vector<Expr> split_predicate() const;
 
    /** Get the default (no-specialization) stage-specific schedule associated
     * with this definition. */
    // @{
    const StageSchedule &schedule() const;
    StageSchedule &schedule();
    // @}
 
    /** You may create several specialized versions of a func with
     * different stage-specific schedules. They trigger when the condition is
     * true. See \ref Func::specialize */
    // @{
    const std::vector<Specialization> &specializations() const;
    std::vector<Specialization> &specializations();
    const Specialization &add_specialization(Expr condition);
    // @}
};
 
struct Specialization {
    Expr condition;
    Definition definition;
    std::string failure_message;  // If non-empty, this specialization always assert-fails with this message.
};
 
}  // namespace Internal
}  // namespace Halide
 
#endif