test: consolidate C++ runtime tests, add model-level coverage

Address PR review comments that asked the new C++ runtime tests be
folded into existing feature-level files rather than shipped as
parallel `*_cpp.py` files.

What
 - Merge `test_000_runtime_cache_cpp.py` into the existing
   `test_000_runtime_cache.py`. The file already covered the Python
   runtime path; two new classes (`TestRuntimeCacheCppPersistence`,
   `TestCppSerializationIndices`) cover the C++ runtime path via
   `use_python_runtime=False`, and the serialization-index
   assertions. Skip on non-RTX builds.
 - Fold the C++ runtime cases for dynamic shapes kernel
   specialization strategy into `test_001_dynamic_shapes_kernel_
   strategy.py` (introduced upstream in PR pytorch#4184). Two new classes
   (`TestDynamicShapesKernelStrategyCpp`, `TestDynamicShapesKernel
   StrategyCppInvalidValue`) exercise lazy/eager/none end-to-end and
   reject invalid strategy names. The pre-existing Python runtime
   tests remain untouched.
 - Rename `test_000_cuda_graph_strategy.py` to `test_001_cuda_graph_
   strategy.py` to match the `test_001_*` convention used for L1
   RTX-only features. When upstream lands the Python runtime
   counterpart (PR pytorch#4187), both sets fold into the same file.
 - Add model-level tests: `test_runtime_cache_models.py` gains a
   `TestRuntimeCacheCppModels` class exercising ResNet18 through the
   C++ runtime with warm-cache roundtrip. `test_dynamic_shapes_
   kernel_strategy_models.py` gains `TestDynamicShapesKernelStrategy
   CppModels` covering lazy/eager/none on ResNet18 via the C++
   runtime.

Verified
 - 35 passed / 3 skipped in the runtime/ tests (merged file plus
   test_001 strategy files).
 - No regression in test_002_cudagraphs_cpp.py (8 passed) or
   test_005_dynamic_allocation.py (1 passed).

Addresses PR pytorch#4202 review comments asking for test file merges and
the addition of model-level runtime_cache_models.py /
dynamic_shapes_kernel_strategy_models.py coverage.

Author: tp5uiuc

tests/py/dynamo/models/test_dynamic_shapes_kernel_strategy_models.py

@@ -129,5 +129,69 @@ def test_dynamic_batch_none(self):
         self._test_dynamic_batch_with_strategy("none")
 
 
+@unittest.skipIf(
+    not ENABLED_FEATURES.torch_tensorrt_runtime,
+    "C++ runtime is not available",
+)
+@unittest.skipIf(
+    not ENABLED_FEATURES.tensorrt_rtx,
+    "Dynamic shapes kernel specialization strategy requires TensorRT-RTX",
+)
+@unittest.skipIf(
+    not importlib.util.find_spec("torchvision"),
+    "torchvision is not installed",
+)
+class TestDynamicShapesKernelStrategyCppModels(TestCase):
+    """End-to-end model tests with each strategy exercised through the C++ runtime."""
+
+    def tearDown(self):
+        torch._dynamo.reset()
+
+    def _compile_and_verify_cpp(self, model, strategy):
+        input_tensor = torch.randn(4, 3, 224, 224).cuda()
+        compiled = torchtrt.compile(
+            model,
+            ir="dynamo",
+            inputs=[
+                torchtrt.Input(
+                    min_shape=(1, 3, 224, 224),
+                    opt_shape=(4, 3, 224, 224),
+                    max_shape=(8, 3, 224, 224),
+                    dtype=torch.float32,
+                )
+            ],
+            enabled_precisions={torch.float32},
+            use_python_runtime=False,
+            min_block_size=1,
+            dynamic_shapes_kernel_specialization_strategy=strategy,
+        )
+        ref_output = model(input_tensor)
+        trt_output = compiled(input_tensor)
+        cos_sim = cosine_similarity(ref_output, trt_output)
+        self.assertTrue(
+            cos_sim > COSINE_THRESHOLD,
+            f"C++ runtime cosine similarity {cos_sim} below threshold {COSINE_THRESHOLD} "
+            f"with strategy={strategy}",
+        )
+
+    def test_resnet18_lazy_strategy_cpp(self):
+        import torchvision.models as models
+
+        model = models.resnet18(pretrained=True).eval().cuda()
+        self._compile_and_verify_cpp(model, "lazy")
+
+    def test_resnet18_eager_strategy_cpp(self):
+        import torchvision.models as models
+
+        model = models.resnet18(pretrained=True).eval().cuda()
+        self._compile_and_verify_cpp(model, "eager")
+
+    def test_resnet18_none_strategy_cpp(self):
+        import torchvision.models as models
+
+        model = models.resnet18(pretrained=True).eval().cuda()
+        self._compile_and_verify_cpp(model, "none")
+
+
 if __name__ == "__main__":
     run_tests()

tests/py/dynamo/models/test_runtime_cache_models.py

@@ -325,5 +325,96 @@ def forward(self, x):
         self.assertTrue(True, "Timing test completed (informational)")
 
 
+@unittest.skipIf(
+    not ENABLED_FEATURES.torch_tensorrt_runtime,
+    "C++ runtime is not available",
+)
+@unittest.skipIf(
+    not ENABLED_FEATURES.tensorrt_rtx,
+    "Runtime cache is only available with TensorRT-RTX",
+)
+@unittest.skipIf(
+    not importlib.util.find_spec("torchvision"),
+    "torchvision is not installed",
+)
+class TestRuntimeCacheCppModels(TestCase):
+    """End-to-end model tests with runtime cache exercised through the C++ runtime."""
+
+    def setUp(self):
+        self.cache_dir = tempfile.mkdtemp()
+        self.cache_path = os.path.join(self.cache_dir, "runtime_cache.bin")
+
+    def tearDown(self):
+        shutil.rmtree(self.cache_dir, ignore_errors=True)
+        torch._dynamo.reset()
+
+    def test_resnet18_with_runtime_cache_cpp(self):
+        import torchvision.models as models
+
+        model = models.resnet18(pretrained=True).eval().cuda()
+        input_tensor = torch.randn(1, 3, 224, 224).cuda()
+
+        compiled = torchtrt.compile(
+            model,
+            ir="dynamo",
+            inputs=[torchtrt.Input(input_tensor.shape, dtype=torch.float32)],
+            enabled_precisions={torch.float32},
+            use_python_runtime=False,
+            min_block_size=1,
+            runtime_cache_path=self.cache_path,
+        )
+
+        ref_output = model(input_tensor)
+        trt_output = compiled(input_tensor)
+
+        cos_sim = cosine_similarity(ref_output, trt_output)
+        self.assertTrue(
+            cos_sim > COSINE_THRESHOLD,
+            f"ResNet18 C++ runtime cosine similarity {cos_sim} below threshold {COSINE_THRESHOLD}",
+        )
+
+        # Verify the runtime cache is persisted on engine destruction.
+        del compiled
+        gc.collect()
+        self.assertTrue(
+            os.path.isfile(self.cache_path),
+            "Runtime cache should be saved after ResNet18 C++-runtime inference",
+        )
+
+    def test_resnet18_cache_reuse_cpp(self):
+        """Warm-cache second compile should match eager output."""
+        import torchvision.models as models
+
+        model = models.resnet18(pretrained=True).eval().cuda()
+        input_tensor = torch.randn(1, 3, 224, 224).cuda()
+        ref_output = model(input_tensor)
+
+        compile_kwargs = {
+            "ir": "dynamo",
+            "inputs": [torchtrt.Input(input_tensor.shape, dtype=torch.float32)],
+            "enabled_precisions": {torch.float32},
+            "use_python_runtime": False,
+            "min_block_size": 1,
+            "runtime_cache_path": self.cache_path,
+        }
+
+        compiled1 = torchtrt.compile(model, **compile_kwargs)
+        out1 = compiled1(input_tensor)
+        self.assertTrue(
+            cosine_similarity(ref_output, out1) > COSINE_THRESHOLD,
+            "First ResNet18 C++-runtime output should match eager",
+        )
+        del compiled1
+        gc.collect()
+        self.assertTrue(os.path.isfile(self.cache_path))
+
+        compiled2 = torchtrt.compile(model, **compile_kwargs)
+        out2 = compiled2(input_tensor)
+        self.assertTrue(
+            cosine_similarity(ref_output, out2) > COSINE_THRESHOLD,
+            "Second ResNet18 C++-runtime output (warm cache) should match eager",
+        )
+
+
 if __name__ == "__main__":
     run_tests()