Type-erased function used across TVM API. More...

#include <tvm/runtime/c_runtime_api.h>
#include <tvm/runtime/container/array.h>
#include <tvm/runtime/container/map.h>
#include <tvm/runtime/data_type.h>
#include <tvm/runtime/logging.h>
#include <tvm/runtime/module.h>
#include <tvm/runtime/ndarray.h>
#include <tvm/runtime/object.h>
#include <functional>
#include <limits>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

Include dependency graph for packed_func.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	tvm::runtime::TypedPackedFunc< FType >
	Please refer to TypedPackedFunc<R(Args..)>. More...

struct	tvm::runtime::SignaturePrinter< TSignature >

class	tvm::runtime::PackedFuncObj
	Object container class that backs PackedFunc. More...

struct	tvm::runtime::PackedFuncObj::Extractor< TPackedFuncSubObj >
	Internal struct for extracting the callable method from callable type. More...

class	tvm::runtime::PackedFuncSubObj< TCallable >
	Derived object class for constructing PackedFuncObj. More...

class	tvm::runtime::PackedFunc
	Packed function is a type-erased function. The arguments are passed by packed format. More...

class	tvm::runtime::TypedPackedFunc< FType >
	Please refer to TypedPackedFunc<R(Args..)>. More...

class	tvm::runtime::TypedPackedFunc< R(Args...)>
	A PackedFunc wrapper to provide typed function signature. It is backed by a PackedFunc internally. More...

class	tvm::runtime::TVMArgs
	Arguments into TVM functions. More...

struct	tvm::runtime::ObjectTypeChecker< T >
	Type traits for runtime type check during FFI conversion. More...

struct	tvm::runtime::ObjectTypeChecker< Array< T > >

struct	tvm::runtime::ObjectTypeChecker< Map< K, V > >

class	tvm::runtime::TVMPODValue_
	Internal base class to handle conversion to POD values. More...

class	tvm::runtime::TVMArgValue
	A single argument value to PackedFunc. Containing both type_code and TVMValue. More...

class	tvm::runtime::TVMMovableArgValue_
	Internal auxiliary struct for TypedPackedFunc to indicate a movable argument. More...

class	tvm::runtime::TVMMovableArgValueWithContext_
	Internal auxiliary struct for TypedPackedFunc to indicate a movable argument with additional context information (function name and argument index) for better error reporting. More...

class	tvm::runtime::TVMRetValue
	Return Value container, Unlike TVMArgValue, which only holds reference and do not delete the underlying container during destruction. More...

struct	tvm::runtime::PackedFuncValueConverter< TObjectRef >
	Type trait to specify special value conversion rules from TVMArgValue and TVMRetValue. More...

class	tvm::runtime::TVMArgsSetter

struct	tvm::runtime::PackedFuncValueConverter<::tvm::runtime::String >

struct	tvm::runtime::PackedFuncValueConverter< Optional< T > >

Namespaces
	tvm
	runtime implementation for LibTorch/TorchScript.

	tvm::runtime

Macros
#define	TVM_RUNTIME_HEADER_ONLY 0

#define	TVM_CHECK_TYPE_CODE(CODE, T) ICHECK_EQ(CODE, T) << "expected " << ArgTypeCode2Str(T) << " but got " << ArgTypeCode2Str(CODE)

#define	TVM_DLL_EXPORT_PACKED_FUNC(ExportName, Function)
	Export a function with the PackedFunc signature as a PackedFunc that can be loaded by LibraryModule. More...

#define	TVM_DLL_EXPORT_TYPED_FUNC(ExportName, Function)
	Export typed function as a PackedFunc that can be loaded by LibraryModule. More...

Typedefs
using	tvm::runtime::FSig = std::string()
	Using static function to output TypedPackedFunc signature. More...

Functions
const char *	tvm::runtime::ArgTypeCode2Str (int type_code)
	Convert argument type code to string. More...

Detailed Description

Type-erased function used across TVM API.

Macro Definition Documentation

◆ TVM_CHECK_TYPE_CODE

#define TVM_CHECK_TYPE_CODE	(	CODE,
		T
	)	ICHECK_EQ(CODE, T) << "expected " << ArgTypeCode2Str(T) << " but got " << ArgTypeCode2Str(CODE)

◆ TVM_DLL_EXPORT_PACKED_FUNC

#define TVM_DLL_EXPORT_PACKED_FUNC	(	ExportName,
		Function
	)

Value:

extern "C" {                                                                              \
  TVM_DLL int ExportName(TVMValue* args, int* type_code, int num_args, TVMValue* out_value, \
                         int* out_type_code, void* resource_handle);                        \
  int ExportName(TVMValue* args, int* type_code, int num_args, TVMValue* out_value,         \
                 int* out_type_code, void* resource_handle) {                               \
    try {                                                                                   \
      ::tvm::runtime::TVMRetValue rv;                                                       \
      Function(::tvm::runtime::TVMArgs(args, type_code, num_args), &rv);                    \
      rv.MoveToCHost(out_value, out_type_code);                                             \
      return 0;                                                                             \
    } catch (const ::std::exception& _except_) {                                            \
      TVMAPISetLastError(_except_.what());                                                  \
      return -1;                                                                            \
    }                                                                                       \
  }                                                                                         \
  }

Export a function with the PackedFunc signature as a PackedFunc that can be loaded by LibraryModule.

Parameters

ExportName	The symbol name to be exported.
Function	The function with PackedFunc signature.

See also: PackedFunc

void AddOne_(TVMArgs args, TVMRetValue* rv) {
  int value = args[0];
  *rv = value + 1;
}
// Expose the function as "AddOne"
TVM_DLL_EXPORT_PACKED_FUNC(AddOne, AddOne_);

◆ TVM_DLL_EXPORT_TYPED_FUNC

#define TVM_DLL_EXPORT_TYPED_FUNC	(	ExportName,
		Function
	)

Value:

extern "C" {                                                                              \
  TVM_DLL int ExportName(TVMValue* args, int* type_code, int num_args, TVMValue* out_value, \
                         int* out_type_code, void* resource_handle) {                       \
    try {                                                                                   \
      auto f = Function;                                                                    \
      using FType = ::tvm::runtime::detail::function_signature<decltype(f)>::FType;         \
      ::tvm::runtime::TVMRetValue rv;                                                       \
      ::tvm::runtime::detail::unpack_call_by_signature<FType>::run(                         \
          f, ::tvm::runtime::TVMArgs(args, type_code, num_args), &rv);                      \
      rv.MoveToCHost(out_value, out_type_code);                                             \
      return 0;                                                                             \
    } catch (const ::std::exception& _except_) {                                            \
      TVMAPISetLastError(_except_.what());                                                  \
      return -1;                                                                            \
    }                                                                                       \
  }                                                                                         \
  }

Export typed function as a PackedFunc that can be loaded by LibraryModule.

Parameters

ExportName	The symbol name to be exported.
Function	The typed function.

Note: ExportName and Function must be different, see code examples below.

See also: TypedPackedFunc

int AddOne_(int x) {
  return x + 1;
}
// Expose the function as "AddOne"
TVM_DLL_EXPORT_TYPED_FUNC(AddOne, AddOne_);
// Expose the function as "SubOne"
TVM_DLL_EXPORT_TYPED_FUNC(SubOne, [](int x) {
  return x - 1;
});
// The following code will cause compilation error.
// Because the same Function and ExportName
// TVM_DLL_EXPORT_TYPED_FUNC(AddOne_, AddOne_);
// The following code is OK, assuming the macro
// is in a different namespace from xyz
// TVM_DLL_EXPORT_TYPED_FUNC(AddOne_, xyz::AddOne_);

◆ TVM_RUNTIME_HEADER_ONLY

#define TVM_RUNTIME_HEADER_ONLY 0

Classes

Namespaces

Macros