Expr in ArrayNode

yzhliu · August 24, 2018, 7:35am

I got trouble with passing [...] to tvm.call_extern, it will fail with
TVMError: [07:24:03] /work1/yizhiliu/tvm/include/tvm/./packed_func_ext.h:123: Check failed: NodeTypeChecker<TNodeRef>::Check(sptr.get()) Expected type array<Expr> but get Array

Not sure whether my understanding is correct @tqchen . and wondering how to make it work.

Values inside a list are converted to Node because _Array constructs ArrayNode, which requires Node inside:

github.com

dmlc/tvm/blob/master/python/tvm/_ffi/node_generic.py#L47


if isinstance(value, _CLASS_NODE_BASE):
    return value
elif isinstance(value, bool):
    return const(value, 'uint1x1')
elif isinstance(value, Number):
    return const(value)
elif isinstance(value, string_types):
    return _api_internal._str(value)
elif isinstance(value, (list, tuple)):
    value = [convert_to_node(x) for x in value]
    return _api_internal._Array(*value)
elif isinstance(value, dict):
    vlist = []
    for item in value.items():
        if (not isinstance(item[0], _CLASS_NODE_BASE) and
                not isinstance(item[0], string_types)):
            raise ValueError("key of map must already been a container type")
        vlist.append(item[0])
        vlist.append(convert_to_node(item[1]))
    return _api_internal._Map(*vlist)
elif isinstance(value, NodeGeneric):

github.com

dmlc/tvm/blob/master/src/api/api_lang.cc#L50


TVM_REGISTER_API("_str")
.set_body([](TVMArgs args,  TVMRetValue* ret) {
*ret = ir::StringImm::make(args[0]);
});




TVM_REGISTER_API("_Array")
.set_body([](TVMArgs args,  TVMRetValue* ret) {
  std::vector<std::shared_ptr<Node> > data;
  for (int i = 0; i < args.size(); ++i) {
    data.push_back(args[i].node_sptr());
  }
  auto node = std::make_shared<ArrayNode>();
  node->data = std::move(data);
  *ret = node;
});


TVM_REGISTER_API("_ArrayGetItem")
.set_body([](TVMArgs args,  TVMRetValue* ret) {
  int64_t i = args[1];
  auto& sptr = args[0].node_sptr();

While make.Call requires Array<Expr>:

github.com

dmlc/tvm/blob/master/src/api/api_ir.cc#L73


                       args[1],
                       args[2],
                       args[3],
                       args[4],
                       args[5]);
});




TVM_REGISTER_API("make.Call")
.set_body([](TVMArgs args,  TVMRetValue *ret) {
  *ret = Call::make(args[0],
                    args[1],
                    args[2],
                    static_cast<Call::CallType>(args[3].operator int()),
                    args[4],
                    args[5]);
});


TVM_REGISTER_API("make.CommReducer")
.set_body([](TVMArgs args, TVMRetValue *ret) {
  *ret = CommReducerNode::make(args[0],

github.com

dmlc/HalideIR/blob/6f64f7866747a2a81bec84aea9bde0479c5b72c1/src/ir/IR.cpp#L458


}


Stmt Evaluate::make(Expr v) {
internal_assert(v.defined()) << "Evaluate of undefined\n";


std::shared_ptr<Evaluate> node = std::make_shared<Evaluate>();
node->value = v;
return Stmt(node);
}


Expr Call::make(Type type, std::string name, Array<Expr> args, CallType call_type,
            FunctionRef func, int value_index) {
for (size_t i = 0; i < args.size(); i++) {
    internal_assert(args[i].defined()) << "Call of undefined\n";
}
if (call_type == Halide) {
    for (size_t i = 0; i < args.size(); i++) {
        internal_assert(args[i].type() == Int(32))
        << "Args to call to halide function must be type Int(32)\n";
    }
}

Thus fails the type-checker between (type-erased) Node and Expr:

github.com

dmlc/tvm/blob/master/include/tvm/packed_func_ext.h#L52


}
};


template<typename T>
struct NodeTypeChecker<Array<T> > {
static inline bool Check(Node* sptr) {
  if (sptr == nullptr) return false;
  if (!sptr->is_type<ArrayNode>()) return false;
  ArrayNode* n = static_cast<ArrayNode*>(sptr);
  for (const auto& p : n->data) {
    if (!NodeTypeChecker<T>::Check(p.get())) return false;
  }
  return true;
}
static inline void PrintName(std::ostringstream& os) { // NOLINT(*)
  os << "array<";
  NodeTypeChecker<T>::PrintName(os);
  os << ">";
}
};

tqchen · August 24, 2018, 4:34pm

Call extern expects arguments in unpacked form. Call it with positional args instead of packing them to arrays

yzhliu · August 24, 2018, 4:44pm

but what if I want to pass a shape? the ndim can vary

tqchen · August 24, 2018, 4:51pm

This is unfortunately the restriction of the extern function(since we essentially only support C calls), we can however, pass in the pointer of shape and length as two arguments.

westion717 · February 8, 2020, 1:06pm

How to pass the pointer of shape? Could you please give some code to show it? Thanks.