tvm_runtime (JavaCPP Presets for TVM 0.7.0-1.5.6 API)

java.lang.Object
- org.bytedeco.tvm.presets.tvm_runtime
- - org.bytedeco.tvm.global.tvm_runtime

All Implemented Interfaces:

LoadEnabled, InfoMapper
```
public class tvm_runtime
extends tvm_runtime
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class tvm_runtime.FileType
\brief type of file
- Nested classes/interfaces inherited from class org.bytedeco.tvm.presets.tvm_runtime
  tvm_runtime.PackedFuncFType

Nested Classes
Modifier and Type	Class and Description
`static class`	`tvm_runtime.FileType` \brief type of file

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DLPACK_VERSION` \brief The current version of dlpack
`static int`	`DMLC_ENABLE_RTTI` \brief whether RTTI is enabled
`static int`	`DMLC_ENABLE_STD_THREAD` \brief Enable std::thread related modules, Used to disable some module in mingw compile.
`static int`	`DMLC_IO_NO_ENDIAN_SWAP`
`static int`	`DMLC_IO_USE_LITTLE_ENDIAN` \brief Use little endian for binary serialization if this is set to 0, use big endian.
`static int`	`DMLC_LITTLE_ENDIAN`
`static int`	`DMLC_LOG_BEFORE_THROW` \brief whether always log a message before throw This can help identify the error that cannot be catched.
`static int`	`DMLC_LOG_CUSTOMIZE` \brief Whether to use customized logger, whose output can be decided by other libraries.
`static int`	`DMLC_LOG_DEBUG` \brief Whether to enable debug logging feature.
`static int`	`DMLC_LOG_FATAL_THROW` \brief whether throw dmlc::Error instead of directly calling abort when FATAL error occured NOTE: this may still not be perfect.
`static int`	`DMLC_LOG_NODATE` \brief Whether to disable date message on the log.
`static int`	`DMLC_MODERN_THREAD_LOCAL` \brief Whether to use modern thread local construct
`static int`	`DMLC_NO_EXCEPTION`
`static int`	`DMLC_THROW_EXCEPTION`
`static int`	`DMLC_USE_CXX11` \brief whether or not use c++11 support
`static int`	`DMLC_USE_FOPEN64` \brief whether use fopen64
`static int`	`DMLC_USE_GLOG` \brief whether use glog for logging
`static int`	`DMLC_USE_HDFS` \brief whether compile with hdfs support
`static int`	`DMLC_USE_PS` \brief whether or not use parameter server
`static int`	`DMLC_USE_REGEX`
`static int`	`DMLC_USE_S3` \brief whether compile with s3 support
`static int`	`kDLAOCL` enum TVMDeviceExtType
`static int`	`kDLBfloat` enum DLDataTypeCode
`static int`	`kDLCPU` enum DLDeviceType
`static int`	`kDLCPUPinned` enum DLDeviceType
`static int`	`kDLExtDev` enum DLDeviceType
`static int`	`kDLFloat` enum DLDataTypeCode
`static int`	`kDLGPU` enum DLDeviceType
`static int`	`kDLHexagon` enum TVMDeviceExtType
`static int`	`kDLInt` enum DLDataTypeCode
`static int`	`kDLMetal` enum DLDeviceType
`static int`	`kDLMicroDev` enum TVMDeviceExtType
`static int`	`kDLOpenCL` enum DLDeviceType
`static int`	`kDLROCM` enum DLDeviceType
`static int`	`kDLSDAccel` enum TVMDeviceExtType
`static int`	`kDLUInt` enum DLDataTypeCode
`static int`	`kDLVPI` enum DLDeviceType
`static int`	`kDLVulkan` enum DLDeviceType
`static int`	`kDLWebGPU` enum TVMDeviceExtType
`static int`	`kOpenGL` enum TVMDeviceExtType
`static int`	`kTVMArgFloat` enum TVMArgTypeCode
`static int`	`kTVMArgInt` enum TVMArgTypeCode
`static int`	`kTVMBytes` enum TVMArgTypeCode
`static int`	`kTVMContext` enum TVMArgTypeCode
`static int`	`kTVMDataType` enum TVMArgTypeCode
`static int`	`kTVMDLTensorHandle` enum TVMArgTypeCode
`static int`	`kTVMExtBegin` enum TVMArgTypeCode
`static int`	`kTVMExtEnd` enum TVMArgTypeCode
`static int`	`kTVMExtReserveEnd` enum TVMArgTypeCode
`static int`	`kTVMModuleHandle` enum TVMArgTypeCode
`static int`	`kTVMNDArrayHandle` enum TVMArgTypeCode
`static int`	`kTVMNNVMFirst` enum TVMArgTypeCode
`static int`	`kTVMNNVMLast` enum TVMArgTypeCode
`static int`	`kTVMNullptr` enum TVMArgTypeCode
`static int`	`kTVMObjectHandle` enum TVMArgTypeCode
`static int`	`kTVMObjectRValueRefArg` enum TVMArgTypeCode
`static int`	`kTVMOpaqueHandle` enum TVMArgTypeCode
`static int`	`kTVMPackedFuncHandle` enum TVMArgTypeCode
`static int`	`kTVMStr` enum TVMArgTypeCode
`static int`	`TVM_OBJECT_ATOMIC_REF_COUNTER` \brief Whether or not use atomic reference counter.
`static int`	`TVM_RUNTIME_HEADER_ONLY` \file tvm/runtime/packed_func.h \brief Type-erased function used across TVM API.
`static int`	`TVM_USE_CXX14_STRING_VIEW_HASH` \file tvm/runtime/container.h \brief Common POD(plain old data) container types.
`static int`	`TVM_USE_CXX17_STRING_VIEW_HASH`
`static String`	`TVM_VERSION` \endcond

Constructor Summary

Constructors
Constructor and Description

tvm_runtime()

Constructors
Constructor and Description
`tvm_runtime()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static TVMString`	`add(BytePointer lhs, TVMString rhs)`
`static TVMString`	`add(String lhs, TVMString rhs)`
`static TVMString`	`add(TVMString lhs, BytePointer rhs)`
`static TVMString`	`add(TVMString lhs, String rhs)`
`static TVMString`	`add(TVMString lhs, TVMString rhs)` \brief An object representing string moved from std::string.
`static BytePointer`	`ArgTypeCode2Str(int type_code)` \brief Convert argument type code to string.
`static BytePointer`	`BeginPtr(BytePointer str)` \brief get the beginning address of a string
`static String`	`BeginPtr(String str)` \brief get the beginning address of a const string
`static void`	`ByteSwap(Pointer data, long elem_bytes, long num_elems)` \brief A generic inplace byte swapping function.
`static BytePointer`	`DLDataType2String(DLDataType t)` \brief convert a TVM type to string.
`static BytePointer`	`DLDataTypeCode2Str(int type_code)` \brief Convert type code to its name
`static int`	`DMLC_IO_NO_ENDIAN_SWAP()` \brief whether serialize using little endian
`static int`	`DMLC_LITTLE_ENDIAN()` Copyright (c) 2017 by Contributors \file endian.h \brief Endian testing, need c++11
`static int`	`DMLC_NO_EXCEPTION()`
`static int`	`DMLC_THROW_EXCEPTION()` \brief Disable copy constructor and assignment operator.
`static int`	`DMLC_USE_REGEX()` \brief whether enable regex support, actually need g++-4.9 or higher
`static boolean`	`equals(BytePointer lhs, TVMString rhs)`
`static boolean`	`equals(String lhs, TVMString rhs)`
`static boolean`	`equals(TVMString lhs, BytePointer rhs)`
`static boolean`	`equals(TVMString lhs, String rhs)`
`static boolean`	`equals(TVMString lhs, TVMString rhs)`
`static BytePointer`	`GetCustomTypeName(byte type_code)` \brief Runtime utility for getting custom type name from code
`static boolean`	`GetCustomTypeRegistered(byte type_code)` \brief Runtime utility for checking whether custom type is registered
`static long`	`GetDataSize(DLTensor arr)` \brief return the size of data the DLTensor hold, in term of number of bytes
`static int`	`GetVectorBytes(DataType dtype)` \brief Get the number of bytes needed in a vector.
`static boolean`	`greaterThan(BytePointer lhs, TVMString rhs)`
`static boolean`	`greaterThan(String lhs, TVMString rhs)`
`static boolean`	`greaterThan(TVMString lhs, BytePointer rhs)`
`static boolean`	`greaterThan(TVMString lhs, String rhs)`
`static boolean`	`greaterThan(TVMString lhs, TVMString rhs)`
`static boolean`	`greaterThanEquals(BytePointer lhs, TVMString rhs)`
`static boolean`	`greaterThanEquals(String lhs, TVMString rhs)`
`static boolean`	`greaterThanEquals(TVMString lhs, BytePointer rhs)`
`static boolean`	`greaterThanEquals(TVMString lhs, String rhs)`
`static boolean`	`greaterThanEquals(TVMString lhs, TVMString rhs)`
`static void`	`InitLogging(BytePointer argv0)` \brief optionally redirect to google's init log
`static void`	`InitLogging(String argv0)`
`static boolean`	`IsContiguous(DLTensor arr)` \brief check if a DLTensor is contiguous.
`static long`	`kTVMNDArrayMagic()` \brief Magic number for NDArray file
`static boolean`	`lessThan(BytePointer lhs, TVMString rhs)`
`static boolean`	`lessThan(String lhs, TVMString rhs)`
`static boolean`	`lessThan(TVMString lhs, BytePointer rhs)`
`static boolean`	`lessThan(TVMString lhs, String rhs)`
`static boolean`	`lessThan(TVMString lhs, TVMString rhs)`
`static boolean`	`lessThanEquals(BytePointer lhs, TVMString rhs)`
`static boolean`	`lessThanEquals(String lhs, TVMString rhs)`
`static boolean`	`lessThanEquals(TVMString lhs, BytePointer rhs)`
`static boolean`	`lessThanEquals(TVMString lhs, String rhs)`
`static boolean`	`lessThanEquals(TVMString lhs, TVMString rhs)`
`static long`	`LogStackTraceLevel()` Copyright (c) 2015 by Contributors \file logging.h \brief defines logging macros of dmlc allows use of GLOG, fall back to internal implementation when disabled
`static ArrayNodePtr`	`makeArrayNode()` \brief Allocate an object using default allocator.
`static boolean`	`notEquals(BytePointer lhs, TVMString rhs)`
`static boolean`	`notEquals(String lhs, TVMString rhs)`
`static boolean`	`notEquals(TVMString lhs, BytePointer rhs)`
`static boolean`	`notEquals(TVMString lhs, String rhs)`
`static boolean`	`notEquals(TVMString lhs, TVMString rhs)`
`static NullOptType`	`NullOpt()` \brief Optional container that to represent to a Nullable variant of T.
`static byte`	`ParseCustomDatatype(BytePointer s, byte[] scan)`
`static byte`	`ParseCustomDatatype(BytePointer s, ByteBuffer scan)`
`static byte`	`ParseCustomDatatype(BytePointer s, BytePointer scan)`
`static byte`	`ParseCustomDatatype(BytePointer s, PointerPointer scan)` \brief Runtime utility for parsing string of the form "custom[]"
`static byte`	`ParseCustomDatatype(String s, byte[] scan)`
`static byte`	`ParseCustomDatatype(String s, ByteBuffer scan)`
`static byte`	`ParseCustomDatatype(String s, BytePointer scan)`
`static boolean`	`RuntimeEnabled(BytePointer target)` \brief Check if runtime module is enabled for target.
`static boolean`	`RuntimeEnabled(String target)`
`static boolean`	`SaveDLTensor(Stream strm, DLTensor tensor)` \brief Save a DLTensor to stream
`static Pointer`	`shiftLeft(Pointer os, DataType dtype)`
`static Pointer`	`shiftLeft(Pointer os, DLDataType t)`
`static Pointer`	`shiftLeft(Pointer out, TVMString input)`
`static BytePointer`	`StackTrace()`
`static BytePointer`	`StackTrace(long start_frame, long stack_size)`
`static DLDataType`	`String2DLDataType(BytePointer s)` \brief convert a string to TVM type.
`static DLDataType`	`String2DLDataType(String s)`
`static BytePointer`	`tvm_dev_mblob_nbytes()` \brief Number of bytes of device module blob.
`static BytePointer`	`tvm_dev_mblob()` \brief Global variable to store device module blob
`static BytePointer`	`tvm_global_barrier_state()` \brief Auxiliary counter to global barrier.
`static BytePointer`	`tvm_module_ctx()` \brief Global variable to store module context.
`static BytePointer`	`tvm_module_main()` \brief Placeholder for the module's entry function.
`static BytePointer`	`tvm_prepare_global_barrier()` \brief Prepare the global barrier before kernels that uses global barrier.
`static BytePointer`	`tvm_set_device()` \brief global function to set device
`static void`	`TVMAPISetLastError(BytePointer msg)` \brief Used for implementing C API function.
`static void`	`TVMAPISetLastError(String msg)`
`static int`	`TVMArrayAlloc(long[] shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, DLTensor out)`
`static int`	`TVMArrayAlloc(long[] shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, PointerPointer out)`
`static int`	`TVMArrayAlloc(LongBuffer shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, DLTensor out)`
`static int`	`TVMArrayAlloc(LongBuffer shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, PointerPointer out)`
`static int`	`TVMArrayAlloc(LongPointer shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, DLTensor out)`
`static int`	`TVMArrayAlloc(LongPointer shape, int ndim, int dtype_code, int dtype_bits, int dtype_lanes, int device_type, int device_id, PointerPointer out)` \brief Allocate a nd-array's memory, including space of shape, of given spec.
`static int`	`TVMArrayCopyFromBytes(DLTensor handle, Pointer data, long nbytes)` \brief Copy array data from CPU byte array.
`static int`	`TVMArrayCopyFromTo(DLTensor from, DLTensor to, TVMStreamHandle stream)` \brief Copy the array, both from and to must be valid during the copy.
`static int`	`TVMArrayCopyToBytes(DLTensor handle, Pointer data, long nbytes)` \brief Copy array data to CPU byte array.
`static int`	`TVMArrayFree(DLTensor handle)` \brief Free the TVM Array.
`static int`	`TVMArrayFromDLPack(DLManagedTensor from, DLTensor out)`
`static int`	`TVMArrayFromDLPack(DLManagedTensor from, PointerPointer out)` \brief Produce an array from the DLManagedTensor that shares data memory with the DLManagedTensor.
`static TVMObject`	`TVMArrayHandleToObjectHandle(DLTensor handle)`
`static int`	`TVMArrayToDLPack(DLTensor from, DLManagedTensor out)`
`static int`	`TVMArrayToDLPack(DLTensor from, PointerPointer out)` \brief Produce a DLMangedTensor from the array that shares data memory with the array.
`static int`	`TVMCbArgToReturn(TVMValue value, int[] code)`
`static int`	`TVMCbArgToReturn(TVMValue value, IntBuffer code)`
`static int`	`TVMCbArgToReturn(TVMValue value, IntPointer code)` \brief Inplace translate callback argument value to return value.
`static int`	`TVMCFuncSetReturn(TVMRetValueHandle ret, TVMValue value, int[] type_code, int num_ret)`
`static int`	`TVMCFuncSetReturn(TVMRetValueHandle ret, TVMValue value, IntBuffer type_code, int num_ret)`
`static int`	`TVMCFuncSetReturn(TVMRetValueHandle ret, TVMValue value, IntPointer type_code, int num_ret)` \brief Set the return value of TVMPackedCFunc.
`static int`	`TVMDeviceAllocDataSpace(DLContext ctx, long nbytes, long alignment, DLDataType type_hint, Pointer out_data)`
`static int`	`TVMDeviceAllocDataSpace(DLContext ctx, long nbytes, long alignment, DLDataType type_hint, PointerPointer out_data)` \brief Allocate a data space on device.
`static int`	`TVMDeviceCopyDataFromTo(Pointer from, long from_offset, Pointer to, long to_offset, long num_bytes, DLContext ctx_from, DLContext ctx_to, DLDataType type_hint, TVMStreamHandle stream)` \brief Copy data from one place to another.
`static int`	`TVMDeviceFreeDataSpace(DLContext ctx, Pointer ptr)` \brief Free a data space on device.
`static void`	`TVMDLManagedTensorCallDeleter(DLManagedTensor dltensor)` \brief Delete (free) a DLManagedTensor's data.
`static int`	`TVMFuncCall(TVMFunctionHandle func, TVMValue arg_values, int[] type_codes, int num_args, TVMValue ret_val, int[] ret_type_code)`
`static int`	`TVMFuncCall(TVMFunctionHandle func, TVMValue arg_values, IntBuffer type_codes, int num_args, TVMValue ret_val, IntBuffer ret_type_code)`
`static int`	`TVMFuncCall(TVMFunctionHandle func, TVMValue arg_values, IntPointer type_codes, int num_args, TVMValue ret_val, IntPointer ret_type_code)` \brief Call a Packed TVM Function.
`static int`	`TVMFuncCreateFromCFunc(TVMPackedCFunc func, Pointer resource_handle, TVMPackedCFuncFinalizer fin, TVMFunctionHandle out)` \brief Wrap a TVMPackedCFunc to become a FunctionHandle.
`static int`	`TVMFuncFree(TVMFunctionHandle func)` \brief Free the function when it is no longer needed.
`static int`	`TVMFuncGetGlobal(BytePointer name, TVMFunctionHandle out)` \brief Get a global function.
`static int`	`TVMFuncGetGlobal(String name, TVMFunctionHandle out)`
`static int`	`TVMFuncListGlobalNames(int[] out_size, PointerPointer out_array)`
`static int`	`TVMFuncListGlobalNames(IntBuffer out_size, PointerPointer out_array)`
`static int`	`TVMFuncListGlobalNames(IntPointer out_size, PointerPointer out_array)` \brief List all the globally registered function name
`static int`	`TVMFuncRegisterGlobal(BytePointer name, TVMFunctionHandle f, int override)` \brief Register the function to runtime's global table.
`static int`	`TVMFuncRegisterGlobal(String name, TVMFunctionHandle f, int override)`
`static BytePointer`	`TVMGetLastError()` \brief return str message of the last error all function in this file will return 0 when success and -1 when an error occurred, TVMGetLastError can be called to retrieve the error this function is threadsafe and can be called by different thread
`static int`	`TVMModFree(TVMModuleHandle mod)` \brief Free the Module
`static int`	`TVMModGetFunction(TVMModuleHandle mod, BytePointer func_name, int query_imports, TVMFunctionHandle out)` \brief Get function from the module.
`static int`	`TVMModGetFunction(TVMModuleHandle mod, String func_name, int query_imports, TVMFunctionHandle out)`
`static int`	`TVMModImport(TVMModuleHandle mod, TVMModuleHandle dep)` \brief Add dep to mod's dependency.
`static int`	`TVMModLoadFromFile(BytePointer file_name, BytePointer format, TVMModuleHandle out)` \brief Load module from file.
`static int`	`TVMModLoadFromFile(String file_name, String format, TVMModuleHandle out)`
`static int`	`TVMObjectDerivedFrom(int child_type_index, int parent_type_index, int[] is_derived)`
`static int`	`TVMObjectDerivedFrom(int child_type_index, int parent_type_index, IntBuffer is_derived)`
`static int`	`TVMObjectDerivedFrom(int child_type_index, int parent_type_index, IntPointer is_derived)` \brief Check that an object is derived from another.
`static int`	`TVMObjectFree(TVMObjectHandle obj)` \brief Free the object.
`static int`	`TVMObjectGetTypeIndex(TVMObjectHandle obj, int[] out_tindex)`
`static int`	`TVMObjectGetTypeIndex(TVMObjectHandle obj, IntBuffer out_tindex)`
`static int`	`TVMObjectGetTypeIndex(TVMObjectHandle obj, IntPointer out_tindex)` \brief Get the type_index from an object.
`static int`	`TVMObjectRetain(TVMObjectHandle obj)` \brief Increase the reference count of an object.
`static int`	`TVMObjectTypeKey2Index(BytePointer type_key, int[] out_tindex)`
`static int`	`TVMObjectTypeKey2Index(BytePointer type_key, IntBuffer out_tindex)`
`static int`	`TVMObjectTypeKey2Index(BytePointer type_key, IntPointer out_tindex)` \brief Convert type key to type index.
`static int`	`TVMObjectTypeKey2Index(String type_key, int[] out_tindex)`
`static int`	`TVMObjectTypeKey2Index(String type_key, IntBuffer out_tindex)`
`static int`	`TVMObjectTypeKey2Index(String type_key, IntPointer out_tindex)`
`static int`	`TVMSetStream(int device_type, int device_id, TVMStreamHandle handle)` \brief Set the runtime stream of current thread to be stream.
`static int`	`TVMStreamCreate(int device_type, int device_id, TVMStreamHandle out)` \brief Create a new runtime stream.
`static int`	`TVMStreamFree(int device_type, int device_id, TVMStreamHandle stream)` \brief Free a created stream handle.
`static int`	`TVMStreamStreamSynchronize(int device_type, int device_id, TVMStreamHandle src, TVMStreamHandle dst)` \brief Synchronize two streams of execution.
`static int`	`TVMSynchronize(int device_type, int device_id, TVMStreamHandle stream)` \brief Wait until all computations on stream completes.
`static boolean`	`TypeEqual(DLDataType lhs, DLDataType rhs)` \brief Check whether two types are equal .
`static boolean`	`TypeMatch(DLDataType t, int code, int bits)`
`static boolean`	`TypeMatch(DLDataType t, int code, int bits, int lanes)` \brief Check whether type matches the given spec.

Methods inherited from class org.bytedeco.tvm.presets.tvm_runtime
init, map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- DLPACK_VERSION
```
public static final int DLPACK_VERSION
```
  \brief The current version of dlpack
  
  See Also:
  
  Constant Field Values
- kDLCPU
```
public static final int kDLCPU
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLGPU
```
public static final int kDLGPU
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLCPUPinned
```
public static final int kDLCPUPinned
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLOpenCL
```
public static final int kDLOpenCL
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLVulkan
```
public static final int kDLVulkan
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLMetal
```
public static final int kDLMetal
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLVPI
```
public static final int kDLVPI
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLROCM
```
public static final int kDLROCM
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLExtDev
```
public static final int kDLExtDev
```
  enum DLDeviceType
  
  See Also:
  
  Constant Field Values
- kDLInt
```
public static final int kDLInt
```
  enum DLDataTypeCode
  
  See Also:
  
  Constant Field Values
- kDLUInt
```
public static final int kDLUInt
```
  enum DLDataTypeCode
  
  See Also:
  
  Constant Field Values
- kDLFloat
```
public static final int kDLFloat
```
  enum DLDataTypeCode
  
  See Also:
  
  Constant Field Values
- kDLBfloat
```
public static final int kDLBfloat
```
  enum DLDataTypeCode
  
  See Also:
  
  Constant Field Values
- DMLC_USE_GLOG
```
public static final int DMLC_USE_GLOG
```
  \brief whether use glog for logging
  
  See Also:
  
  Constant Field Values
- DMLC_LOG_FATAL_THROW
```
public static final int DMLC_LOG_FATAL_THROW
```
  \brief whether throw dmlc::Error instead of directly calling abort when FATAL error occured NOTE: this may still not be perfect. do not use FATAL and CHECK in destructors
  
  See Also:
  
  Constant Field Values
- DMLC_LOG_BEFORE_THROW
```
public static final int DMLC_LOG_BEFORE_THROW
```
  \brief whether always log a message before throw This can help identify the error that cannot be catched.
  
  See Also:
  
  Constant Field Values
- DMLC_LOG_CUSTOMIZE
```
public static final int DMLC_LOG_CUSTOMIZE
```
  \brief Whether to use customized logger, whose output can be decided by other libraries.
  
  See Also:
  
  Constant Field Values
- DMLC_LOG_DEBUG
```
public static final int DMLC_LOG_DEBUG
```
  \brief Whether to enable debug logging feature.
  
  See Also:
  
  Constant Field Values
- DMLC_LOG_NODATE
```
public static final int DMLC_LOG_NODATE
```
  \brief Whether to disable date message on the log.
  
  See Also:
  
  Constant Field Values
- DMLC_USE_HDFS
```
public static final int DMLC_USE_HDFS
```
  \brief whether compile with hdfs support
  
  See Also:
  
  Constant Field Values
- DMLC_USE_S3
```
public static final int DMLC_USE_S3
```
  \brief whether compile with s3 support
  
  See Also:
  
  Constant Field Values
- DMLC_USE_PS
```
public static final int DMLC_USE_PS
```
  \brief whether or not use parameter server
  
  See Also:
  
  Constant Field Values
- DMLC_USE_CXX11
```
public static final int DMLC_USE_CXX11
```
  \brief whether or not use c++11 support
  
  See Also:
  
  Constant Field Values
- DMLC_MODERN_THREAD_LOCAL
```
public static final int DMLC_MODERN_THREAD_LOCAL
```
  \brief Whether to use modern thread local construct
  
  See Also:
  
  Constant Field Values
- DMLC_ENABLE_RTTI
```
public static final int DMLC_ENABLE_RTTI
```
  \brief whether RTTI is enabled
  
  See Also:
  
  Constant Field Values
- DMLC_USE_FOPEN64
```
public static final int DMLC_USE_FOPEN64
```
  \brief whether use fopen64
  
  See Also:
  
  Constant Field Values
- DMLC_IO_USE_LITTLE_ENDIAN
```
public static final int DMLC_IO_USE_LITTLE_ENDIAN
```
  \brief Use little endian for binary serialization if this is set to 0, use big endian.
  
  See Also:
  
  Constant Field Values
- DMLC_ENABLE_STD_THREAD
```
public static final int DMLC_ENABLE_STD_THREAD
```
  \brief Enable std::thread related modules, Used to disable some module in mingw compile.
  
  See Also:
  
  Constant Field Values
- DMLC_USE_REGEX
```
public static final int DMLC_USE_REGEX
```
- DMLC_THROW_EXCEPTION
```
public static final int DMLC_THROW_EXCEPTION
```
- DMLC_NO_EXCEPTION
```
public static final int DMLC_NO_EXCEPTION
```
- DMLC_LITTLE_ENDIAN
```
public static final int DMLC_LITTLE_ENDIAN
```
- DMLC_IO_NO_ENDIAN_SWAP
```
public static final int DMLC_IO_NO_ENDIAN_SWAP
```
- TVM_VERSION
```
public static final String TVM_VERSION
```
  \endcond
  
  See Also:
  
  Constant Field Values
- kDLAOCL
```
public static final int kDLAOCL
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kDLSDAccel
```
public static final int kDLSDAccel
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kOpenGL
```
public static final int kOpenGL
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kDLMicroDev
```
public static final int kDLMicroDev
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kDLHexagon
```
public static final int kDLHexagon
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kDLWebGPU
```
public static final int kDLWebGPU
```
  enum TVMDeviceExtType
  
  See Also:
  
  Constant Field Values
- kTVMArgInt
```
public static final int kTVMArgInt
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMArgFloat
```
public static final int kTVMArgFloat
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMOpaqueHandle
```
public static final int kTVMOpaqueHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMNullptr
```
public static final int kTVMNullptr
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMDataType
```
public static final int kTVMDataType
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMContext
```
public static final int kTVMContext
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMDLTensorHandle
```
public static final int kTVMDLTensorHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMObjectHandle
```
public static final int kTVMObjectHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMModuleHandle
```
public static final int kTVMModuleHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMPackedFuncHandle
```
public static final int kTVMPackedFuncHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMStr
```
public static final int kTVMStr
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMBytes
```
public static final int kTVMBytes
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMNDArrayHandle
```
public static final int kTVMNDArrayHandle
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMObjectRValueRefArg
```
public static final int kTVMObjectRValueRefArg
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMExtBegin
```
public static final int kTVMExtBegin
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMNNVMFirst
```
public static final int kTVMNNVMFirst
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMNNVMLast
```
public static final int kTVMNNVMLast
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMExtReserveEnd
```
public static final int kTVMExtReserveEnd
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- kTVMExtEnd
```
public static final int kTVMExtEnd
```
  enum TVMArgTypeCode
  
  See Also:
  
  Constant Field Values
- TVM_OBJECT_ATOMIC_REF_COUNTER
```
public static final int TVM_OBJECT_ATOMIC_REF_COUNTER
```
  \brief Whether or not use atomic reference counter. If the reference counter is not atomic, an object cannot be owned by multiple threads. We can, however, move an object across threads
  
  See Also:
  
  Constant Field Values
- TVM_USE_CXX14_STRING_VIEW_HASH
```
public static final int TVM_USE_CXX14_STRING_VIEW_HASH
```
  \file tvm/runtime/container.h \brief Common POD(plain old data) container types.
  
  See Also:
  
  Constant Field Values
- TVM_USE_CXX17_STRING_VIEW_HASH
```
public static final int TVM_USE_CXX17_STRING_VIEW_HASH
```
  See Also:
  
  Constant Field Values
- TVM_RUNTIME_HEADER_ONLY
```
public static final int TVM_RUNTIME_HEADER_ONLY
```
  \file tvm/runtime/packed_func.h \brief Type-erased function used across TVM API.
  
  See Also:
  
  Constant Field Values

Constructor Detail
- tvm_runtime
```
public tvm_runtime()
```

Method Detail

DMLC_USE_REGEX
```
@MemberGetter
public static int DMLC_USE_REGEX()
```
\brief whether enable regex support, actually need g++-4.9 or higher

DMLC_THROW_EXCEPTION
```
@MemberGetter
public static int DMLC_THROW_EXCEPTION()
```
\brief Disable copy constructor and assignment operator. If C++11 is supported, both copy and move constructors and assignment operators are deleted explicitly. Otherwise, they are only declared but not implemented. Place this macro in private section if C++11 is not available.

DMLC_NO_EXCEPTION

@MemberGetter
public static int DMLC_NO_EXCEPTION()

BeginPtr

@Namespace(value="dmlc")
 @Cast(value="char*")
public static BytePointer BeginPtr(@StdString @ByRef
                                                                                    BytePointer str)

\brief get the beginning address of a string

Parameters:: str - input string
Returns:: beginning address of a string

BeginPtr

@Namespace(value="dmlc")
public static String BeginPtr(@StdString
                                                        String str)

\brief get the beginning address of a const string

Parameters:: str - input string
Returns:: beginning address of a string

LogStackTraceLevel
```
@Namespace(value="dmlc")
 @Cast(value="size_t")
public static long LogStackTraceLevel()
```
Copyright (c) 2015 by Contributors \file logging.h \brief defines logging macros of dmlc allows use of GLOG, fall back to internal implementation when disabled

StackTrace

@Namespace(value="dmlc")
 @StdString
public static BytePointer StackTrace(@Cast(value="size_t")
                                                                            long start_frame,
                                                                            @Cast(value="const size_t")
                                                                            long stack_size)

StackTrace

@Namespace(value="dmlc")
 @StdString
public static BytePointer StackTrace()

InitLogging

@Namespace(value="dmlc")
public static void InitLogging(@Cast(value="const char*")
                                                         BytePointer argv0)

\brief optionally redirect to google's init log

Parameters:: argv0 - The arguments.

InitLogging

@Namespace(value="dmlc")
public static void InitLogging(String argv0)

DMLC_LITTLE_ENDIAN
```
@MemberGetter
public static int DMLC_LITTLE_ENDIAN()
```
Copyright (c) 2017 by Contributors \file endian.h \brief Endian testing, need c++11

DMLC_IO_NO_ENDIAN_SWAP
```
@MemberGetter
public static int DMLC_IO_NO_ENDIAN_SWAP()
```
\brief whether serialize using little endian

ByteSwap

@Namespace(value="dmlc")
public static void ByteSwap(Pointer data,
                                                      @Cast(value="size_t")
                                                      long elem_bytes,
                                                      @Cast(value="size_t")
                                                      long num_elems)

\brief A generic inplace byte swapping function.

Parameters:: data - The data pointer.; elem_bytes - The number of bytes of the data elements; num_elems - Number of elements in the data. \note Always try pass in constant elem_bytes to enable compiler optimization

TVMAPISetLastError

public static void TVMAPISetLastError(@Cast(value="const char*")
                                      BytePointer msg)

\brief Used for implementing C API function. Set last error message before return.

Parameters:: msg - The error message to be set.

TVMAPISetLastError

public static void TVMAPISetLastError(String msg)

TVMGetLastError
```
@Cast(value="const char*")
public static BytePointer TVMGetLastError()
```
\brief return str message of the last error all function in this file will return 0 when success and -1 when an error occurred, TVMGetLastError can be called to retrieve the error this function is threadsafe and can be called by different thread

Returns:

error info

TVMModLoadFromFile

public static int TVMModLoadFromFile(@Cast(value="const char*")
                                     BytePointer file_name,
                                     @Cast(value="const char*")
                                     BytePointer format,
                                     @ByPtrPtr
                                     TVMModuleHandle out)

\brief Load module from file.

Parameters:: file_name - The file name to load the module from.; format - The format of the module.; out - The result module
Returns:: 0 when success, -1 when failure happens \note The resulting module do not contain import relation. It can be reconstructed by TVMModImport.

TVMModLoadFromFile

public static int TVMModLoadFromFile(String file_name,
                                     String format,
                                     @ByPtrPtr
                                     TVMModuleHandle out)

TVMModImport
```
public static int TVMModImport(TVMModuleHandle mod,
                               TVMModuleHandle dep)
```
\brief Add dep to mod's dependency. This allows functions in this module to use modules.

Parameters:

mod - The module handle.

dep - The dependent module to be imported.

Returns:

0 when success, -1 when failure happens

TVMModGetFunction

public static int TVMModGetFunction(TVMModuleHandle mod,
                                    @Cast(value="const char*")
                                    BytePointer func_name,
                                    int query_imports,
                                    @ByPtrPtr
                                    TVMFunctionHandle out)

\brief Get function from the module.

Parameters:: mod - The module handle.; func_name - The name of the function.; query_imports - Whether to query imported modules; out - The result function, can be NULL if it is not available.
Returns:: 0 when no error is thrown, -1 when failure happens

TVMModGetFunction

public static int TVMModGetFunction(TVMModuleHandle mod,
                                    String func_name,
                                    int query_imports,
                                    @ByPtrPtr
                                    TVMFunctionHandle out)

TVMModFree
```
public static int TVMModFree(TVMModuleHandle mod)
```
\brief Free the Module

Parameters:

mod - The module to be freed. \note This may not free up the module's resources. If there is active TVMFunctionHandle uses the module Or if this module is imported by another active module. The all functions remains valid until TVMFuncFree is called.

Returns:

0 when success, -1 when failure happens

TVMFuncFree
```
public static int TVMFuncFree(TVMFunctionHandle func)
```
\brief Free the function when it is no longer needed.

Parameters:

func - The function handle

Returns:

0 when success, -1 when failure happens

TVMFuncCall
```
public static int TVMFuncCall(TVMFunctionHandle func,
                              TVMValue arg_values,
                              IntPointer type_codes,
                              int num_args,
                              TVMValue ret_val,
                              IntPointer ret_type_code)
```
\brief Call a Packed TVM Function.

Parameters:

func - node handle of the function.

arg_values - The arguments

type_codes - The type codes of the arguments

num_args - Number of arguments.

ret_val - The return value.

ret_type_code - the type code of return value.

Returns:

0 when success, -1 when failure happens \note TVM calls always exchanges with type bits=64, lanes=1 \note API calls always exchanges with type bits=64, lanes=1 If API call returns container handles (e.g. FunctionHandle) these handles should be managed by the front-end. The front-end need to call free function (e.g. TVMFuncFree) to free these handles.

TVMFuncCall

public static int TVMFuncCall(TVMFunctionHandle func,
                              TVMValue arg_values,
                              IntBuffer type_codes,
                              int num_args,
                              TVMValue ret_val,
                              IntBuffer ret_type_code)

TVMFuncCall

public static int TVMFuncCall(TVMFunctionHandle func,
                              TVMValue arg_values,
                              int[] type_codes,
                              int num_args,
                              TVMValue ret_val,
                              int[] ret_type_code)

TVMCFuncSetReturn
```
public static int TVMCFuncSetReturn(TVMRetValueHandle ret,
                                    TVMValue value,
                                    IntPointer type_code,
                                    int num_ret)
```
\brief Set the return value of TVMPackedCFunc. This function is called by TVMPackedCFunc to set the return value. When this function is not called, the function returns null by default.

Parameters:

ret - The return value handle, pass by ret in TVMPackedCFunc

value - The value to be returned.

type_code - The type of the value to be returned.

num_ret - Number of return values, for now only 1 is supported.

TVMCFuncSetReturn

public static int TVMCFuncSetReturn(TVMRetValueHandle ret,
                                    TVMValue value,
                                    IntBuffer type_code,
                                    int num_ret)

TVMCFuncSetReturn

public static int TVMCFuncSetReturn(TVMRetValueHandle ret,
                                    TVMValue value,
                                    int[] type_code,
                                    int num_ret)

TVMCbArgToReturn
```
public static int TVMCbArgToReturn(TVMValue value,
                                   IntPointer code)
```
\brief Inplace translate callback argument value to return value. This is only needed for non-POD arguments.

Parameters:

value - The value to be translated.

code - The type code to be translated. \note This function will do a shallow copy when necessary.

Returns:

0 when success, -1 when failure happens.

TVMCbArgToReturn

public static int TVMCbArgToReturn(TVMValue value,
                                   IntBuffer code)

TVMCbArgToReturn

public static int TVMCbArgToReturn(TVMValue value,
                                   int[] code)

TVMFuncCreateFromCFunc

public static int TVMFuncCreateFromCFunc(TVMPackedCFunc func,
                                         Pointer resource_handle,
                                         TVMPackedCFuncFinalizer fin,
                                         @ByPtrPtr
                                         TVMFunctionHandle out)

\brief Wrap a TVMPackedCFunc to become a FunctionHandle. The resource_handle will be managed by TVM API, until the function is no longer used.

Parameters:: func - The packed C function.; resource_handle - The resource handle from front-end, can be NULL.; fin - The finalizer on resource handle when the FunctionHandle get freed, can be NULL; out - the result function handle.
Returns:: 0 when success, -1 when failure happens

TVMFuncRegisterGlobal

public static int TVMFuncRegisterGlobal(@Cast(value="const char*")
                                        BytePointer name,
                                        TVMFunctionHandle f,
                                        int override)

\brief Register the function to runtime's global table. The registered function then can be pulled by the backend by the name.

Parameters:: name - The name of the function.; f - The function to be registered.; override - Whether allow override already registered function.

TVMFuncRegisterGlobal

public static int TVMFuncRegisterGlobal(String name,
                                        TVMFunctionHandle f,
                                        int override)

TVMFuncGetGlobal

public static int TVMFuncGetGlobal(@Cast(value="const char*")
                                   BytePointer name,
                                   @ByPtrPtr
                                   TVMFunctionHandle out)

\brief Get a global function.

Parameters:: name - The name of the function.; out - the result function pointer, NULL if it does not exist. \note The function handle of global function is managed by TVM runtime, So TVMFuncFree is should not be called when it get deleted.

TVMFuncGetGlobal

public static int TVMFuncGetGlobal(String name,
                                   @ByPtrPtr
                                   TVMFunctionHandle out)

TVMFuncListGlobalNames

public static int TVMFuncListGlobalNames(IntPointer out_size,
                                         @Cast(value="const char***") @ByPtrPtr
                                         PointerPointer out_array)

\brief List all the globally registered function name

Parameters:: out_size - The number of functions; out_array - The array of function names.
Returns:: 0 when success, -1 when failure happens

TVMFuncListGlobalNames

public static int TVMFuncListGlobalNames(IntBuffer out_size,
                                         @Cast(value="const char***") @ByPtrPtr
                                         PointerPointer out_array)

TVMFuncListGlobalNames

public static int TVMFuncListGlobalNames(int[] out_size,
                                         @Cast(value="const char***") @ByPtrPtr
                                         PointerPointer out_array)

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                LongPointer shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @Cast(value="TVMArrayHandle*")
                                PointerPointer out)

\brief Allocate a nd-array's memory, including space of shape, of given spec.

Parameters:: shape - The shape of the array, the data content will be copied to out; ndim - The number of dimension of the array.; dtype_code - The type code of the dtype; dtype_bits - The number of bits of dtype; dtype_lanes - The number of lanes in the dtype.; device_type - The device type of context; device_id - The device id of context.; out - The output handle.
Returns:: 0 when success, -1 when failure happens

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                LongBuffer shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @ByPtrPtr @Cast(value="TVMArrayHandle*")
                                DLTensor out)

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                long[] shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @Cast(value="TVMArrayHandle*")
                                PointerPointer out)

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                LongPointer shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @ByPtrPtr @Cast(value="TVMArrayHandle*")
                                DLTensor out)

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                LongBuffer shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @Cast(value="TVMArrayHandle*")
                                PointerPointer out)

TVMArrayAlloc

public static int TVMArrayAlloc(@Cast(value="const tvm_index_t*")
                                long[] shape,
                                int ndim,
                                int dtype_code,
                                int dtype_bits,
                                int dtype_lanes,
                                int device_type,
                                int device_id,
                                @ByPtrPtr @Cast(value="TVMArrayHandle*")
                                DLTensor out)

TVMArrayFree

public static int TVMArrayFree(@Cast(value="TVMArrayHandle")
                               DLTensor handle)

\brief Free the TVM Array.

Parameters:: handle - The array handle to be freed.
Returns:: 0 when success, -1 when failure happens

TVMArrayCopyFromBytes

public static int TVMArrayCopyFromBytes(@Cast(value="TVMArrayHandle")
                                        DLTensor handle,
                                        Pointer data,
                                        @Cast(value="size_t")
                                        long nbytes)

\brief Copy array data from CPU byte array.

Parameters:: handle - The array handle.; data - the data pointer; nbytes - The number of bytes to copy.
Returns:: 0 when success, -1 when failure happens

TVMArrayCopyToBytes

public static int TVMArrayCopyToBytes(@Cast(value="TVMArrayHandle")
                                      DLTensor handle,
                                      Pointer data,
                                      @Cast(value="size_t")
                                      long nbytes)

\brief Copy array data to CPU byte array.

Parameters:: handle - The array handle.; data - the data pointer; nbytes - The number of bytes to copy.
Returns:: 0 when success, -1 when failure happens

TVMArrayCopyFromTo

public static int TVMArrayCopyFromTo(@Cast(value="TVMArrayHandle")
                                     DLTensor from,
                                     @Cast(value="TVMArrayHandle")
                                     DLTensor to,
                                     TVMStreamHandle stream)

\brief Copy the array, both from and to must be valid during the copy.

Parameters:: from - The array to be copied from.; to - The target space.; stream - The stream where the copy happens, can be NULL.
Returns:: 0 when success, -1 when failure happens

TVMArrayFromDLPack

public static int TVMArrayFromDLPack(DLManagedTensor from,
                                     @Cast(value="TVMArrayHandle*")
                                     PointerPointer out)

\brief Produce an array from the DLManagedTensor that shares data memory with the DLManagedTensor.

Parameters:: from - The source DLManagedTensor.; out - The output array handle.
Returns:: 0 when success, -1 when failure happens

TVMArrayFromDLPack

public static int TVMArrayFromDLPack(DLManagedTensor from,
                                     @ByPtrPtr @Cast(value="TVMArrayHandle*")
                                     DLTensor out)

TVMArrayToDLPack

public static int TVMArrayToDLPack(@Cast(value="TVMArrayHandle")
                                   DLTensor from,
                                   @Cast(value="DLManagedTensor**")
                                   PointerPointer out)

\brief Produce a DLMangedTensor from the array that shares data memory with the array.

Parameters:: from - The source array.; out - The DLManagedTensor handle.
Returns:: 0 when success, -1 when failure happens

TVMArrayToDLPack

public static int TVMArrayToDLPack(@Cast(value="TVMArrayHandle")
                                   DLTensor from,
                                   @ByPtrPtr
                                   DLManagedTensor out)

TVMDLManagedTensorCallDeleter
```
public static void TVMDLManagedTensorCallDeleter(DLManagedTensor dltensor)
```
\brief Delete (free) a DLManagedTensor's data.

Parameters:

dltensor - Pointer to the DLManagedTensor.

TVMStreamCreate

public static int TVMStreamCreate(int device_type,
                                  int device_id,
                                  @ByPtrPtr
                                  TVMStreamHandle out)

\brief Create a new runtime stream.

Parameters:: device_type - The device type of context; device_id - The device id of context; out - The new stream handle
Returns:: 0 when success, -1 when failure happens

TVMStreamFree
```
public static int TVMStreamFree(int device_type,
                                int device_id,
                                TVMStreamHandle stream)
```
\brief Free a created stream handle.

Parameters:

device_type - The device type of context

device_id - The device id of context

stream - The stream to be freed

Returns:

0 when success, -1 when failure happens

TVMSetStream
```
public static int TVMSetStream(int device_type,
                               int device_id,
                               TVMStreamHandle handle)
```
\brief Set the runtime stream of current thread to be stream. The subsequent calls to the same device_type will use the setted stream handle. The specific type of stream is runtime device dependent.

Parameters:

device_type - The device type of context

device_id - The device id of context.

handle - The stream handle.

Returns:

0 when success, -1 when failure happens

TVMSynchronize
```
public static int TVMSynchronize(int device_type,
                                 int device_id,
                                 TVMStreamHandle stream)
```
\brief Wait until all computations on stream completes.

Parameters:

device_type - The device type of context

device_id - The device id of context.

stream - The stream to be synchronized.

Returns:

0 when success, -1 when failure happens

TVMStreamStreamSynchronize

public static int TVMStreamStreamSynchronize(int device_type,
                                             int device_id,
                                             TVMStreamHandle src,
                                             TVMStreamHandle dst)

\brief Synchronize two streams of execution.

Parameters:: device_type - The device type of context; device_id - The device id of context; src - The source stream to synchronize.; dst - The destination stream to synchronize.
Returns:: 0 when success, -1 when failure happens

TVMObjectGetTypeIndex

public static int TVMObjectGetTypeIndex(TVMObjectHandle obj,
                                        @Cast(value="unsigned*")
                                        IntPointer out_tindex)

\brief Get the type_index from an object.

Parameters:: obj - The object handle.; out_tindex - the output type index.
Returns:: 0 when success, -1 when failure happens

TVMObjectGetTypeIndex

public static int TVMObjectGetTypeIndex(TVMObjectHandle obj,
                                        @Cast(value="unsigned*")
                                        IntBuffer out_tindex)

TVMObjectGetTypeIndex

public static int TVMObjectGetTypeIndex(TVMObjectHandle obj,
                                        @Cast(value="unsigned*")
                                        int[] out_tindex)

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(@Cast(value="const char*")
                                         BytePointer type_key,
                                         @Cast(value="unsigned*")
                                         IntPointer out_tindex)

\brief Convert type key to type index.

Parameters:: type_key - The key of the type.; out_tindex - the corresponding type index.
Returns:: 0 when success, -1 when failure happens

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(String type_key,
                                         @Cast(value="unsigned*")
                                         IntBuffer out_tindex)

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(@Cast(value="const char*")
                                         BytePointer type_key,
                                         @Cast(value="unsigned*")
                                         int[] out_tindex)

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(String type_key,
                                         @Cast(value="unsigned*")
                                         IntPointer out_tindex)

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(@Cast(value="const char*")
                                         BytePointer type_key,
                                         @Cast(value="unsigned*")
                                         IntBuffer out_tindex)

TVMObjectTypeKey2Index

public static int TVMObjectTypeKey2Index(String type_key,
                                         @Cast(value="unsigned*")
                                         int[] out_tindex)

TVMObjectRetain
```
public static int TVMObjectRetain(TVMObjectHandle obj)
```
\brief Increase the reference count of an object.

Parameters:

obj - The object handle. \note Internally we increase the reference counter of the object.

Returns:

0 when success, -1 when failure happens

TVMObjectFree
```
public static int TVMObjectFree(TVMObjectHandle obj)
```
\brief Free the object.

Parameters:

obj - The object handle. \note Internally we decrease the reference counter of the object. The object will be freed when every reference to the object are removed.

Returns:

0 when success, -1 when failure happens

TVMDeviceAllocDataSpace

public static int TVMDeviceAllocDataSpace(@ByVal
                                          DLContext ctx,
                                          @Cast(value="size_t")
                                          long nbytes,
                                          @Cast(value="size_t")
                                          long alignment,
                                          @ByVal
                                          DLDataType type_hint,
                                          @Cast(value="void**")
                                          PointerPointer out_data)

\brief Allocate a data space on device.

Parameters:: ctx - The device context to perform operation.; nbytes - The number of bytes in memory.; alignment - The alignment of the memory.; type_hint - The type of elements. Only needed by certain backends such as nbytes & alignment are sufficient for most backends.; out_data - The allocated device pointer.
Returns:: 0 when success, -1 when failure happens

TVMDeviceAllocDataSpace

public static int TVMDeviceAllocDataSpace(@ByVal
                                          DLContext ctx,
                                          @Cast(value="size_t")
                                          long nbytes,
                                          @Cast(value="size_t")
                                          long alignment,
                                          @ByVal
                                          DLDataType type_hint,
                                          @Cast(value="void**") @ByPtrPtr
                                          Pointer out_data)

TVMDeviceFreeDataSpace

public static int TVMDeviceFreeDataSpace(@ByVal @Cast(value="TVMContext*")
                                         DLContext ctx,
                                         Pointer ptr)

\brief Free a data space on device.

Parameters:: ctx - The device context to perform operation.; ptr - The data space.
Returns:: 0 when success, -1 when failure happens

TVMDeviceCopyDataFromTo

public static int TVMDeviceCopyDataFromTo(@Const
                                          Pointer from,
                                          @Cast(value="size_t")
                                          long from_offset,
                                          Pointer to,
                                          @Cast(value="size_t")
                                          long to_offset,
                                          @Cast(value="size_t")
                                          long num_bytes,
                                          @ByVal @Cast(value="TVMContext*")
                                          DLContext ctx_from,
                                          @ByVal @Cast(value="TVMContext*")
                                          DLContext ctx_to,
                                          @ByVal
                                          DLDataType type_hint,
                                          TVMStreamHandle stream)

\brief Copy data from one place to another.

Parameters:: from - The source array.; from_offset - The byte offeset in the from.; to - The target array.; to_offset - The byte offset in the to.; num_bytes - The size of the memory in bytes; ctx_from - The source context; ctx_to - The target context; type_hint - The type of elements, only neded by certain backends. can be useful for cross device endian converison.; stream - Optional stream object.
Returns:: 0 when success, -1 when failure happens.

TVMObjectDerivedFrom

public static int TVMObjectDerivedFrom(@Cast(value="uint32_t")
                                       int child_type_index,
                                       @Cast(value="uint32_t")
                                       int parent_type_index,
                                       IntPointer is_derived)

\brief Check that an object is derived from another.

Parameters:: child_type_index - The type index of the derived type.; parent_type_index - The type index of the parent type.; is_derived - A boolean representing whether this predicate holds.
Returns:: 0 when success, -1 when failure happens.

TVMObjectDerivedFrom

public static int TVMObjectDerivedFrom(@Cast(value="uint32_t")
                                       int child_type_index,
                                       @Cast(value="uint32_t")
                                       int parent_type_index,
                                       IntBuffer is_derived)

TVMObjectDerivedFrom

public static int TVMObjectDerivedFrom(@Cast(value="uint32_t")
                                       int child_type_index,
                                       @Cast(value="uint32_t")
                                       int parent_type_index,
                                       int[] is_derived)

GetVectorBytes

@Namespace(value="tvm::runtime")
public static int GetVectorBytes(@ByVal
                                                                   DataType dtype)

\brief Get the number of bytes needed in a vector.

Parameters:: dtype - The data type.
Returns:: Number of bytes needed.

TypeMatch

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean TypeMatch(@ByVal
                                                                                        DLDataType t,
                                                                                        int code,
                                                                                        int bits,
                                                                                        int lanes)

\brief Check whether type matches the given spec.

Parameters:: t - The type; code - The type code.; bits - The number of bits to be matched.; lanes - The number of lanes in the type.

TypeMatch

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean TypeMatch(@ByVal
                                                                                        DLDataType t,
                                                                                        int code,
                                                                                        int bits)

TypeEqual

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean TypeEqual(@ByVal
                                                                                        DLDataType lhs,
                                                                                        @ByVal
                                                                                        DLDataType rhs)

\brief Check whether two types are equal .

Parameters:: lhs - The left operand.; rhs - The right operand.

GetCustomTypeName

@Namespace(value="tvm::runtime")
 @StdString
public static BytePointer GetCustomTypeName(@Cast(value="uint8_t")
                                                                                           byte type_code)

\brief Runtime utility for getting custom type name from code

Parameters:: type_code - Custom type code
Returns:: Custom type name

GetCustomTypeRegistered

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean GetCustomTypeRegistered(@Cast(value="uint8_t")
                                                                                                      byte type_code)

\brief Runtime utility for checking whether custom type is registered

Parameters:: type_code - Custom type code
Returns:: Bool representing whether type is registered

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  BytePointer s,
                                                                                                  @Cast(value="const char**")
                                                                                                  PointerPointer scan)

\brief Runtime utility for parsing string of the form "custom[]"

Parameters:: s - String to parse; scan - pointer to parsing pointer, which is scanning across s
Returns:: type code of custom type parsed

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  BytePointer s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  BytePointer scan)

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  String s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  ByteBuffer scan)

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  BytePointer s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  byte[] scan)

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  String s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  BytePointer scan)

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  BytePointer s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  ByteBuffer scan)

ParseCustomDatatype

@Namespace(value="tvm::runtime")
 @Cast(value="uint8_t")
public static byte ParseCustomDatatype(@StdString
                                                                                                  String s,
                                                                                                  @Cast(value="const char**") @ByPtrPtr
                                                                                                  byte[] scan)

DLDataTypeCode2Str

@Namespace(value="tvm::runtime")
 @Cast(value="const char*")
public static BytePointer DLDataTypeCode2Str(@Cast(value="DLDataTypeCode")
                                                                                                            int type_code)

\brief Convert type code to its name

Parameters:: type_code - The type code .
Returns:: The name of type code.

String2DLDataType

@Namespace(value="tvm::runtime")
 @ByVal
public static DLDataType String2DLDataType(@StdString
                                                                                      BytePointer s)

\brief convert a string to TVM type.

Parameters:: s - The string to be converted.
Returns:: The corresponding tvm type.

String2DLDataType

@Namespace(value="tvm::runtime")
 @ByVal
public static DLDataType String2DLDataType(@StdString
                                                                                      String s)

DLDataType2String

@Namespace(value="tvm::runtime")
 @StdString
public static BytePointer DLDataType2String(@ByVal
                                                                                           DLDataType t)

\brief convert a TVM type to string.

Parameters:: t - The type to be converted.
Returns:: The corresponding tvm type in string.

shiftLeft

@Namespace(value="tvm::runtime")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                       Pointer os,
                                                                                                                                       @ByVal
                                                                                                                                       DLDataType t)

shiftLeft

@Namespace(value="tvm::runtime")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                       Pointer os,
                                                                                                                                       @Const @ByRef
                                                                                                                                       DataType dtype)

makeArrayNode
```
@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="make_object<tvm::runtime::ArrayNode>")
public static ArrayNodePtr makeArrayNode()
```
\brief Allocate an object using default allocator.

Parameters:

args - arguments to the constructor. \tparam T the node type.

Returns:

The ObjectPtr to the allocated object.

add

@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="operator +")
public static TVMString add(@Const @ByRef
                                                                                                   TVMString lhs,
                                                                                                   @Const @ByRef
                                                                                                   TVMString rhs)

\brief An object representing string moved from std::string.

add

@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="operator +")
public static TVMString add(@Const @ByRef
                                                                                                   TVMString lhs,
                                                                                                   @StdString
                                                                                                   BytePointer rhs)

add

@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="operator +")
public static TVMString add(@Const @ByRef
                                                                                                   TVMString lhs,
                                                                                                   @StdString
                                                                                                   String rhs)

add

@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="operator +")
public static TVMString add(@StdString
                                                                                                   BytePointer lhs,
                                                                                                   @Const @ByRef
                                                                                                   TVMString rhs)

add

@Namespace(value="tvm::runtime")
 @ByVal
 @Name(value="operator +")
public static TVMString add(@StdString
                                                                                                   String lhs,
                                                                                                   @Const @ByRef
                                                                                                   TVMString rhs)

lessThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                                   TVMString lhs,
                                                                                                                   @StdString
                                                                                                                   BytePointer rhs)

lessThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                                   TVMString lhs,
                                                                                                                   @StdString
                                                                                                                   String rhs)

lessThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@StdString
                                                                                                                   BytePointer lhs,
                                                                                                                   @Const @ByRef
                                                                                                                   TVMString rhs)

lessThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@StdString
                                                                                                                   String lhs,
                                                                                                                   @Const @ByRef
                                                                                                                   TVMString rhs)

lessThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                                   TVMString lhs,
                                                                                                                   @Const @ByRef
                                                                                                                   TVMString rhs)

greaterThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@Const @ByRef
                                                                                                                      TVMString lhs,
                                                                                                                      @StdString
                                                                                                                      BytePointer rhs)

greaterThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@Const @ByRef
                                                                                                                      TVMString lhs,
                                                                                                                      @StdString
                                                                                                                      String rhs)

greaterThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@StdString
                                                                                                                      BytePointer lhs,
                                                                                                                      @Const @ByRef
                                                                                                                      TVMString rhs)

greaterThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@StdString
                                                                                                                      String lhs,
                                                                                                                      @Const @ByRef
                                                                                                                      TVMString rhs)

greaterThan

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@Const @ByRef
                                                                                                                      TVMString lhs,
                                                                                                                      @Const @ByRef
                                                                                                                      TVMString rhs)

lessThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@Const @ByRef
                                                                                                                          TVMString lhs,
                                                                                                                          @StdString
                                                                                                                          BytePointer rhs)

lessThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@Const @ByRef
                                                                                                                          TVMString lhs,
                                                                                                                          @StdString
                                                                                                                          String rhs)

lessThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@StdString
                                                                                                                          BytePointer lhs,
                                                                                                                          @Const @ByRef
                                                                                                                          TVMString rhs)

lessThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@StdString
                                                                                                                          String lhs,
                                                                                                                          @Const @ByRef
                                                                                                                          TVMString rhs)

lessThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@Const @ByRef
                                                                                                                          TVMString lhs,
                                                                                                                          @Const @ByRef
                                                                                                                          TVMString rhs)

greaterThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@Const @ByRef
                                                                                                                             TVMString lhs,
                                                                                                                             @StdString
                                                                                                                             BytePointer rhs)

greaterThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@Const @ByRef
                                                                                                                             TVMString lhs,
                                                                                                                             @StdString
                                                                                                                             String rhs)

greaterThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@StdString
                                                                                                                             BytePointer lhs,
                                                                                                                             @Const @ByRef
                                                                                                                             TVMString rhs)

greaterThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@StdString
                                                                                                                             String lhs,
                                                                                                                             @Const @ByRef
                                                                                                                             TVMString rhs)

greaterThanEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@Const @ByRef
                                                                                                                             TVMString lhs,
                                                                                                                             @Const @ByRef
                                                                                                                             TVMString rhs)

equals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                                  TVMString lhs,
                                                                                                                  @StdString
                                                                                                                  BytePointer rhs)

equals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                                  TVMString lhs,
                                                                                                                  @StdString
                                                                                                                  String rhs)

equals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@StdString
                                                                                                                  BytePointer lhs,
                                                                                                                  @Const @ByRef
                                                                                                                  TVMString rhs)

equals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@StdString
                                                                                                                  String lhs,
                                                                                                                  @Const @ByRef
                                                                                                                  TVMString rhs)

equals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                                  TVMString lhs,
                                                                                                                  @Const @ByRef
                                                                                                                  TVMString rhs)

notEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                                     TVMString lhs,
                                                                                                                     @StdString
                                                                                                                     BytePointer rhs)

notEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                                     TVMString lhs,
                                                                                                                     @StdString
                                                                                                                     String rhs)

notEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@StdString
                                                                                                                     BytePointer lhs,
                                                                                                                     @Const @ByRef
                                                                                                                     TVMString rhs)

notEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@StdString
                                                                                                                     String lhs,
                                                                                                                     @Const @ByRef
                                                                                                                     TVMString rhs)

notEquals

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                                     TVMString lhs,
                                                                                                                     @Const @ByRef
                                                                                                                     TVMString rhs)

shiftLeft

@Namespace(value="tvm::runtime")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                       Pointer out,
                                                                                                                                       @Const @ByRef
                                                                                                                                       TVMString input)

NullOpt

@Namespace(value="tvm")
 @MemberGetter
 @Const
 @ByRef
public static NullOptType NullOpt()

\brief Optional container that to represent to a Nullable variant of T. \tparam T The original ObjectRef.



  Optional<String> opt0 = nullptr;
  Optional<String> opt1 = String("xyz");
  CHECK(opt0 == nullptr);
  CHECK(opt1 == "xyz");

SaveDLTensor

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean SaveDLTensor(Stream strm,
                                                                                           @Const
                                                                                           DLTensor tensor)

\brief Save a DLTensor to stream

Parameters:: strm - The output stream; tensor - The tensor to be saved.

GetDataSize

@Namespace(value="tvm::runtime")
 @Cast(value="size_t")
public static long GetDataSize(@Const @ByRef
                                                                                         DLTensor arr)

\brief return the size of data the DLTensor hold, in term of number of bytes

Parameters:: arr - the input DLTensor
Returns:: number of bytes of data in the DLTensor.

IsContiguous

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean IsContiguous(@Const @ByRef
                                                                                           DLTensor arr)

\brief check if a DLTensor is contiguous.

Parameters:: arr - The input DLTensor.
Returns:: The check result.

TVMArrayHandleToObjectHandle

@Namespace(value="tvm::runtime")
public static TVMObject TVMArrayHandleToObjectHandle(@Cast(value="TVMArrayHandle")
                                                                                       DLTensor handle)

kTVMNDArrayMagic

@Namespace(value="tvm::runtime")
 @MemberGetter
 @Cast(value="const uint64_t")
public static long kTVMNDArrayMagic()

\brief Magic number for NDArray file

RuntimeEnabled

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean RuntimeEnabled(@StdString
                                                                                             BytePointer target)

\brief Check if runtime module is enabled for target.

Parameters:: target - The target module name.
Returns:: Whether runtime is enabled.

RuntimeEnabled

@Namespace(value="tvm::runtime")
 @Cast(value="bool")
public static boolean RuntimeEnabled(@StdString
                                                                                             String target)

tvm_module_ctx

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_module_ctx()

\brief Global variable to store module context.

tvm_dev_mblob

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_dev_mblob()

\brief Global variable to store device module blob

tvm_dev_mblob_nbytes

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_dev_mblob_nbytes()

\brief Number of bytes of device module blob.

tvm_set_device

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_set_device()

\brief global function to set device

tvm_global_barrier_state

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_global_barrier_state()

\brief Auxiliary counter to global barrier.

tvm_prepare_global_barrier

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_prepare_global_barrier()

\brief Prepare the global barrier before kernels that uses global barrier.

tvm_module_main

@Namespace(value="tvm::runtime::symbol")
 @MemberGetter
 @Cast(value="const char*")
public static BytePointer tvm_module_main()

\brief Placeholder for the module's entry function.

ArgTypeCode2Str
```
@Namespace(value="tvm::runtime")
 @Cast(value="const char*")
public static BytePointer ArgTypeCode2Str(int type_code)
```
\brief Convert argument type code to string.

Parameters:

type_code - The input type code.

Returns:

The corresponding string repr.

Class tvm_runtime

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.tvm.presets.tvm_runtime

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.tvm.presets.tvm_runtime

Methods inherited from class java.lang.Object

Field Detail

DLPACK_VERSION

kDLCPU

kDLGPU

kDLCPUPinned

kDLOpenCL

kDLVulkan

kDLMetal

kDLVPI

kDLROCM

kDLExtDev

kDLInt

kDLUInt

kDLFloat

kDLBfloat

DMLC_USE_GLOG

DMLC_LOG_FATAL_THROW

DMLC_LOG_BEFORE_THROW

DMLC_LOG_CUSTOMIZE

DMLC_LOG_DEBUG

DMLC_LOG_NODATE

DMLC_USE_HDFS

DMLC_USE_S3

DMLC_USE_PS

DMLC_USE_CXX11

DMLC_MODERN_THREAD_LOCAL

DMLC_ENABLE_RTTI

DMLC_USE_FOPEN64

DMLC_IO_USE_LITTLE_ENDIAN

DMLC_ENABLE_STD_THREAD

DMLC_USE_REGEX

DMLC_THROW_EXCEPTION

DMLC_NO_EXCEPTION

DMLC_LITTLE_ENDIAN

DMLC_IO_NO_ENDIAN_SWAP

TVM_VERSION

kDLAOCL

kDLSDAccel

kOpenGL

kDLMicroDev

kDLHexagon

kDLWebGPU

kTVMArgInt

kTVMArgFloat

kTVMOpaqueHandle

kTVMNullptr

kTVMDataType

kTVMContext

kTVMDLTensorHandle

kTVMObjectHandle

kTVMModuleHandle

kTVMPackedFuncHandle

kTVMStr

kTVMBytes

kTVMNDArrayHandle

kTVMObjectRValueRefArg

kTVMExtBegin

kTVMNNVMFirst

kTVMNNVMLast

kTVMExtReserveEnd

kTVMExtEnd

TVM_OBJECT_ATOMIC_REF_COUNTER

TVM_USE_CXX14_STRING_VIEW_HASH

TVM_USE_CXX17_STRING_VIEW_HASH

TVM_RUNTIME_HEADER_ONLY

Constructor Detail

tvm_runtime

Method Detail

DMLC_USE_REGEX

DMLC_THROW_EXCEPTION

DMLC_NO_EXCEPTION

BeginPtr