[Draft][Unity] Allow dynamic indices to TupleGetItem #16002

TVM containers, such as tvm::runtime::Array, require the contained objects to inherit from `ObjectRef`. As a result, the wrapper types `IntImm`, `FloatImm`, and `StringImm` are often used to allow native types in the TVM containers. Conversions into these wrapper type may be required when using a container, and may be performed automatically when passing an object across the FFI. By also providing conversion to an unwrapped type, these automatic conversions are transparent become transparent to users. The trait can be specialized to add type specific conversion logic from the TVMArgvalue and TVMRetValue.

Because `isinstance(bool_value, int)` returns True, boolean values were being converted to `T.int64`, instead of to `T.bool`.

… parameter" This reverts commit 61f6322.

Prior to this commit, the `Array::Map` member function could only be applied to nullable object types. This was due to the internal use of `U()` as the default value for initializing the output `ArrayNode`, where `U` is the return type of the mapping function. This default constructor is only available for nullable types, and would result in a compile-time failure for non-nullable types. This commit replaces `U()` with `ObjectRef()` in `Array::Map`, removing this limitation. Since all items in the output array are overwritten before returning to the calling scope, initializing the output array with `ObjectRef()` does not violate type safety.

Prior to this commit, `int`, `float`, and `bool` arguments from Python were converted to `IntImm`, `FloatImm`, and `Bool`. These are subtypes of `PrimExpr`, and should only be used at compile-time. By automatically applying this conversion as part of the FFI, these types are required to be present whenever a primitive is converted to a `tvm::ObjectRef`. This can become especially fragile for an end-user when storing objects into a TVM container. Because TVM containers require all contents to be `ObjectRef` subclasses, an automatic conversion may be applied on storing into a container, resulting in an unexpected type being retrieved from the container. For example, this currently occurs in Relax when extracting a `R.Prim` from a `R.Tuple`. This commit introduces a `Box<T>` type for storage of boxed primitives at runtime, distinct from the IR types. * Primitive arguments provided to a PackedFunc that requires an `ObjectRef` will be converted to the corresponding boxed type. (e.g. Passing a Python `int` to a C++ function accepting `ObjectRef` produces a `Box<int64_t>`. * Boxed primitives provided to a PackedFunc that requires an unboxed primitive will be converted to the corresponding primitive. * PackedFunc return values of `ObjectRef` are converted to the corresponding primitive, if present. (e.g. If a `tuple_getitem` with static return type `ObjectRef` returns a `Box<int64_t>`, it will be unwrapped to a python `int`.) Together, these three rules provide backwards compatibility for existing PackedFunc definitions, while avoiding exposing the user to any container-induced type conversions betweeen primitive types and `ObjectRef`.

Mostly, this requires removing `.value` unwrapping that is now applied automatically.

* Change tir.Call signature accept `Array<Variant<...>>` instead of `Array<ObjectRef>`. This allows the FFI to apply registered conversions. * Update target parsing to expect the default object types. * Extend conversion into PrimExpr. Several APIs that check for a PrimExpr may now receive a `runtime.String`, `runtime.Box<bool>` or `runtime.Box<int64_t>`. These must be converted to `StringImm`, `Bool`, or `IntImm` for use in functions that accept `PrimExpr`.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[Draft][Unity] Allow dynamic indices to TupleGetItem #16002

[Draft][Unity] Allow dynamic indices to TupleGetItem #16002

Commits on Nov 29, 2023