update constant pad

Author: zewenli98

py/torch_tensorrt/dynamo/conversion/impl/pad.py

@@ -6,10 +6,7 @@
 from torch.fx.node import Target
 from torch_tensorrt.dynamo._SourceIR import SourceIR
 from torch_tensorrt.dynamo.conversion._ConversionContext import ConversionContext
-from torch_tensorrt.fx.converters.converter_utils import (
-    has_dynamic_shape,
-    set_layer_name,
-)
+from torch_tensorrt.fx.converters.converter_utils import has_dynamic_shape
 from torch_tensorrt.fx.types import TRTTensor
 
 
@@ -22,58 +19,43 @@ def constant_padNd(
     pad: Sequence[int],
     value: Union[int, float] = 0,
 ) -> TRTTensor:
+    """
+    Note: IPaddingLayer is deprecated in TensorRT 8.2 and will be removed in TensorRT 10.0.
+    Use ISliceLayer to pad the tensor, which supports new non-constant, reflects padding
+    mode and clamp, and supports padding output with dynamic shape.
+    """
     if has_dynamic_shape(input.shape):
         assert input.shape[1] != -1, "Channel dim can't be dynamic for padding."
 
-    pad_len = len(pad)
-
-    if pad_len == 4 and value == 0:
-        pre_padding = (pad[2], pad[0])
-        post_padding = (pad[3], pad[1])
-
-        # add padding layer
-        pad_layer = ctx.net.add_padding_nd(
-            input=input,
-            pre_padding=pre_padding,
-            post_padding=post_padding,
+    # Implement constant padding via concat
+    curr_dim = len(input.shape) - 1
+
+    for i in range(0, len(pad), 2):
+        input_shape = list(input.shape)
+
+        pre_pad = pad[i]
+        post_pad = pad[i + 1]
+        pre_pad_shape = copy.deepcopy(input_shape)
+        pre_pad_shape[curr_dim] = pre_pad
+        pre_pad_tensor = torch.full(pre_pad_shape, float(value))
+        if pre_pad == post_pad:
+            post_pad_tensor = pre_pad_tensor
+        else:
+            post_pad_shape = copy.deepcopy(input_shape)
+            post_pad_shape[curr_dim] = post_pad
+            post_pad_tensor = torch.full(post_pad_shape, float(value))
+        output = impl.cat.cat(
+            ctx,
+            target,
+            source_ir,
+            f"{name}_concat{curr_dim}",
+            input=(pre_pad_tensor, input, post_pad_tensor),
+            dim=curr_dim,
         )
+        curr_dim -= 1
+        input = output
 
-        pad_layer.pre_padding_nd = pre_padding
-        pad_layer.post_padding_nd = post_padding
-
-        set_layer_name(pad_layer, target, name, source_ir)
-        return pad_layer.get_output(0)
-
-    else:
-        # Implement constant padding via concat
-        curr_dim = len(input.shape) - 1
-
-        for i in range(0, pad_len, 2):
-            input_shape = list(input.shape)
-
-            pre_pad = pad[i]
-            post_pad = pad[i + 1]
-            pre_pad_shape = copy.deepcopy(input_shape)
-            pre_pad_shape[curr_dim] = pre_pad
-            pre_pad_tensor = torch.full(pre_pad_shape, float(value))
-            if pre_pad == post_pad:
-                post_pad_tensor = pre_pad_tensor
-            else:
-                post_pad_shape = copy.deepcopy(input_shape)
-                post_pad_shape[curr_dim] = post_pad
-                post_pad_tensor = torch.full(post_pad_shape, float(value))
-            output = impl.cat.cat(
-                ctx,
-                target,
-                source_ir,
-                f"{name}_concat{curr_dim}",
-                input=(pre_pad_tensor, input, post_pad_tensor),
-                dim=curr_dim,
-            )
-            curr_dim -= 1
-            input = output
-
-        return output
+    return output
 
 
 def reflection_padNd(