@@ -6,6 +6,7 @@
 
 # pyre-strict
 
+from executorch.backends.vulkan._passes.conv1d_as_conv2d import Conv1dAsConv2dPass
 from executorch.backends.vulkan._passes.fold_qdq import FoldQDQPass
 from executorch.backends.vulkan._passes.fuse_patterns import FusePatternsPass
 from executorch.backends.vulkan._passes.fuse_quantized_ops import (
@@ -28,6 +29,7 @@
 from executorch.backends.vulkan._passes.tag_memory_meta_pass import TagMemoryMetaPass
 
 __all__ = [
+    "Conv1dAsConv2dPass",
     "FoldQDQPass",
     "FusePatternsPass",
     "FuseQuantizedOpsTransform",
 
@@ -0,0 +1,169 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-strict
+
+from typing import List, Optional
+
+import torch
+
+from executorch.backends.transforms.utils import (
+    get_param_tensor,
+    is_param_node,
+    set_param_tensor,
+)
+from executorch.exir.dialects._ops import ops as exir_ops
+from executorch.exir.pass_base import ExportPass, PassResult
+
+from torch.export import ExportedProgram
+
+# Mirrors kIm2colMinCOut in Convolution.cpp. At or above this output channel
+# count, should_use_conv2d_im2col() selects the im2col + GEMM path on every
+# vendor, so a rewritten conv is guaranteed to land there rather than on the
+# direct conv2d shader, which has not been compared against conv1d.
+_IM2COL_MIN_C_OUT = 128
+
+
+def _reshape_fake(val: torch.Tensor, sizes: List[int]) -> torch.Tensor:
+    fake_mode = getattr(val, "fake_mode", None)
+    if fake_mode is None:
+        return val.reshape(sizes)
+    with fake_mode:
+        return val.reshape(sizes)
+
+
+class Conv1dAsConv2dPass(ExportPass):
+    """
+    Rewrite eligible 1-D convolutions into a 2-D convolution over a singleton
+    height dimension.
+
+    conv1d.glsl computes one output element per invocation with no tiling and no
+    reuse between invocations, and its global work grid packs texels along the
+    batch dim, wasting three of every four lanes at batch 1. It measures around
+    30x slower than the conv2d im2col + GEMM path for the same MAC count.
+    Expressing the convolution as 2-D lets the existing conv2d machinery
+    (im2col selection, memory layout tagging, weight prepacking) handle it with
+    no runtime changes.
+
+    Only convolutions that are certain to reach the im2col path are rewritten,
+    so nothing silently moves onto a shader that has not been compared against
+    conv1d. The weight is reshaped in place rather than through a view node
+    because the conv2d implementation reads it as a constant TensorRef.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._exported_program: Optional[ExportedProgram] = None
+
+    def _eligible(self, node: torch.fx.Node) -> bool:
+        assert self._exported_program is not None
+        in_node, weight_node = node.args[0], node.args[1]
+        if not isinstance(in_node, torch.fx.Node):
+            return False
+        if not isinstance(weight_node, torch.fx.Node):
+            return False
+        in_shape = in_node.meta["val"].shape
+        w_shape = weight_node.meta["val"].shape
+        if len(in_shape) != 3 or len(w_shape) != 3:
+            return False
+        # The weight has to be a constant so it can be reshaped in place.
+        if not is_param_node(self._exported_program, weight_node):
+            return False
+        # ...and it has to belong to this convolution alone. The reshape is a
+        # mutation of shared state: a second consumer would keep reading the
+        # weight it was built against and find it rank 4, whether that consumer
+        # is another conv1d this pass then declines to rewrite, or an op that
+        # has nothing to do with convolution.
+        if len(weight_node.users) != 1:
+            return False
+        transposed, groups = node.args[6], node.args[8]
+        if transposed or groups != 1:
+            return False
+        # conv2d does not support batched input at all, so a rewrite there
+        # would turn a working conv1d into a throw.
+        #
+        # A symbolic batch is rejected rather than compared. Comparing it would
+        # read the value it happened to be traced with, so a dimension free to
+        # be 4 at runtime would pass a test for 1 and reach a conv2d that
+        # cannot serve it. Only a batch that is already a plain 1 is provably 1
+        # for every input the graph accepts.
+        if not isinstance(in_shape[0], int) or in_shape[0] != 1:
+            return False
+        # Depthwise and pointwise 1-D convs keep their own shaders.
+        if w_shape[0] < _IM2COL_MIN_C_OUT or w_shape[2] == 1:
+            return False
+        # im2col requires unit dilation.
+        return list(node.args[5]) == [1]
+
+    def _rewrite(self, graph: torch.fx.Graph, node: torch.fx.Node) -> None:
+        assert self._exported_program is not None
+        view = exir_ops.edge.aten.view_copy.default
+        in_node, weight_node = node.args[0], node.args[1]
+
+        in_shape = list(in_node.meta["val"].shape)
+        w_shape = list(weight_node.meta["val"].shape)
+        out_shape = list(node.meta["val"].shape)
+        in_4d_shape = [in_shape[0], in_shape[1], 1, in_shape[2]]
+        w_4d_shape = [w_shape[0], w_shape[1], 1, w_shape[2]]
+        out_4d_shape = [out_shape[0], out_shape[1], 1, out_shape[2]]
+
+        # The weight tensor is contiguous, so inserting a singleton dim is a
+        # pure metadata change. It is safe to do in place only because
+        # _eligible() has established this convolution is the weight's sole
+        # consumer.
+        weight = get_param_tensor(self._exported_program, weight_node)
+        assert weight is not None
+        set_param_tensor(
+            self._exported_program, weight_node, weight.reshape(w_4d_shape)
+        )
+        weight_node.meta["val"] = _reshape_fake(weight_node.meta["val"], w_4d_shape)
+
+        with graph.inserting_before(node):
+            in_4d = graph.call_function(view, args=(in_node, in_4d_shape))
+        in_4d.meta = dict(in_node.meta)
+        in_4d.meta["val"] = _reshape_fake(in_node.meta["val"], in_4d_shape)
+
+        def pad(arg: List[int], lead: int) -> List[int]:
+            return [lead, arg[0]]
+
+        node.args = (
+            in_4d,
+            weight_node,
+            node.args[2],
+            pad(node.args[3], 1),  # stride
+            pad(node.args[4], 0),  # padding
+            pad(node.args[5], 1),  # dilation
+            node.args[6],
+            pad(node.args[7], 0),  # output_padding
+            node.args[8],
+        )
+
+        with graph.inserting_after(node):
+            out_3d = graph.call_function(view, args=(node, out_shape))
+        out_3d.meta = dict(node.meta)
+        node.replace_all_uses_with(out_3d)
+        out_3d.args = (node, out_shape)
+        node.meta["val"] = _reshape_fake(node.meta["val"], out_4d_shape)
+
+    def call(self, graph_module: torch.fx.GraphModule) -> PassResult:
+        assert self._exported_program is not None
+
+        modified = False
+        for node in list(graph_module.graph.nodes):
+            if node.op != "call_function":
+                continue
+            if node.target != exir_ops.edge.aten.convolution.default:
+                continue
+            if not self._eligible(node):
+                continue
+            self._rewrite(graph_module.graph, node)
+            modified = True
+
+        if not modified:
+            return PassResult(graph_module, False)
+
+        graph_module.recompile()
+        return PassResult(graph_module, True)
@@ -93,6 +93,20 @@ def define_common_targets(is_fbcode = False):
         ],
     )
 
+    runtime.python_library(
+        name = "conv1d_as_conv2d",
+        srcs = ["conv1d_as_conv2d.py"],
+        visibility = [
+            "//executorch/backends/...",
+        ],
+        deps = [
+            "//caffe2:torch",
+            "//executorch/backends/transforms:utils",
+            "//executorch/exir:pass_base",
+            "//executorch/exir/dialects:lib",
+        ],
+    )
+
     runtime.python_library(
         name = "fold_qdq",
         srcs = ["fold_qdq.py"],
@@ -144,6 +158,7 @@ def define_common_targets(is_fbcode = False):
             "//executorch/examples/...",
         ],
         deps = [
+            ":conv1d_as_conv2d",
             ":fold_qdq",
             ":fuse_patterns",
             ":fuse_quantized_ops",
 
@@ -1094,6 +1094,33 @@ def forward(self, x):
             (torch.randn(size=(64,), dtype=torch.float32),),
         )
 
+    def test_vulkan_backend_conv1d_as_conv2d(self):
+        # Eligible for Conv1dAsConv2dPass: groups 1, unit dilation, kernel > 1,
+        # batch 1 and out_channels >= the im2col threshold, so this lowers via
+        # the conv2d im2col + GEMM path rather than conv1d.glsl.
+        class Conv1dModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv = torch.nn.Conv1d(
+                    in_channels=32,
+                    out_channels=128,
+                    kernel_size=3,
+                    stride=2,
+                    padding=1,
+                    bias=True,
+                )
+
+            def forward(self, x):
+                return self.conv(x)
+
+        conv1d_module = Conv1dModule()
+        sample_inputs = (torch.randn(size=(1, 32, 64), dtype=torch.float32),)
+
+        self.lower_module_and_test_output(
+            conv1d_module,
+            sample_inputs,
+        )
+
     @disable_test("layer norm compute shader not working with swiftshader")
     def test_vulkan_backend_native_layer_norm(self):
         class NativeLayerNormModule(torch.nn.Module):
 
@@ -1,8 +1,9 @@
 import unittest
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
 import torch
 
+from executorch.backends.vulkan._passes.conv1d_as_conv2d import Conv1dAsConv2dPass
 from executorch.backends.vulkan._passes.fuse_patterns import FusePatternsPass
 
 from executorch.exir import EdgeCompileConfig, EdgeProgramManager, to_edge
@@ -86,7 +87,104 @@ def op_node_count(graph_module: torch.fx.GraphModule, canonical_op_name: str) ->
     return count
 
 
+def run_conv1d_as_conv2d(
+    model: torch.nn.Module,
+    sample_inputs: Tuple[torch.Tensor],
+    dynamic_shapes=None,
+) -> torch.fx.GraphModule:
+    """Exports `model` to edge and runs Conv1dAsConv2dPass over it."""
+    program = torch.export.export(
+        model, sample_inputs, dynamic_shapes=dynamic_shapes, strict=True
+    )
+    edge_program = to_edge(
+        program,
+        compile_config=EdgeCompileConfig(
+            _skip_dim_order=False, _check_ir_validity=False
+        ),
+    )
+    exported = edge_program.exported_program()
+
+    conv_pass = Conv1dAsConv2dPass()
+    conv_pass._exported_program = exported
+    return conv_pass(exported.graph_module).graph_module
+
+
+def conv_input_ranks(graph_module: torch.fx.GraphModule) -> List[int]:
+    """The rank of the input to every convolution in the graph."""
+    ranks = []
+    for node in graph_module.graph.nodes:
+        if get_target_canonical_name(node) == "convolution.default":
+            ranks.append(len(node.args[0].meta["val"].shape))
+    return ranks
+
+
 class TestVulkanPasses(unittest.TestCase):
+    def test_conv1d_as_conv2d_rewrites_eligible_conv(self):
+        # Output equality cannot show this: an unrewritten conv1d computes the
+        # same numbers. What distinguishes the two is the rank the convolution
+        # is asked to work at, so that is what is asserted.
+        class Conv1dModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv = torch.nn.Conv1d(32, 128, kernel_size=3, padding=1)
+
+            def forward(self, x):
+                return self.conv(x)
+
+        gm = run_conv1d_as_conv2d(Conv1dModule(), (torch.randn(1, 32, 64),))
+
+        self.assertEqual(conv_input_ranks(gm), [4])
+        # Two views: one lifting the input to 4-D, one lowering the output back.
+        self.assertEqual(op_node_count(gm, "view_copy.default"), 2)
+
+    def test_conv1d_as_conv2d_rejects_shared_weight(self):
+        # The rewrite reshapes the weight in place. A second consumer would go
+        # on reading a tensor that has silently become rank 4, so a shared
+        # weight has to be left alone.
+        class SharedWeightModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.weight = torch.nn.Parameter(torch.randn(128, 32, 3))
+
+            def forward(self, x, y):
+                return (
+                    torch.nn.functional.conv1d(x, self.weight, padding=1),
+                    torch.nn.functional.conv1d(y, self.weight, padding=1),
+                )
+
+        gm = run_conv1d_as_conv2d(
+            SharedWeightModule(), (torch.randn(1, 32, 64), torch.randn(1, 32, 64))
+        )
+
+        self.assertEqual(conv_input_ranks(gm), [3, 3])
+        self.assertEqual(op_node_count(gm, "view_copy.default"), 0)
+
+    def test_conv1d_as_conv2d_rejects_symbolic_batch(self):
+        # A batch free to vary at runtime is not a batch of 1, whatever value it
+        # was traced with, and conv2d refuses batched input. The guard is on the
+        # dimension being a plain integer rather than on its traced value, so
+        # that a comparison never decides this from the hint alone.
+        #
+        # Traced at 2 because export specializes a size-1 dimension: the batch
+        # has to be genuinely symbolic here for the graph to be the one the
+        # guard exists for.
+        class Conv1dModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv = torch.nn.Conv1d(32, 128, kernel_size=3, padding=1)
+
+            def forward(self, x):
+                return self.conv(x)
+
+        gm = run_conv1d_as_conv2d(
+            Conv1dModule(),
+            (torch.randn(2, 32, 64),),
+            dynamic_shapes={"x": {0: torch.export.Dim.AUTO}},
+        )
+
+        self.assertEqual(conv_input_ranks(gm), [3])
+        self.assertEqual(op_node_count(gm, "view_copy.default"), 0)
+
     def test_fuse_torchao_quantized_embedding(self):
         """A torchao-dialect 4-bit weight-only quantized embedding
         (torchao.dequantize_affine -> aten.embedding) should fuse into a single
 
@@ -17,6 +17,7 @@
     ViewCopyToSqueezeUnsqueezePass,
 )
 from executorch.backends.vulkan._passes import (
+    Conv1dAsConv2dPass,
     FoldQDQPass,
     FuseQuantizedOpsTransform,
     insert_prepack_nodes,
@@ -190,6 +191,7 @@ def preprocess(  # noqa: C901
                 AddmmToLinearTransform(),
                 InsertDtypePromotionPass(),
                 FusePatternsPass(),
+                Conv1dAsConv2dPass(),
                 FuseClampPass(),
                 RemoveRedundantOpsTransform(),
                 FuseQuantizedOpsTransform(),