tensorrt-cu12-bindings 10.8.0.43__cp312-none-win_amd64.whl → 10.9.0.34__cp312-none-win_amd64.whl

tensorrt_bindings/__init__.py

@@ -31,20 +31,25 @@ else:
 
 
 if not _libs_wheel_imported and sys.platform.startswith("win"):
+    log_found_dlls = bool(int(os.environ.get("TRT_LOG_FOUND_DLLS", 0)))
     # On Windows, we need to manually open the TensorRT libraries - otherwise we are unable to
     # load the bindings. If we imported the tensorrt_libs wheel, then that should have taken care of it for us.
     def find_lib(name):
         paths = os.environ["PATH"].split(os.path.pathsep)
+
         # Add ../tensorrt.libs to the search path.  This allows repackaging non-standalone TensorRT wheels as standalone
         # using delvewheel (with the --no-mangle-all flag set) to work properly.
         paths.append(os.path.join(os.path.dirname(__file__), os.pardir, "tensorrt.libs"))
+
         for path in paths:
             libpath = os.path.join(path, name)
             if os.path.isfile(libpath):
+                if log_found_dlls:
+                    print(f"Found {name} in path: {libpath}")
                 return libpath
 
-        if name.startswith("cudnn") or name.startswith("cublas"):
-            return ""
+        if name.startswith("nvinfer_builder_resource"):
+            return None
 
         raise FileNotFoundError(
             "Could not find: {:}. Is it on your PATH?\nNote: Paths searched were:\n{:}".format(name, paths)
@@ -54,11 +59,9 @@ if not _libs_wheel_imported and sys.platform.startswith("win"):
     LIBRARIES = {
         "tensorrt": [
             "nvinfer_10.dll",
-            "cublas64_12.dll",
-            "cublasLt64_12.dll",
-            "cudnn64_##CUDNN_MAJOR##.dll",
             "nvinfer_plugin_10.dll",
             "nvonnxparser_10.dll",
+            "nvinfer_builder_resource_10.dll",
         ],
         "tensorrt_dispatch": [
             "nvinfer_dispatch_10.dll",
@@ -70,14 +73,16 @@ if not _libs_wheel_imported and sys.platform.startswith("win"):
 
     for lib in LIBRARIES:
         lib_path = find_lib(lib)
-        if lib_path != "":
-            ctypes.CDLL(lib_path)
+        if not lib_path:
+            continue
+        assert os.path.isfile(lib_path)
+        ctypes.CDLL(lib_path)
 
 del _libs_wheel_imported
 
 from .tensorrt import *
 
-__version__ = "10.8.0.43"
+__version__ = "10.9.0.34"
 
 
 # Provides Python's `with` syntax

tensorrt_bindings/plugin/_export.py

@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 
+import tensorrt as trt
 from types import ModuleType
 import importlib
 
@@ -34,3 +35,5 @@ def public_api(module: ModuleType = None, symbol: str = None):
         return obj
 
     return export_impl
+
+IS_AOT_ENABLED = hasattr(trt, "QuickPluginCreationRequest")

tensorrt_bindings/plugin/_lib.py

@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,13 +20,16 @@ import types
 import typing
 from typing import Callable, Tuple, List
 import numpy as np
-
-from ._plugin_class import _TemplatePlugin
+from ._plugin_class import _TemplateJITPlugin
+from ._export import IS_AOT_ENABLED
+if IS_AOT_ENABLED:
+    from ._plugin_class import _TemplateAOTPlugin
 from ._validate import (
     _parse_register_inputs,
     _parse_register_return,
     _validate_autotune,
     _validate_impl,
+    _validate_aot_impl,
     _validate_name_and_namespace,
 )
 from ._utils import (
@@ -91,11 +94,13 @@ class PluginDef:
         self.plugin_id = None  # includes namespace (format is ns::name)
         self.register_func = None
         self.impl_func = None
+        self.aot_impl_func = None
         self.autotune_func = None
         self.autotune_attr_names = None
         self.input_tensor_names = None
         self.input_attrs = None  # map name -> type
         self.impl_attr_names = None
+        self.aot_impl_attr_names = None
         self.num_outputs = None
         self.input_arg_schema = None
         self.expects_tactic = None
@@ -195,24 +200,26 @@ class PluginDef:
                     )
                 )
 
-        plg = plg_creator.create_plugin(
-            name,
-            namespace,
-            trt.PluginFieldCollection(fields),
-            trt.TensorRTPhase.BUILD,
-        )
-        plg.init(
-            self.register_func,
-            attrs,
-            self.impl_attr_names,
-            self.impl_func,
-            self.autotune_attr_names,
-            self.autotune_func,
-            self.expects_tactic,
-        )
+        def create_plugin_instance(quick_plugin_creation_request: "trt.QuickPluginCreationRequest" = None):
+            if quick_plugin_creation_request is None:
+                plg = plg_creator.create_plugin(
+                    name,
+                    namespace,
+                    trt.PluginFieldCollection(fields),
+                    trt.TensorRTPhase.BUILD
+                )
+            else:
+                plg = plg_creator.create_plugin(
+                    name,
+                    namespace,
+                    trt.PluginFieldCollection(fields),
+                    trt.TensorRTPhase.BUILD,
+                    quick_plugin_creation_request
+                )
 
-        return input_tensors, [], plg
+            return input_tensors, [], plg
 
+        return create_plugin_instance
 
 class _TemplatePluginCreator(trt.IPluginCreatorV3Quick):
     def __init__(self, name, namespace, attrs):
@@ -246,7 +253,7 @@ class _TemplatePluginCreator(trt.IPluginCreatorV3Quick):
 
         self.field_names = trt.PluginFieldCollection(field_names)
 
-    def create_plugin(self, name, namespace, fc, phase):
+    def create_plugin(self, name, namespace, fc, phase, qpcr: "trt.QuickPluginCreationRequest" = None):
         desc = QDP_REGISTRY[f"{namespace}::{name}"]
         name = name
         namespace = namespace
@@ -271,18 +278,83 @@ class _TemplatePluginCreator(trt.IPluginCreatorV3Quick):
                 else:
                     attrs[f.name] = attr_type_annot(f.data)
 
-        plg = _TemplatePlugin(name, namespace, desc.num_outputs)
-        plg.init(
-            desc.register_func,
-            attrs,
-            desc.impl_attr_names,
-            desc.impl_func,
-            desc.autotune_attr_names,
-            desc.autotune_func,
-            desc.expects_tactic,
-        )
-        return plg
+        jit_or_aot = None # True if JIT is to be created, False if AOT. Not None will be asserted before plugin creation.
+
+        if qpcr is None:
+            plg = _TemplateJITPlugin(name, namespace, desc.num_outputs)
+
+            plg.init(
+                desc.register_func,
+                attrs,
+                desc.impl_attr_names,
+                desc.impl_func,
+                desc.autotune_attr_names,
+                desc.autotune_func,
+                desc.expects_tactic,
+            )
+
+            return plg
+
+        # If there is a strict preference, that takes precedence
+        if qpcr == trt.QuickPluginCreationRequest.STRICT_AOT:
+            if desc.aot_impl_func is None:
+                raise ValueError(f"AOT implementation requested, but not defined for '{desc.plugin_id}'. Was @trt.plugin.aot_impl defined?")
+            jit_or_aot = False
+        elif qpcr == trt.QuickPluginCreationRequest.STRICT_JIT:
+            if desc.impl_func is None:
+                raise ValueError(f"JIT implementation requested, but not defined for '{desc.plugin_id}'. Was @trt.plugin.impl defined?")
+            jit_or_aot = True
+        else:
+            aot_defined = desc.aot_impl_func is not None
+            jit_defined = desc.impl_func is not None
+
+            # A preferemce must be indicated if both AOT and JIT implementations are defined
+            if aot_defined and jit_defined:
+                if qpcr == trt.QuickPluginCreationRequest.PREFER_AOT:
+                    jit_or_aot = False
+                elif qpcr == trt.QuickPluginCreationRequest.PREFER_JIT:
+                    jit_or_aot = True
+                else:
+                    raise ValueError(f"Plugin '{desc.plugin_id}' has both AOT and JIT implementations. NetworkDefinitionCreationFlag.PREFER_AOT_PYTHON_PLUGINS or NetworkDefinitionCreationFlag.PREFER_JIT_PYTHON_PLUGINS should be specified.")
+            else:
+                # If only one implementation is defined, use that.
+                # Any preference specified is ignored. If the preference is strong, a strict flag should have been specified.
+                if aot_defined:
+                    jit_or_aot = False
+                elif jit_defined:
+                    jit_or_aot = True
+                else:
+                    raise ValueError(f"Plugin '{desc.plugin_id}' does not have either a AOT or JIT implementation.")
+
+        assert jit_or_aot is not None
+
+        if jit_or_aot:
+            plg = _TemplateJITPlugin(name, namespace, desc.num_outputs)
+
+            plg.init(
+                desc.register_func,
+                attrs,
+                desc.impl_attr_names,
+                desc.impl_func,
+                desc.autotune_attr_names,
+                desc.autotune_func,
+                desc.expects_tactic,
+            )
 
+        else:
+            plg = _TemplateAOTPlugin(name, namespace, desc.num_outputs)
+
+            plg.init(
+                desc.register_func,
+                attrs,
+                desc.aot_impl_attr_names,
+                desc.aot_impl_func,
+                desc.autotune_attr_names,
+                desc.autotune_func
+            )
+
+        # the caller can determine if the created plugin is an AOT or JIT plugin by inspecting the interface info
+        return plg
 
 def _register_plugin_creator(name: str, namespace: str, attrs_types):
     plg_registry = trt.get_plugin_registry()
@@ -445,6 +517,102 @@ def impl(plugin_id: str) -> Callable:
 
     return decorator
 
+# Decorator for `tensorrt.plugin.aot_impl`
+@public_api()
+def aot_impl(plugin_id: str) -> Callable:
+    """
+    Wraps a function to define an Ahead-of-Time (AOT) implementation for a plugin already registered through `trt.plugin.register`.
+
+    This API is only intended to be used as a decorator. The decorated function is not required to have type hints for input arguments or return value;
+    however, any type hints specified will be validated against the `trt.plugin.register` signature for consistency.
+
+    The schema for the function is as follows:
+    .. code-block:: text
+
+        (inp0: TensorDesc, inp1: TensorDesc, ..., attr0: SupportedAttrType, attr1: SupportedAttrType, outputs: Tuple[TensorDesc], tactic: Optional[int]) -> Tuple[str, str, KernelLaunchParams, SymExprs]
+
+    * Input tensors are passed first, each described by a `TensorDesc`.
+    * Plugin attributes are declared next.
+       * Not all attributes included in `trt.plugin.register` must be specified here -- they could be a subset.
+       * NOTE: Plugin attributes are not serialized into the engine when using an AOT implementation.
+    * `tactic` is an optional argument. If the plugin is using custom tactics, it must be specified to receive the tactic value to use for the current execution of the plugin.
+
+    Args:
+        plugin_id: The ID for the plugin in the form "{namespace}::{name}", which must match that used during `trt.plugin.register`
+
+    :returns:
+        - kernel_name: The name of the kernel.
+        - compiled_kernel: Compiled form of the kernel. Presently, only PTX is supported.
+        - launch_params: The launch parameters for the kernel
+        - extra_args: Symbolic expressions for scalar inputs to the kernel, located after the tensor inputs and before the tensor outputs
+
+    .. code-block:: python
+        :linenos:
+        :caption: Implementation of an elementwise plugin with an OpenAI Triton kernel
+
+        import tensorrt.plugin as trtp
+        import triton
+        import triton.language as tl
+
+        @triton.jit
+        def add_kernel(x_ptr, n_elements, y_ptr, BLOCK_SIZE: tl.constexpr):
+            pid = tl.program_id(0)
+            offsets = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+            mask = offsets < n_elements
+            x = tl.load(x_ptr + offsets, mask=mask)
+            tl.store(y_ptr + offsets, x + 1, mask=mask)
+
+        @trtp.register("my::add_plugin")
+        def add_plugin_desc(inp0: trtp.TensorDesc, block_size: int) -> Tuple[trtp.TensorDesc]:
+            return inp0.like()
+
+        @trtp.aot_impl("my::elemwise_add_plugin")
+        def add_plugin_aot_impl(
+            inp0: trtp.TensorDesc, block_size: int, single_tactic: bool, outputs: Tuple[trtp.TensorDesc], tactic: int
+        ) -> Tuple[Union[str, bytes], Union[str, bytes], trtp.KernelLaunchParams, trtp.SymExprs]:
+
+            type_str = "fp32" if inp0.dtype == trt.float32 else "fp16"
+
+            src = triton.compiler.ASTSource(
+                fn=add_kernel,
+                signature=f"*{type_str},i32,*{type_str}",
+                constants={
+                    "BLOCK_SIZE": block_size,
+                },
+            )
+
+            compiled_kernel = triton.compile(src)
+
+            N = inp0.shape_expr.numel()
+            launch_params = trtp.KernelLaunchParams()
+
+            # grid dims
+            launch_params.grid_x = trtp.cdiv(N, block_size)
+            # block dims
+            launch_params.block_x = compiled_kernel.metadata.num_warps * 32
+            # shared memory
+            launch_params.shared_mem = compiled_kernel.metadata.shared
+
+            extra_args = trtp.SymIntExprs(1)
+            extra_args[0] = trtp.SymInt32(N)
+
+            return compiled_kernel.metadata.name, compiled_kernel.asm["ptx"], launch_params, extra_args
+    """
+    def decorator(aot_impl_func: Callable):
+        if plugin_id not in QDP_REGISTRY:
+            raise ValueError(
+                f"Plugin {plugin_id} is not registered. Did you register it with tensorrt.plugin.register API?"
+            )
+
+        plugin_def = QDP_REGISTRY[plugin_id]
+        aot_impl_attr_names = _validate_aot_impl(aot_impl_func, plugin_def)
+
+        plugin_def.aot_impl_func = aot_impl_func
+        plugin_def.aot_impl_attr_names = aot_impl_attr_names
+        return aot_impl_func
+
+    return decorator
+
 
 # Decorator for `tensorrt.plugin.autotune`
 @public_api()

tensorrt_bindings/plugin/_plugin_class.py

@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,25 +15,27 @@
 # limitations under the License.
 #
 import tensorrt as trt
-from typing import Tuple
+from typing import Tuple, Union
 
 import numpy as np
 from ._utils import _numpy_to_plugin_field_type, _built_in_to_plugin_field_type
-from ._tensor import TensorDesc, Tensor, Shape, ShapeExpr, ShapeExprs
+from ._tensor import TensorDesc, Tensor, Shape, ShapeExpr, ShapeExprs, SymIntExpr, SymExprs, SymInt32
+from ._export import IS_AOT_ENABLED
+if IS_AOT_ENABLED:
+    from ._tensor import KernelLaunchParams
 from ._autotune import _TypeFormatCombination
 
+from ._export import public_api
 
-class _TemplatePlugin(
+class _TemplatePluginBase(
     trt.IPluginV3,
     trt.IPluginV3QuickCore,
     trt.IPluginV3QuickBuild,
-    trt.IPluginV3QuickRuntime,
 ):
     def __init__(self, name, namespace, num_outputs):
         trt.IPluginV3.__init__(self)
         trt.IPluginV3QuickCore.__init__(self)
         trt.IPluginV3QuickBuild.__init__(self)
-        trt.IPluginV3QuickRuntime.__init__(self)
 
         self.plugin_version = "1"
         self.input_types = []
@@ -46,28 +48,6 @@ class _TemplatePlugin(
         self.autotune_combs = []
         self.supported_combs = {}
         self.curr_comb = None
-        self.expects_tactic = False
-
-    def init(
-        self,
-        register_function,
-        attrs,
-        impl_attr_names,
-        impl_function,
-        autotune_attr_names,
-        autotune_function,
-        expects_tactic,
-    ):
-        self.register_function = register_function
-        self.impl_function = impl_function
-        self.attrs = attrs
-        self.impl_attr_names = impl_attr_names
-        self.autotune_attr_names = autotune_attr_names
-        self.autotune_function = autotune_function
-        self.expects_tactic = expects_tactic
-
-    def get_capability_interface(self, type):
-        return self
 
     def get_num_outputs(self):
         return self.num_outputs
@@ -140,7 +120,7 @@ class _TemplatePlugin(
 
     def get_output_shapes(self, inputs, shape_inputs, exprBuilder):
         assert len(shape_inputs) == 0  # Shape inputs are not yet supported for QDPs
-        ShapeExpr._exprBuilder = exprBuilder
+        SymIntExpr._exprBuilder = exprBuilder
         self.input_descs = []
         for i in range(len(inputs)):
             desc = TensorDesc()
@@ -247,6 +227,45 @@ class _TemplatePlugin(
 
         return ret_supported_combs
 
+    def get_aliased_input(self, output_index: int):
+        return self.aliased_map[output_index]
+
+    def get_valid_tactics(self):
+        tactics = self.supported_combs.get(self.curr_comb)
+        assert tactics is not None
+        return list(tactics)
+
+    def set_tactic(self, tactic):
+        self._tactic = tactic
+
+class _TemplateJITPlugin(_TemplatePluginBase, trt.IPluginV3QuickRuntime):
+    def __init__(self, name, namespace, num_outputs):
+        super().__init__(name, namespace, num_outputs)
+        trt.IPluginV3QuickRuntime.__init__(self)
+
+        self.expects_tactic = False
+
+    def init(
+        self,
+        register_function,
+        attrs,
+        impl_attr_names,
+        impl_function,
+        autotune_attr_names,
+        autotune_function,
+        expects_tactic,
+    ):
+        self.register_function = register_function
+        self.impl_function = impl_function
+        self.attrs = attrs
+        self.impl_attr_names = impl_attr_names
+        self.autotune_attr_names = autotune_attr_names
+        self.autotune_function = autotune_function
+        self.expects_tactic = expects_tactic
+
+    def get_capability_interface(self, type):
+        return self
+
     def enqueue(
         self,
         input_desc,
@@ -305,20 +324,136 @@ class _TemplatePlugin(
         else:
             self.impl_function(*input_tensors, *val, output_tensors, stream=stream)
 
-    def get_aliased_input(self, output_index: int):
-        return self.aliased_map[output_index]
-
-    def get_valid_tactics(self):
-        tactics = self.supported_combs.get(self.curr_comb)
-        assert tactics is not None
-        return list(tactics)
-
-    def set_tactic(self, tactic):
-        self._tactic = tactic
-
     def clone(self):
-        cloned_plugin = _TemplatePlugin(
+        cloned_plugin = _TemplateJITPlugin(
             self.plugin_name, self.plugin_namespace, self.num_outputs
         )
         cloned_plugin.__dict__.update(self.__dict__)
         return cloned_plugin
+
+if IS_AOT_ENABLED:
+    class _TemplateAOTPlugin(
+        _TemplatePluginBase,
+        trt.IPluginV3QuickAOTBuild,
+    ):
+        def __init__(self, name, namespace, num_outputs):
+            _TemplatePluginBase.__init__(self, name, namespace, num_outputs)
+            trt.IPluginV3QuickAOTBuild.__init__(self)
+            self.kernel_map = {}
+
+        def set_tactic(self, tactic):
+            self._tactic = tactic
+
+        def init(
+            self,
+            register_function,
+            attrs,
+            aot_impl_attr_names,
+            aot_impl_function,
+            autotune_attr_names,
+            autotune_function
+        ):
+            self.register_function = register_function
+            self.aot_impl_function = aot_impl_function
+            self.attrs = attrs
+            self.aot_impl_attr_names = aot_impl_attr_names
+            self.autotune_attr_names = autotune_attr_names
+            self.autotune_function = autotune_function
+
+        def get_capability_interface(self, type):
+            return self
+
+        def get_kernel(self, inputDesc, outputDesc):
+            io_types = []
+            io_formats = []
+
+            for i, desc in enumerate(inputDesc):
+                io_types.append(desc.type)
+                io_formats.append(desc.format)
+
+            for i, desc in enumerate(outputDesc):
+                io_types.append(desc.type)
+                io_formats.append(desc.format)
+
+            key = (tuple(io_types), tuple(io_formats), self._tactic)
+
+            assert key in self.kernel_map, "key {} not in kernel_map".format(key)
+
+            kernel_name, ptx = self.kernel_map[key]
+
+            return kernel_name, ptx.encode() if isinstance(ptx, str) else ptx
+
+        def get_launch_params(self, inDimsExprs, in_out, num_inputs, launchParams, symExprSetter, exprBuilder):
+
+            SymIntExpr._exprBuilder = exprBuilder
+
+            if len(self.attrs) > 0:
+                _, val = zip(*self.attrs.items())
+            else:
+                val = ()
+
+            io_types = []
+            io_formats = []
+
+            for i, desc in enumerate(in_out):
+                if i < num_inputs:
+                    self.input_descs[i]._immutable = False
+                    self.input_descs[i].shape = Shape(desc)
+                    self.input_descs[i].dtype = desc.desc.type
+                    self.input_descs[i].format = desc.desc.format
+                    self.input_descs[i].scale = desc.desc.scale
+                    io_types.append(desc.desc.type)
+                    io_formats.append(desc.desc.format)
+                    self.input_descs[i]._immutable = True
+                else:
+                    self.output_descs[i - num_inputs]._immutable = False
+                    self.output_descs[i - num_inputs].shape = Shape(desc)
+                    self.output_descs[i - num_inputs].dtype = desc.desc.type
+                    self.output_descs[i - num_inputs].format = desc.desc.format
+                    self.output_descs[i - num_inputs].scale = desc.desc.scale
+                    io_types.append(desc.desc.type)
+                    io_formats.append(desc.desc.format)
+                    self.output_descs[i - num_inputs]._immutable = True
+
+            kernel_name, ptx, launch_params, extra_args = self.aot_impl_function(
+                *self.input_descs, *val, self.output_descs, self._tactic
+            )
+
+            if not isinstance(kernel_name, str) and not isinstance(kernel_name, bytes):
+                raise TypeError(f"Kernel name must be a 'str' or 'bytes'.  Got: {type(kernel_name)}.")
+
+            if not isinstance(ptx, str) and not isinstance(ptx, bytes):
+                raise TypeError(f"PTX/CUBIN must be a 'str' or 'bytes'.  Got: {type(ptx)}.")
+
+            if not isinstance(launch_params, KernelLaunchParams):
+                raise TypeError(f"Launch params must be a 'tensorrt.plugin.KernelLaunchParams'.  Got: {type(launch_params)}.")
+
+            if not isinstance(extra_args, SymExprs):
+                raise TypeError(f"Extra args must be a 'tensorrt.plugin.SymIntExprs'.  Got: {type(extra_args)}.")
+
+            launchParams.grid_x = launch_params.grid_x()
+            launchParams.grid_y = launch_params.grid_y()
+            launchParams.grid_z = launch_params.grid_z()
+            launchParams.block_x = launch_params.block_x()
+            launchParams.block_y = launch_params.block_y()
+            launchParams.block_z = launch_params.block_z()
+            launchParams.shared_mem = launch_params.shared_mem()
+
+            self.kernel_map[(tuple(io_types), tuple(io_formats), self._tactic)] = (kernel_name, ptx)
+
+            symExprSetter.nbSymExprs = len(extra_args)
+
+            for i, arg in enumerate(extra_args):
+                if not isinstance(arg, SymInt32):
+                    raise TypeError(f"Extra args must be a 'tensorrt.plugin.SymInt32'.  Got: {type(arg)}.")
+                symExprSetter[i] = arg()
+
+        def get_timing_cache_id(self):
+            return ""
+
+        def clone(self):
+            cloned_plugin = _TemplateAOTPlugin(
+                self.plugin_name, self.plugin_namespace, self.num_outputs
+            )
+            cloned_plugin.__dict__.update(self.__dict__)
+            return cloned_plugin