operation.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef TVM_TE_OPERATION_H_
#define TVM_TE_OPERATION_H_
 
#include <tvm/arith/analyzer.h>
#include <tvm/ffi/reflection/registry.h>
#include <tvm/te/tensor.h>
#include <tvm/tir/buffer.h>
#include <tvm/tir/expr.h>
#include <tvm/tir/op.h>
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace tvm {
namespace te {
 
struct TensorDom {
  // constructor
  explicit TensorDom(int ndim) : data(ndim) {}
  std::vector<std::vector<IntSet>> data;
};
 
class TVM_DLL OperationNode : public Object {
 public:
  std::string name;
  std::string tag;
  Map<String, ffi::Any> attrs;
  // virtual destructor.
  virtual ~OperationNode() {}
  virtual int num_outputs() const = 0;
  virtual DataType output_dtype(size_t i) const = 0;
  virtual Array<PrimExpr> output_shape(size_t i) const = 0;
  virtual Array<Tensor> InputTensors() const = 0;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<OperationNode>()
        .def_ro("name", &OperationNode::name)
        .def_ro("tag", &OperationNode::tag)
        .def_ro("attrs", &OperationNode::attrs);
  }
 
  static constexpr const char* _type_key = "te.Operation";
 
  TVM_DECLARE_BASE_OBJECT_INFO(OperationNode, Object);
};
 
class PlaceholderOpNode : public OperationNode {
 public:
  Array<PrimExpr> shape;
  DataType dtype;
  // override behavior.
  int num_outputs() const final;
  DataType output_dtype(size_t i) const final;
  Array<PrimExpr> output_shape(size_t i) const final;
  Array<Tensor> InputTensors() const final;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<PlaceholderOpNode>()
        .def_ro("shape", &PlaceholderOpNode::shape)
        .def_ro("dtype", &PlaceholderOpNode::dtype);
  }
 
  static constexpr const char* _type_key = "te.PlaceholderOp";
 
  TVM_DECLARE_BASE_OBJECT_INFO(PlaceholderOpNode, OperationNode);
};
 
class PlaceholderOp : public Operation {
 public:
  TVM_DLL PlaceholderOp(std::string name, Array<PrimExpr> shape, DataType dtype);
 
  TVM_DEFINE_OBJECT_REF_METHODS(PlaceholderOp, Operation, PlaceholderOpNode);
};
 
class TVM_DLL BaseComputeOpNode : public OperationNode {
 public:
  Array<IterVar> axis;
  Array<IterVar> reduce_axis;
  // override functions
  Array<PrimExpr> output_shape(size_t idx) const final;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<BaseComputeOpNode>()
        .def_ro("axis", &BaseComputeOpNode::axis)
        .def_ro("reduce_axis", &BaseComputeOpNode::reduce_axis);
  }
 
  static constexpr const char* _type_key = "te.BaseComputeOp";
 
  TVM_DECLARE_BASE_OBJECT_INFO(BaseComputeOpNode, OperationNode);
};
 
class TVM_DLL ComputeOpNode : public BaseComputeOpNode {
 public:
  Array<PrimExpr> body;
  ComputeOpNode() {}
  // override functions
  int num_outputs() const final;
  DataType output_dtype(size_t i) const final;
  Array<Tensor> InputTensors() const final;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<ComputeOpNode>().def_ro("body", &ComputeOpNode::body);
  }
 
  static constexpr const char* _type_key = "te.ComputeOp";
 
  TVM_DECLARE_FINAL_OBJECT_INFO(ComputeOpNode, BaseComputeOpNode);
};
 
class ComputeOp : public Operation {
 public:
  TVM_DLL ComputeOp(std::string name, std::string tag, Map<String, ffi::Any> attrs,
                    Array<IterVar> axis, Array<PrimExpr> body);
 
  TVM_DEFINE_OBJECT_REF_METHODS(ComputeOp, Operation, ComputeOpNode);
  TVM_DEFINE_OBJECT_REF_COW_METHOD(ComputeOpNode);
};
 
class ScanOpNode : public OperationNode {
 public:
  IterVar scan_axis;
  Array<Tensor> init;
  Array<Tensor> update;
  Array<Tensor> state_placeholder;
  Array<Tensor> inputs;
  Array<IterVar> spatial_axis_;
  ScanOpNode() {}
  // override behavior.
  int num_outputs() const final;
  DataType output_dtype(size_t i) const final;
  Array<PrimExpr> output_shape(size_t i) const final;
  Array<Tensor> InputTensors() const final;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<ScanOpNode>()
        .def_ro("scan_axis", &ScanOpNode::scan_axis)
        .def_ro("init", &ScanOpNode::init)
        .def_ro("update", &ScanOpNode::update)
        .def_ro("state_placeholder", &ScanOpNode::state_placeholder)
        .def_ro("inputs", &ScanOpNode::inputs)
        .def_ro("spatial_axis_", &ScanOpNode::spatial_axis_);
  }
 
  static constexpr const char* _type_key = "te.ScanOp";
 
  TVM_DECLARE_FINAL_OBJECT_INFO(ScanOpNode, OperationNode);
};
 
class ScanOp : public Operation {
 public:
  TVM_DLL ScanOp(std::string name, std::string tag, Optional<Map<String, ffi::Any>> attrs,
                 IterVar axis, Array<Tensor> init, Array<Tensor> update,
                 Array<Tensor> state_placeholder, Array<Tensor> input);
 
  TVM_DEFINE_OBJECT_REF_METHODS(ScanOp, Operation, ScanOpNode);
};
 
class ExternOpNode : public OperationNode {
 public:
  Array<Tensor> inputs;
  Array<Buffer> input_placeholders;
  Array<Buffer> output_placeholders;
  Stmt body;
 
  ExternOpNode() {}
  // override functions
  int num_outputs() const final;
  DataType output_dtype(size_t i) const final;
  Array<PrimExpr> output_shape(size_t i) const final;
  Array<Tensor> InputTensors() const final;
 
  static void RegisterReflection() {
    namespace refl = tvm::ffi::reflection;
    refl::ObjectDef<ExternOpNode>()
        .def_ro("inputs", &ExternOpNode::inputs)
        .def_ro("input_placeholders", &ExternOpNode::input_placeholders)
        .def_ro("output_placeholders", &ExternOpNode::output_placeholders)
        .def_ro("body", &ExternOpNode::body);
  }
 
  static constexpr const char* _type_key = "te.ExternOp";
 
  TVM_DECLARE_FINAL_OBJECT_INFO(ExternOpNode, OperationNode);
};
 
class ExternOp : public Operation {
 public:
  TVM_DLL ExternOp(std::string name, std::string tag, Map<String, ffi::Any> attrs,
                   Array<Tensor> inputs, Array<Buffer> input_placeholders,
                   Array<Buffer> output_placeholders, Stmt body);
 
  TVM_DEFINE_OBJECT_REF_METHODS(ExternOp, Operation, ExternOpNode);
};
 
TVM_DLL Var var(std::string name_hint, DataType t = DataType::Int(32));
 
TVM_DLL IterVar thread_axis(Range dom, std::string tag);
 
TVM_DLL IterVar reduce_axis(Range dom, std::string name = "rv");
 
using FCompute = std::function<PrimExpr(const Array<Var>& i)>;
 
using FBatchCompute = std::function<Array<PrimExpr>(const Array<Var>& i)>;
 
TVM_DLL Tensor placeholder(Array<PrimExpr> shape, DataType dtype = DataType::Float(32),
                           std::string name = "placeholder");
 
TVM_DLL Tensor compute(Array<PrimExpr> shape, FCompute fcompute, std::string name = "tensor",
                       std::string tag = "", Map<String, ffi::Any> attrs = {});
 
TVM_DLL Array<Tensor> compute(Array<PrimExpr> shape, FBatchCompute fcompute,
                              std::string name = "tensor", std::string tag = "",
                              Map<String, ffi::Any> attrs = {});
 
TVM_DLL Array<Tensor> scan(Array<Tensor> init, Array<Tensor> update,
                           Array<Tensor> state_placeholder, Array<Tensor> inputs = Array<Tensor>(),
                           std::string name = "scan", std::string tag = "",
                           Map<String, ffi::Any> attrs = {});
 
// same as compute, specialized for different fcompute function
inline Tensor compute(Array<PrimExpr> shape, std::function<PrimExpr(Var)> f,
                      std::string name = "tensor", std::string tag = "",
                      Map<String, ffi::Any> attrs = {}) {
  FCompute fc = [f](const Array<Var>& i) { return f(i[0]); };
  return compute(shape, fc, name, tag, attrs);
}
inline Tensor compute(Array<PrimExpr> shape, std::function<PrimExpr(Var, Var)> f,
                      std::string name = "tensor", std::string tag = "",
                      Map<String, ffi::Any> attrs = {}) {
  FCompute fc = [f](const Array<Var>& i) { return f(i[0], i[1]); };
  return compute(shape, fc, name, tag, attrs);
}
inline Tensor compute(Array<PrimExpr> shape, std::function<PrimExpr(Var, Var, Var)> f,
                      std::string name = "tensor", std::string tag = "",
                      Map<String, ffi::Any> attrs = {}) {
  FCompute fc = [f](const Array<Var>& i) { return f(i[0], i[1], i[2]); };
  return compute(shape, fc, name, tag, attrs);
}
inline Tensor compute(Array<PrimExpr> shape, std::function<PrimExpr(Var, Var, Var, Var)> f,
                      std::string name = "tensor", std::string tag = "",
                      Map<String, ffi::Any> attrs = {}) {
  FCompute fc = [f](const Array<Var>& i) { return f(i[0], i[1], i[2], i[3]); };
  return compute(shape, fc, name, tag, attrs);
}
 
// inline function.
inline const OperationNode* Operation::operator->() const {
  return static_cast<const OperationNode*>(get());
}
}  // namespace te
}  // namespace tvm
#endif  // TVM_TE_OPERATION_H_