Merge branch 'main' into recurrent-fla

Gasoonjia · web-flow · commit c8b7f92913d9 · 2026-04-09T20:46:45.000-07:00
diff --git a/backends/xnnpack/test/models/deeplab_v3.py b/backends/xnnpack/test/models/deeplab_v3.py
@@ -22,13 +22,37 @@ def forward(self, *args):
         return self.m(*args)["out"]
 
 
+class DynamicDL3Wrapper(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.m = deeplabv3_resnet50(
+            weights=deeplabv3.DeepLabV3_ResNet50_Weights.DEFAULT
+        )
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(
+            x,
+            size=(224, 224),
+            mode="bilinear",
+            align_corners=True,
+            antialias=False,
+        )
+        return self.m(x)["out"]
+
+
 class TestDeepLabV3(unittest.TestCase):
     def setUp(self):
         torch._dynamo.reset()
 
     dl3 = DL3Wrapper()
     dl3 = dl3.eval()
     model_inputs = (torch.randn(1, 3, 224, 224),)
+    dynamic_shapes = (
+        {
+            2: torch.export.Dim("height", min=224, max=455),
+            3: torch.export.Dim("width", min=224, max=455),
+        },
+    )
 
     def test_fp32_dl3(self):
 
@@ -40,3 +64,13 @@ def test_fp32_dl3(self):
             .serialize()
             .run_method_and_compare_outputs()
         )
+
+    def test_fp32_dl3_dynamic(self):
+        (
+            Tester(DynamicDL3Wrapper(), self.model_inputs, self.dynamic_shapes)
+            .export()
+            .to_edge_transform_and_lower()
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
diff --git a/backends/xnnpack/test/models/edsr.py b/backends/xnnpack/test/models/edsr.py
@@ -13,12 +13,34 @@
 from torchsr.models import edsr_r16f64
 
 
+class DynamicEDSR(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = edsr_r16f64(2, False).eval()
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(
+            x,
+            size=(224, 224),
+            mode="bilinear",
+            align_corners=True,
+            antialias=False,
+        )
+        return self.model(x)
+
+
 class TestEDSR(unittest.TestCase):
     def setUp(self):
         torch._dynamo.reset()
 
     edsr = edsr_r16f64(2, False).eval()  # noqa
     model_inputs = (torch.randn(1, 3, 224, 224),)
+    dynamic_shapes = (
+        {
+            2: torch.export.Dim("height", min=224, max=455),
+            3: torch.export.Dim("width", min=224, max=455),
+        },
+    )
 
     def test_fp32_edsr(self):
         (
@@ -53,3 +75,13 @@ def test_qs8_edsr_no_calibrate(self):
             .serialize()
             .run_method_and_compare_outputs()
         )
+
+    def test_fp32_edsr_dynamic(self):
+        (
+            Tester(DynamicEDSR(), self.model_inputs, self.dynamic_shapes)
+            .export()
+            .to_edge_transform_and_lower()
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
diff --git a/backends/xnnpack/test/models/emformer_rnnt.py b/backends/xnnpack/test/models/emformer_rnnt.py
@@ -48,6 +48,24 @@ def test_fp32_emformer_joiner(self):
             .run_method_and_compare_outputs()
         )
 
+    def test_fp32_emformer_joiner_dynamic(self):
+        joiner = self.Joiner()
+        dynamic_shapes = (
+            {0: torch.export.Dim("batch", min=1, max=4)},
+            None,
+            {0: torch.export.Dim("batch", min=1, max=4)},
+            None,
+        )
+        (
+            Tester(joiner, joiner.get_example_inputs(), dynamic_shapes=dynamic_shapes)
+            .export()
+            .to_edge_transform_and_lower()
+            .check(["torch.ops.higher_order.executorch_call_delegate"])
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
+
     class Predictor(EmformerRnnt):
         def forward(self, a, b):
             return self.rnnt.predict(a, b, None)
@@ -96,3 +114,23 @@ def test_fp32_emformer_transcriber(self):
             .serialize()
             .run_method_and_compare_outputs()
         )
+
+    def test_fp32_emformer_transcriber_dynamic(self):
+        transcriber = self.Transcriber()
+        dynamic_shapes = (
+            {0: torch.export.Dim("batch", min=1, max=4)},
+            None,
+        )
+        (
+            Tester(
+                transcriber,
+                transcriber.get_example_inputs(),
+                dynamic_shapes=dynamic_shapes,
+            )
+            .export()
+            .to_edge_transform_and_lower()
+            .check(["torch.ops.higher_order.executorch_call_delegate"])
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
diff --git a/backends/xnnpack/test/models/inception_v3.py b/backends/xnnpack/test/models/inception_v3.py
@@ -12,12 +12,34 @@
 from torchvision import models
 
 
+class DynamicInceptionV3(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = models.inception_v3(weights="IMAGENET1K_V1").eval()
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(
+            x,
+            size=(224, 224),
+            mode="bilinear",
+            align_corners=True,
+            antialias=False,
+        )
+        return self.model(x)
+
+
 class TestInceptionV3(unittest.TestCase):
     def setUp(self):
         torch._dynamo.reset()
 
     ic3 = models.inception_v3(weights="IMAGENET1K_V1").eval()  # noqa
     model_inputs = (torch.randn(1, 3, 224, 224),)
+    dynamic_shapes = (
+        {
+            2: torch.export.Dim("height", min=224, max=455),
+            3: torch.export.Dim("width", min=224, max=455),
+        },
+    )
 
     all_operators = {
         "executorch_exir_dialects_edge__ops_aten_addmm_default",
@@ -82,3 +104,14 @@ def test_qs8_ic3_no_calibration(self):
             .serialize()
             .run_method_and_compare_outputs()
         )
+
+    def test_fp32_ic3_dynamic(self):
+        (
+            Tester(DynamicInceptionV3(), self.model_inputs, self.dynamic_shapes)
+            .export()
+            .to_edge_transform_and_lower()
+            .check(["torch.ops.higher_order.executorch_call_delegate"])
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
diff --git a/backends/xnnpack/test/models/inception_v4.py b/backends/xnnpack/test/models/inception_v4.py
@@ -11,12 +11,34 @@
 from timm.models import inception_v4
 
 
+class DynamicInceptionV4(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = inception_v4(pretrained=False).eval()
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(
+            x,
+            size=(299, 299),
+            mode="bilinear",
+            align_corners=True,
+            antialias=False,
+        )
+        return self.model(x)
+
+
 class TestInceptionV4(unittest.TestCase):
     def setUp(self):
         torch._dynamo.reset()
 
     ic4 = inception_v4(pretrained=False).eval()
     model_inputs = (torch.randn(3, 299, 299).unsqueeze(0),)
+    dynamic_shapes = (
+        {
+            2: torch.export.Dim("height", min=299, max=455),
+            3: torch.export.Dim("width", min=299, max=455),
+        },
+    )
 
     all_operators = {
         "executorch_exir_dialects_edge__ops_aten_addmm_default",
@@ -60,3 +82,14 @@ def test_qs8_ic4(self):
             .serialize()
             .run_method_and_compare_outputs()
         )
+
+    def test_fp32_ic4_dynamic(self):
+        (
+            Tester(DynamicInceptionV4(), self.model_inputs, self.dynamic_shapes)
+            .export()
+            .to_edge_transform_and_lower()
+            .check(["torch.ops.higher_order.executorch_call_delegate"])
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs()
+        )
diff --git a/backends/xnnpack/test/models/mobilebert.py b/backends/xnnpack/test/models/mobilebert.py
@@ -31,6 +31,8 @@ def setUp(self):
         "executorch_exir_dialects_edge__ops_aten_constant_pad_nd_default",
     }
 
+    dynamic_shapes = ({1: torch.export.Dim("seq_length", min=2, max=32)},)
+
     def test_fp32_mobilebert(self):
         (
             Tester(self.mobilebert, self.example_inputs)
@@ -53,3 +55,18 @@ def test_qs8_mobilebert(self):
             .serialize()
             .run_method_and_compare_outputs(inputs=self.example_inputs)
         )
+
+    def test_fp32_mobilebert_dynamic(self):
+        (
+            Tester(
+                self.mobilebert,
+                self.example_inputs,
+                dynamic_shapes=self.dynamic_shapes,
+            )
+            .export()
+            .to_edge_transform_and_lower()
+            .check(["torch.ops.higher_order.executorch_call_delegate"])
+            .to_executorch()
+            .serialize()
+            .run_method_and_compare_outputs(inputs=self.example_inputs)
+        )
diff --git a/runtime/core/error.h b/runtime/core/error.h
@@ -152,6 +152,7 @@ constexpr const char* to_string(const Error error) {
     case Error::RegistrationAlreadyRegistered:
       return "Error::RegistrationAlreadyRegistered";
   }
+  return "Error::Unknown";
 }
 
 } // namespace runtime
diff --git a/runtime/core/test/error_handling_test.cpp b/runtime/core/test/error_handling_test.cpp
@@ -105,6 +105,72 @@ class Movable {
   mutable void* buffer_;
 };
 
+TEST(ErrorHandlingTest, ToStringKnownError) {
+  EXPECT_STREQ(executorch::runtime::to_string(Error::Ok), "Error::Ok");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::Internal), "Error::Internal");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::InvalidState),
+      "Error::InvalidState");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::EndOfMethod), "Error::EndOfMethod");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::AlreadyLoaded),
+      "Error::AlreadyLoaded");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::NotSupported),
+      "Error::NotSupported");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::NotImplemented),
+      "Error::NotImplemented");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::InvalidArgument),
+      "Error::InvalidArgument");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::InvalidType), "Error::InvalidType");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::OperatorMissing),
+      "Error::OperatorMissing");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::RegistrationExceedingMaxKernels),
+      "Error::RegistrationExceedingMaxKernels");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::RegistrationAlreadyRegistered),
+      "Error::RegistrationAlreadyRegistered");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::NotFound), "Error::NotFound");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::MemoryAllocationFailed),
+      "Error::MemoryAllocationFailed");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::AccessFailed),
+      "Error::AccessFailed");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::InvalidProgram),
+      "Error::InvalidProgram");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::InvalidExternalData),
+      "Error::InvalidExternalData");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::OutOfResources),
+      "Error::OutOfResources");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::DelegateInvalidCompatibility),
+      "Error::DelegateInvalidCompatibility");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::DelegateMemoryAllocationFailed),
+      "Error::DelegateMemoryAllocationFailed");
+  EXPECT_STREQ(
+      executorch::runtime::to_string(Error::DelegateInvalidHandle),
+      "Error::DelegateInvalidHandle");
+}
+
+TEST(ErrorHandlingTest, ToStringUnknownError) {
+  auto unknown = static_cast<Error>(0xFF);
+  const char* result = executorch::runtime::to_string(unknown);
+  EXPECT_STREQ(result, "Error::Unknown");
+}
+
 TEST(ErrorHandlingTest, ResultBasic) {
   Result<uint32_t> r(1);
   ASSERT_TRUE(r.ok());
diff --git a/runtime/executor/method.cpp b/runtime/executor/method.cpp
@@ -1521,8 +1521,17 @@ Error Method::execute_instruction() {
       // We know that instr_args_as_FreeCall is non-null because it was checked
       // at init time.
       auto free_call = instruction->instr_args_as_FreeCall();
-      auto t = mutable_value(free_call->value_index()).toTensor();
-      internal::reset_data_ptr(t);
+      auto& val = mutable_value(free_call->value_index());
+      if (val.isTensor()) {
+        auto& t = val.toTensor();
+        internal::reset_data_ptr(t);
+      } else {
+        ET_LOG(
+            Error,
+            "FreeCall target at index %u is not a Tensor",
+            static_cast<unsigned int>(free_call->value_index()));
+        err = Error::InvalidProgram;
+      }
     } break;
     default:
       ET_LOG(

Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,7 @@ constexpr const char* to_string(const Error error) {`
`152`	`152`	`case Error::RegistrationAlreadyRegistered:`
`153`	`153`	`return "Error::RegistrationAlreadyRegistered";`
`154`	`154`	`}`
	`155`	`+ return "Error::Unknown";`
`155`	`156`	`}`
`156`	`157`
`157`	`158`	`} // namespace runtime`