diff --git a/test/cpp_extensions/setup.py b/test/cpp_extensions/setup.py index 980bf72adf147..c73bd28f27302 100644 --- a/test/cpp_extensions/setup.py +++ b/test/cpp_extensions/setup.py @@ -4,7 +4,6 @@ from setuptools import setup import torch.cuda -from torch.testing._internal.common_utils import IS_WINDOWS from torch.utils.cpp_extension import ( BuildExtension, CppExtension, @@ -42,7 +41,7 @@ ), ] -NVCC_FLAGS = ["-O2"] + (["-DUSE_CUDA"] if IS_WINDOWS else []) +NVCC_FLAGS = ["-O2"] + [] if torch.cuda.is_available() and (CUDA_HOME is not None or ROCM_HOME is not None): extension = CUDAExtension( @@ -83,8 +82,7 @@ # todo(mkozuki): Figure out the root cause if ( - (not IS_WINDOWS) - and torch.cuda.is_available() + torch.cuda.is_available() and (CUDA_HOME is not None or ROCM_HOME is not None) ): # malfet: One should not assume that PyTorch re-exports CUDA dependencies @@ -96,8 +94,7 @@ ext_modules.append(cublas_extension) if ( - (not IS_WINDOWS) - and torch.cuda.is_available() + torch.cuda.is_available() and (CUDA_HOME is not None or ROCM_HOME is not None) ): cusolver_extension = CUDAExtension( @@ -109,7 +106,6 @@ if ( USE_NINJA - and (not IS_WINDOWS) and torch.cuda.is_available() and CUDA_HOME is not None ): diff --git a/test/custom_operator/test_custom_ops.py b/test/custom_operator/test_custom_ops.py index bfb4427b7626f..238951ca16590 100644 --- a/test/custom_operator/test_custom_ops.py +++ b/test/custom_operator/test_custom_ops.py @@ -1,7 +1,6 @@ # Owner(s): ["module: cpp-extensions"] import sys -import unittest from model import get_custom_op_library_path @@ -11,7 +10,6 @@ from torch.testing._internal.common_utils import ( expectedIfCppFakeTensor, HardwareClassification, - IS_WINDOWS, run_tests, TestCase, ) @@ -45,7 +43,6 @@ def test_op_with_incorrect_abstract_impl_pystub(self): with self.assertRaisesRegex(RuntimeError, "pointwise"): torch.ops.custom.cos(x) - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") def test_dynamo_pystub_suggestion(self): x = torch.randn(3) diff --git a/test/distributed/elastic/multiprocessing/api_test.py b/test/distributed/elastic/multiprocessing/api_test.py index c03393a254578..6e6a2a624a71f 100644 --- a/test/distributed/elastic/multiprocessing/api_test.py +++ b/test/distributed/elastic/multiprocessing/api_test.py @@ -39,7 +39,6 @@ IS_CI, IS_LINUX, IS_MACOS, - IS_WINDOWS, run_tests, skip_if_pytest, TEST_WITH_ASAN, @@ -299,7 +298,7 @@ def _test_zombie_workflow( # tests incompatible with tsan or asan -if not (TEST_WITH_DEV_DBG_ASAN or IS_WINDOWS or IS_MACOS): +if not (TEST_WITH_DEV_DBG_ASAN or IS_MACOS): class StartProcessesAsFuncTest(_StartProcessesTest): def test_to_map(self): @@ -643,7 +642,7 @@ def test_validate_full_rank(self): # tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows -if not (TEST_WITH_DEV_DBG_ASAN or IS_WINDOWS or IS_MACOS): +if not (TEST_WITH_DEV_DBG_ASAN or IS_MACOS): class StartProcessesListAsFuncTest(_StartProcessesTest): def test_function(self): @@ -796,7 +795,7 @@ def test_binary_duplicate_log_filters(self): # tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows -if not (TEST_WITH_DEV_DBG_ASAN or IS_WINDOWS or IS_MACOS or IS_CI): +if not (TEST_WITH_DEV_DBG_ASAN or IS_MACOS or IS_CI): class StartProcessesNotCIAsFuncTest(_StartProcessesTest): @skip_if_pytest diff --git a/test/distributed/elastic/timer/file_based_local_timer_test.py b/test/distributed/elastic/timer/file_based_local_timer_test.py index 2af011ca22e2b..07a482fd61b30 100644 --- a/test/distributed/elastic/timer/file_based_local_timer_test.py +++ b/test/distributed/elastic/timer/file_based_local_timer_test.py @@ -18,7 +18,6 @@ HardwareClassification, IS_ARM64, IS_MACOS, - IS_WINDOWS, run_tests, TEST_WITH_TSAN, TestCase, @@ -26,7 +25,7 @@ # timer is not supported on these platforms -if not (IS_WINDOWS or IS_MACOS or IS_ARM64): +if not (IS_MACOS or IS_ARM64): # func2 should time out def func2(n, file_path): if file_path is not None: diff --git a/test/distributed/elastic/timer/local_timer_example.py b/test/distributed/elastic/timer/local_timer_example.py index 6d438f2536d6f..216f89966117b 100644 --- a/test/distributed/elastic/timer/local_timer_example.py +++ b/test/distributed/elastic/timer/local_timer_example.py @@ -16,7 +16,6 @@ from torch.testing._internal.common_utils import ( IS_ARM64, IS_MACOS, - IS_WINDOWS, run_tests, skip_but_pass_in_sandcastle_if, TEST_WITH_DEV_DBG_ASAN, @@ -42,7 +41,7 @@ def _stuck_function(rank, mp_queue): # timer is not supported on these platforms -if not (IS_WINDOWS or IS_MACOS or IS_ARM64): +if not (IS_MACOS or IS_ARM64): class LocalTimerExample(TestCase): """ diff --git a/test/distributed/elastic/timer/local_timer_test.py b/test/distributed/elastic/timer/local_timer_test.py index fbe0da28df320..073ce34edbbc7 100644 --- a/test/distributed/elastic/timer/local_timer_test.py +++ b/test/distributed/elastic/timer/local_timer_test.py @@ -18,7 +18,6 @@ HardwareClassification, IS_ARM64, IS_MACOS, - IS_WINDOWS, run_tests, TEST_WITH_DEV_DBG_ASAN, TEST_WITH_TSAN, @@ -27,7 +26,7 @@ # timer is not supported on these platforms -INVALID_PLATFORMS = IS_WINDOWS or IS_MACOS or TEST_WITH_DEV_DBG_ASAN or IS_ARM64 +INVALID_PLATFORMS = IS_MACOS or TEST_WITH_DEV_DBG_ASAN or IS_ARM64 if not INVALID_PLATFORMS: # func2 should time out diff --git a/test/distributed/elastic/utils/distributed_test.py b/test/distributed/elastic/utils/distributed_test.py index a03a3b77bd339..2488940b7ae35 100644 --- a/test/distributed/elastic/utils/distributed_test.py +++ b/test/distributed/elastic/utils/distributed_test.py @@ -24,7 +24,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_MACOS, - IS_WINDOWS, run_tests, TEST_WITH_TSAN, TestCase, @@ -55,7 +54,7 @@ def _can_bind(family, host): return False -if IS_WINDOWS or IS_MACOS: +if IS_MACOS: print("tests incompatible with tsan or asan", file=sys.stderr) sys.exit(0) diff --git a/test/distributed/test_c10d_nccl.py b/test/distributed/test_c10d_nccl.py index 2999ed000c964..01930568e8b64 100644 --- a/test/distributed/test_c10d_nccl.py +++ b/test/distributed/test_c10d_nccl.py @@ -75,8 +75,6 @@ instantiate_parametrized_tests, IS_LINUX, IS_SANDCASTLE, - isRocmArchAnyOf, - MI200_ARCH, MI350_ARCH, parametrize, retry_on_connect_failures, @@ -3341,12 +3339,6 @@ def first_bucket_size(ddp_bucket_mb): opt_ddp = torch.optim.SGD(m_ddp.parameters(), lr=0.1) has_half = any(p.dtype is torch.half for p in m.parameters()) tol = 3.0e-3 if has_half else 1.0e-5 - if has_half and TEST_WITH_ROCM and isRocmArchAnyOf(MI200_ARCH): - # MIOpen picks fp16 implicit-GEMM group conv solvers on - # gfx90a that lose intermediate precision, and the DDP vs - # full-batch accumulation order difference amplifies it. - # https://github.com/ROCm/rocm-libraries/issues/11938 - tol = 8.0e-3 except BaseException: # Prints case-specific debugging info to narrow down failing case. print( diff --git a/test/distributed/test_nccl.py b/test/distributed/test_nccl.py index ad89ce92a4d27..93e7062bb4b2a 100644 --- a/test/distributed/test_nccl.py +++ b/test/distributed/test_nccl.py @@ -32,7 +32,6 @@ ) from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_WINDOWS, load_tests, NoTest, parametrize, @@ -73,13 +72,13 @@ class TestNCCL(TestCase): - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") def test_unique_id(self, device): uid = nccl.unique_id() self.assertIsInstance(uid, bytes) self.assertGreater(len(uid), 1) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if(not TEST_MULTIGPU, "only one GPU detected") @dtypes(*broadcast_dtypes) def test_broadcast(self, device, dtype): @@ -115,7 +114,7 @@ def test_broadcast(self, device, dtype): for i in range(nGPUs): self.assertEqual(tensors[i], expected) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if(not TEST_MULTIGPU, "only one GPU detected") @dtypes(*datatypes) def test_reduce(self, device, dtype): @@ -137,7 +136,7 @@ def test_reduce(self, device, dtype): self.assertEqual(tensors[0], expected) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if(not TEST_MULTIGPU, "only one GPU detected") @dtypes(*datatypes) def test_all_reduce(self, device, dtype): @@ -168,7 +167,7 @@ def test_all_reduce(self, device, dtype): for tensor in tensors: self.assertEqual(tensor, expected) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") def test_collective_errors(self, device): t = torch.rand(10).cuda(0) with self.assertRaisesRegex( @@ -196,7 +195,7 @@ def test_collective_errors(self, device): ): nccl.reduce_scatter(t, t) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if(not TEST_MULTIGPU, "only one GPU detected") @dtypes(*datatypes) def test_all_gather(self, device, dtype): @@ -222,7 +221,7 @@ def test_all_gather(self, device, dtype): for tensor in outputs: self.assertEqual(tensor, expected) - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if(not TEST_MULTIGPU, "only one GPU detected") @dtypes(*datatypes) def test_reduce_scatter(self, device, dtype): @@ -280,7 +279,7 @@ def _init_pg(cls, rank, world_size, rdvz_file): ) cls.pg = c10d.distributed_c10d._get_default_group() - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_alloc(self): @@ -305,7 +304,7 @@ def foo(): symm_mem.rendezvous(out, group=group_name) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 28), "NCCL Symmetric Memory support device API from nccl 2.28" ) @@ -338,7 +337,7 @@ def test_nccl_symmem_rendezvous_many_allocations(self): ) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_rendezvous_world(self): @@ -359,7 +358,7 @@ def test_nccl_symmem_rendezvous_world(self): self.assertTrue(buf.eq(peer_rank).all()) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 27), "NCCL Symmetric Memory support from nccl 2.27") @skip_if_lt_x_gpu(2) def test_nccl_symmem_barrier(self): @@ -383,7 +382,7 @@ def test_nccl_symmem_barrier(self): handle.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_barrier_channel_out_of_bounds(self): @@ -405,7 +404,7 @@ def test_nccl_symmem_barrier_channel_out_of_bounds(self): handle.barrier(channel=max_channel - 1) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 29), "NCCL one-sided host API support from nccl 2.29") @skip_if_lt_x_gpu(2) def test_nccl_symmem_signal_rank_out_of_bounds(self): @@ -424,7 +423,7 @@ def test_nccl_symmem_signal_rank_out_of_bounds(self): handle.wait_signal(src_rank=bad_rank) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_rendezvous_subgroup(self): @@ -446,7 +445,7 @@ def test_nccl_symmem_rendezvous_subgroup(self): self.assertTrue(buf.eq(peer_rank).all()) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_collective(self): @@ -475,7 +474,7 @@ def test_nccl_symmem_collective(self): self.assertEqual(out, res) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_collective_cuda_graph(self): @@ -522,7 +521,7 @@ def test_nccl_symmem_collective_cuda_graph(self): self.assertEqual(res, out) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_tensor_creation_and_collective_cuda_graph(self): @@ -583,7 +582,7 @@ def test_nccl_symmem_tensor_creation_and_collective_cuda_graph(self): self.assertEqual(out, torch.full_like(out, expected_sum)) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_symmetric_memory_device_API @skip_if_lt_x_gpu(2) def test_nccl_symmem_put(self): @@ -624,7 +623,7 @@ def test_nccl_symmem_put(self): ) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 29), "NCCL one-sided host API support from nccl 2.29") @skip_if_lt_x_gpu(2) def test_nccl_symmem_handle_signal(self): @@ -664,7 +663,7 @@ def test_nccl_symmem_handle_signal(self): c10d.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_if_lt_x_gpu(2) @requires_nccl_version( (2, 28), "NCCL Symmetric Memory multicast support from nccl 2.28" @@ -698,7 +697,7 @@ def test_nccl_symmem_get(self): c10d.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 28), "NCCL Symmetric Memory support device API from nccl 2.28" ) @@ -742,7 +741,7 @@ def test_nccl_symmem_ops_on_subgroup(self): c10d.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 28), "NCCL Symmetric Memory device API support from nccl 2.28" ) @@ -823,7 +822,7 @@ def test_get(self): c10d.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 29, 7), "nccl_reduce_scatter_offset requires nccl 2.29.7" ) @@ -902,7 +901,7 @@ def test_reduce_scatter_offset(self, experts_per_rank: int, dim: int): ) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 29, 7), "nccl_reduce_scatter_offset requires nccl 2.29.7" ) @@ -971,7 +970,7 @@ def test_reduce_scatter_offset_uneven(self, dim: int): ) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 28, 0), "nccl_all_to_all_nd requires nccl 2.28") @skip_if_lt_x_gpu(2) @parametrize( @@ -1072,7 +1071,7 @@ def test_all_to_all_nd(self, scatter_gather, out_2d, input_3d): ) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 29), "NCCL one-sided host API support from nccl 2.29") @skip_if_lt_x_gpu(2) def test_put_wait_signal(self): @@ -1101,7 +1100,7 @@ def test_put_wait_signal(self): c10d.barrier() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 28), "NCCL Symmetric Memory support device API from nccl 2.28" ) @@ -1132,7 +1131,7 @@ def test_mempool_tensor_factory(self): self.assertEqual(tensor, expected) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version( (2, 28), "NCCL Symmetric Memory support device API from nccl 2.28" ) @@ -1162,7 +1161,7 @@ def test_mempool_compute_ops(self): self.assertEqual(y, expected) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 27), "NCCL Symmetric Memory support from nccl 2.27") @skip_if_lt_x_gpu(2) def test_mempool_recycled_barrier(self): @@ -1200,7 +1199,7 @@ def barrier_roundtrip(): del hdl2, t2 @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @skip_but_pass_in_sandcastle_if( os.environ.get("NCCL_NVLS_ENABLE", "1") == "0", "NCCL_NVLS_ENABLE=0", @@ -1252,7 +1251,7 @@ def _profile_gpu_events(self, fn: Callable[[], None]) -> list[str]: return [e.name for e in prof.events() if e.device_type == DeviceType.CUDA] @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 28), "NCCL symmetric kernels need nccl 2.28") @skip_if_lt_x_gpu(2) @parametrize("backend", ["nccl", "nccl-legacy"]) @@ -1270,7 +1269,7 @@ def test_nccl_symmem_mem_pool_all_reduce_symk(self, backend: str): nccl_backend.deregister_mem_pool(pool) @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 28), "NCCL copy-engine collectives need nccl 2.28") @skip_if_lt_x_gpu(2) @parametrize("backend", ["nccl", "nccl-legacy"]) @@ -1338,7 +1337,7 @@ def _init_pg(cls, rank, world_size, rdvz_file): cls.pg = c10d.distributed_c10d._get_default_group() @skip_but_pass_in_sandcastle_if(TEST_WITH_ROCM, "Skip NCCL tests for ROCm") - @skip_but_pass_in_sandcastle_if(IS_WINDOWS, "NCCL doesn't support Windows") + @skip_but_pass_in_sandcastle_if(False, "NCCL doesn't support Windows") @requires_nccl_version((2, 27), "NCCL Symmetric Memory support from nccl 2.27") @skip_if_lt_x_gpu(2) def test_nccl_symmem_rendezvous(self): diff --git a/test/dynamo/test_activation_checkpointing.py b/test/dynamo/test_activation_checkpointing.py index 3cb5ced36c5b6..791704b25d84d 100644 --- a/test/dynamo/test_activation_checkpointing.py +++ b/test/dynamo/test_activation_checkpointing.py @@ -39,7 +39,6 @@ ) from torch.testing._internal.common_device_type import instantiate_device_type_tests from torch.testing._internal.common_utils import ( - IS_WINDOWS, parametrize, skipIfHpu, skipIfXpu, @@ -976,7 +975,6 @@ def fn(x, y): self.assertEqual(len(wrap_node.args), 3) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1143,7 +1141,6 @@ def fn(x): self.assertEqual(x.grad, x.cos()) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1199,7 +1196,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1255,7 +1251,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1329,7 +1324,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1386,7 +1380,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1458,7 +1451,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1511,7 +1503,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1563,7 +1554,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ @@ -1612,7 +1602,6 @@ def fn(x, y): self._validate(fn, backend, x, y) self._compare_orig_and_checkpointed_fns(gn, fn, x, y) - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @unittest.skip( "In-place op support in selective checkpointing + torch.compile " "requires TorchDispatchMode + torch.compile work to complete" @@ -1671,7 +1660,6 @@ def fn(x, y): self._compare_orig_and_checkpointed_fns(gn, fn, x, y) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @torch._inductor.config.patch(fallback_random=True) @parametrize( "partition_fn", @@ -1738,7 +1726,6 @@ def fn(x): self._compare_orig_and_checkpointed_fns(gn, fn, x) @requires_gpu_and_triton - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows") @parametrize( "partition_fn", [ diff --git a/test/dynamo/test_logging.py b/test/dynamo/test_logging.py index 2dbc31a3e505f..dbbc2b277a263 100644 --- a/test/dynamo/test_logging.py +++ b/test/dynamo/test_logging.py @@ -22,7 +22,6 @@ from torch.testing._internal.common_utils import ( expectedIfCppFakeTensor, find_free_port, - IS_WINDOWS, munge_exc, skipIfTorchDynamo, skipIfWindows, @@ -1048,8 +1047,7 @@ def test_trace_source_funcname(self, records): # NOTE: list comprehensions are inlined in 3.12, so test with tuples def fn1(): def fn2(): - if True: - return tuple(torch.ones(3, 3) for _ in range(5)) + return tuple(torch.ones(3, 3) for _ in range(5)) return None return fn2() @@ -1088,7 +1086,7 @@ def test_invalid_artifact_flag_error_msg(self): "import torch", env=env, ) - lines = stderr.decode().split("\r\n" if IS_WINDOWS else "\n") + lines = stderr.decode().split("\n") # This is a sanity assert that our error is not spammy. # As of this test creation this was 18. # See this issue for the purpose o this test: diff --git a/test/dynamo/test_misc.py b/test/dynamo/test_misc.py index 33703a63c6fda..7cbe25174f949 100644 --- a/test/dynamo/test_misc.py +++ b/test/dynamo/test_misc.py @@ -93,7 +93,6 @@ freeze_rng_state, instantiate_parametrized_tests, IS_FBCODE, - IS_S390X, parametrize, recover_orig_fp32_precision, scoped_load_inline, @@ -13189,10 +13188,6 @@ def fn(x, y): res = opt_fn(x, y) self.assertTrue(same(ref, res)) - @unittest.skipIf( - IS_S390X, - "test_recursion_depth_guards_nested_graph_breaks fails on s390x and needs investigation", - ) def test_recursion_depth_guards(self): @torch.compile(dynamic=True, backend="eager") def foo(*args, **kwargs): diff --git a/test/dynamo/test_pgo.py b/test/dynamo/test_pgo.py index 25398def0304b..185f9f918fcad 100644 --- a/test/dynamo/test_pgo.py +++ b/test/dynamo/test_pgo.py @@ -18,7 +18,7 @@ ) from torch._inductor.cpp_builder import normalize_path_separator from torch._inductor.utils import clear_caches, fresh_cache -from torch.testing._internal.common_utils import HardwareClassification, IS_WINDOWS +from torch.testing._internal.common_utils import HardwareClassification class PgoTest(torch._dynamo.test_case.TestCase): @@ -400,7 +400,7 @@ def write_load_and_run(path): # Windows can't create unification temp path: # hash(a18a3259)C:/Users/Xuhan/AppData/Local/Temp/tmpx3hfkuqa/example.py # Skip hash check - self.assertTrue(("hash" if IS_WINDOWS else "hash(390fe689)") in state) + self.assertTrue("hash(390fe689)" in state) self.assertTrue("/example.py:4:func:" in state) self.assertTrue(" L['x']: tensor size=[?] stride=[1]" in state) # We should compile this only once due to PGO. diff --git a/test/dynamo/test_streams.py b/test/dynamo/test_streams.py index 7491fd59f5fea..f3a02823bd36d 100644 --- a/test/dynamo/test_streams.py +++ b/test/dynamo/test_streams.py @@ -25,7 +25,6 @@ from torch.testing._internal.common_utils import ( IS_LINUX, IS_MACOS, - IS_WINDOWS, parametrize, requires_accelerator, requires_cuda, @@ -2361,7 +2360,7 @@ def fn(x): ) @unittest.skipIf( - IS_LINUX or IS_MACOS or TEST_WITH_ROCM or IS_WINDOWS, + IS_LINUX or IS_MACOS or TEST_WITH_ROCM, "https://github.com/pytorch/pytorch/issues/178155", ) @unittest.skip("https://github.com/pytorch/pytorch/issues/177771") diff --git a/test/export/test_db.py b/test/export/test_db.py index 7b7dd91c009ad..c0b407ba2d82b 100644 --- a/test/export/test_db.py +++ b/test/export/test_db.py @@ -13,14 +13,12 @@ from torch.export import export from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_WINDOWS, parametrize, run_tests, TestCase, ) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo doesn't support") class ExampleTests(TestCase): # TODO Maybe we should make this tests actually show up in a file? diff --git a/test/export/test_draft_export.py b/test/export/test_draft_export.py index 7376370bcafdc..e3bbc73262f23 100644 --- a/test/export/test_draft_export.py +++ b/test/export/test_draft_export.py @@ -2,7 +2,6 @@ import copy import re import tempfile -import unittest from unittest.mock import patch import torch @@ -19,7 +18,6 @@ ) from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, TestCase, ) @@ -718,7 +716,6 @@ def forward(self, a, b): ep.run_decompositions() # https://github.com/pytorch/pytorch/issues/140625 - @unittest.skipIf(IS_WINDOWS, "aoti_compile_and_package not supported on Windows") def test_constantify_unbacked_symbol(self): class M(torch.nn.Module): def forward(self, x, y): diff --git a/test/export/test_export.py b/test/export/test_export.py index 940b5cfec566c..6c6b775c3a756 100644 --- a/test/export/test_export.py +++ b/test/export/test_export.py @@ -89,7 +89,6 @@ IS_FBCODE, IS_MACOS, IS_SANDCASTLE, - IS_WINDOWS, run_tests, skipIfCrossRef, skipIfRocm, @@ -587,7 +586,6 @@ def forward(self, x): return x + a -@unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo isn't support") class TestExport(TestCase): def _test_export_same_as_eager(self, f, args, kwargs=None): diff --git a/test/export/test_export_opinfo.py b/test/export/test_export_opinfo.py index c7f5a6a11bafc..a297ba6adb763 100644 --- a/test/export/test_export_opinfo.py +++ b/test/export/test_export_opinfo.py @@ -22,7 +22,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_FBCODE, - IS_WINDOWS, run_tests, TestCase, ) @@ -192,11 +191,6 @@ class TestExportOnFakeDevice(TestCase): # Running this on all ops in op_db is too slow, so we only run on a selected subset @onlyAccelerator @skipXPUIf(True, "https://github.com/intel/torch-xpu-ops/issues/5157") - @unittest.skipIf( - IS_WINDOWS, - "Subprocess with simulated CPU machine imports op_db which triggers " - "get_device_capability(); 0 devices raises Invalid device id on Windows.", - ) @ops(selected_op_db, allowed_dtypes=(torch.float,)) def test_fake_export(self, device, dtype, op): test_script = f"""\ @@ -263,10 +257,6 @@ def forward(self, *args): self.assertEqual(r, "") @onlyAccelerator - @unittest.skipIf( - IS_WINDOWS, - "Failing on Windows, device_count() changes from 0 to 1 ", - ) def test_preserve_original_behavior(self, device): test_script = f"""\ import torch diff --git a/test/export/test_hop.py b/test/export/test_hop.py index 4211b6432b50e..b0f33ef3cb08d 100644 --- a/test/export/test_hop.py +++ b/test/export/test_hop.py @@ -18,7 +18,6 @@ ) from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, ) from torch.testing._internal.hop_db import ( @@ -46,7 +45,6 @@ } -@unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo isn't support") class TestHOPDevice(TestCase): hw_classification = HardwareClassification.ACCELERATOR diff --git a/test/export/test_pass_infra.py b/test/export/test_pass_infra.py index fb576123fbaf0..3c203e4064ed7 100644 --- a/test/export/test_pass_infra.py +++ b/test/export/test_pass_infra.py @@ -10,7 +10,6 @@ from torch.fx.passes.infra.pass_base import PassResult from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, TestCase, ) @@ -48,7 +47,6 @@ class NullPass(_ExportPassBaseDeprecatedDoNotUse): self.assertEqual(new_node.op, old_node.op) self.assertEqual(new_node.target, old_node.target) - @unittest.skipIf(IS_WINDOWS, "Windows not supported") def test_cond(self) -> None: class M(torch.nn.Module): def __init__(self) -> None: diff --git a/test/export/test_passes.py b/test/export/test_passes.py index 0d161c9765398..f19f39b2f480c 100644 --- a/test/export/test_passes.py +++ b/test/export/test_passes.py @@ -50,7 +50,6 @@ from torch.testing._internal.common_device_type import instantiate_device_type_tests from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TestCase, @@ -759,7 +758,6 @@ def forward(self, x): new_inp = torch.tensor([1, 1, 1, 1]) self.assertEqual(mod(new_inp), ep.module()(new_inp)) - @unittest.skipIf(IS_WINDOWS, "Windows not supported") @unittest.expectedFailure # TODO(pianpwk): add back runtime asserts to subgraphs def test_runtime_assert_inline_constraints_for_cond(self) -> None: diff --git a/test/export/test_serialize.py b/test/export/test_serialize.py index 818810d030747..5cc7e643c967a 100644 --- a/test/export/test_serialize.py +++ b/test/export/test_serialize.py @@ -54,7 +54,6 @@ instantiate_parametrized_tests, IS_FBCODE, IS_MACOS, - IS_WINDOWS, parametrize, run_tests, TemporaryFileName, @@ -1122,7 +1121,6 @@ def _check_graph(pre_dispatch): _check_graph(pre_dispatch=False) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo doesn't support") class TestDeserialize(_DeserializeGraphMixin, TestCase): hw_classification = HardwareClassification.GENERIC @@ -2057,7 +2055,6 @@ def test_deserialize_torch_artifact_dict(self): self.assertIsInstance(result, dict) self.assertTrue(torch.equal(result["key"], torch.tensor([1, 2, 3]))) - @unittest.skipIf(IS_WINDOWS, "Cannot modify file in windows") def test_save_file(self): class Foo(torch.nn.Module): def forward(self, x): @@ -2113,7 +2110,7 @@ def forward(self, x): self.assertEqual(extra_files["extra.txt"], "moo") @unittest.skipIf( - IS_FBCODE or IS_MACOS or IS_WINDOWS, "The file path is different in fbcode CI" + IS_FBCODE or IS_MACOS, "The file path is different in fbcode CI" ) def test_version_error(self): class Foo(torch.nn.Module): @@ -2949,7 +2946,6 @@ def forward(self, x): self.assertIsNotNone(triton_node) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo doesn't support") class TestDeserializeAccelerator(_DeserializeGraphMixin, TestCase): hw_classification = HardwareClassification.ACCELERATOR diff --git a/test/export/test_swap.py b/test/export/test_swap.py index c3ece1a489db8..0cd2c38a5fd64 100644 --- a/test/export/test_swap.py +++ b/test/export/test_swap.py @@ -15,13 +15,11 @@ from torch.export._swap import _swap_modules from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, TestCase, ) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @unittest.skipIf(not torchdynamo.is_dynamo_supported(), "dynamo isn't support") @parameterized_class( [ diff --git a/test/export/test_unflatten.py b/test/export/test_unflatten.py index daba516bbb51c..dbddbad76db04 100644 --- a/test/export/test_unflatten.py +++ b/test/export/test_unflatten.py @@ -11,7 +11,6 @@ from torch.export.unflatten import _assign_attr, _AttrKind, _disable_interpreter from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TestCase, @@ -282,7 +281,6 @@ def forward(self, x, y): inp = (torch.randn(3), torch.randn(3)) self.assertTrue(torch.allclose(uep(*inp), m(*inp))) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfTorchDynamo("Non strict mode is not meant to run with dynamo") def test_unflatten_preserve_signature(self): class NestedChild(torch.nn.Module): @@ -384,7 +382,6 @@ def forward(self, x): export_module.module(), unflattened, (torch.randn((2, 3)),) ) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") def test_unflatten_preserve_with_unused_input(self): class M1(torch.nn.Module): def forward(self, x, a, b): @@ -443,7 +440,6 @@ def forward(self, x): ): unflattened(torch.randn(6, 6)) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") def test_unflatten_with_inplace_compile(self): class NestedChild(torch.nn.Module): def forward(self, x): diff --git a/test/export/test_verifier.py b/test/export/test_verifier.py index 2c909f21f799d..cdc09cecc6163 100644 --- a/test/export/test_verifier.py +++ b/test/export/test_verifier.py @@ -10,7 +10,6 @@ from torch.export.exported_program import InputKind, InputSpec, TensorArgument from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, TestCase, ) @@ -65,7 +64,6 @@ def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: with self.assertRaises(SpecViolationError): verifier.check(ep) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") def test_verifier_higher_order(self) -> None: class Foo(torch.nn.Module): def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: @@ -84,7 +82,6 @@ def false_fn(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: verifier = Verifier() verifier.check(ep) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") def test_verifier_nested_invalid_module(self) -> None: class Foo(torch.nn.Module): def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: diff --git a/test/functorch/test_aotdispatch.py b/test/functorch/test_aotdispatch.py index 2fbafbe8d1152..f335bfcc8d67e 100644 --- a/test/functorch/test_aotdispatch.py +++ b/test/functorch/test_aotdispatch.py @@ -98,7 +98,6 @@ instantiate_parametrized_tests, IS_ARM64, IS_MACOS, - IS_WINDOWS, IS_X86, outs_and_grads, parametrize, @@ -1168,7 +1167,6 @@ def __torch_dispatch__(self, func, types, args=(), kwargs=None): self.assertTrue(isinstance(aa2.grad, ConstantExtraMetadataTensor)) self.assertTrue(isinstance(aa2.grad.elem, TwoTensor)) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") def test_custom_tensor_metadata(self): def f(x): x_elem = x.elem @@ -1248,7 +1246,6 @@ def f(x, y, z): self.assertTrue(torch.allclose(y_nested_compile.grad.a.a, y_nested.grad.a.a)) self.assertTrue(torch.allclose(y_nested_compile.grad.a.b, y_nested.grad.a.b)) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") def test_nested_subclasses_complicated_inps_mixed(self): def f(x, y): y_elem = y.elem @@ -5763,7 +5760,6 @@ def forward(self, arg0_1, arg1_1): return (add_3,)""", ) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf( not torchdynamo.is_dynamo_supported(), "TorchDynamo is not supported" ) @@ -5841,7 +5837,6 @@ def forward(self, arg0_1): return (sin_1,)""", ) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf( not torchdynamo.is_dynamo_supported(), "TorchDynamo is not supported" ) @@ -6002,7 +5997,6 @@ def forward(self, arg0_1: "f32[2]", arg1_1: "f32[2]"): """, ) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf( not torchdynamo.is_dynamo_supported(), "TorchDynamo is not supported" ) @@ -6573,7 +6567,6 @@ def fn(p, x): ): aot_export_module(mod, [inp], trace_joint=True, output_loss_index=1) - @unittest.skipIf(IS_WINDOWS, "Windows isn't supported for this case") @unittest.skipIf( not torch._dynamo.is_dynamo_supported(), "Cond needs dynamo to run" ) diff --git a/test/functorch/test_control_flow.py b/test/functorch/test_control_flow.py index 59fa7e7ec66df..f54d84fdd89f7 100644 --- a/test/functorch/test_control_flow.py +++ b/test/functorch/test_control_flow.py @@ -45,7 +45,6 @@ expectedIfCppFakeTensor, HardwareClassification, instantiate_parametrized_tests, - IS_WINDOWS, parametrize, run_tests, skipIfCrossRef, @@ -555,7 +554,6 @@ def check_autograd(self, result, result_exp, params): self.assertEqual(grads, expected_grads, atol=6e-05, rtol=6e-06) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class TestControlFlow(_TestControlFlowBase): hw_classification = HardwareClassification.GENERIC @@ -3136,7 +3134,6 @@ def f(i, length): self.assertEqual(cc.frame_count, 1) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class TestControlFlowDevice(_TestControlFlowBase): hw_classification = HardwareClassification.ACCELERATOR @@ -5140,7 +5137,6 @@ def forward(self, scan_fct, inputs, **kwargs): return results -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class AssociativeScanTests(TestCase): hw_classification = HardwareClassification.GENERIC @@ -5395,7 +5391,6 @@ def inner_fn(xi): self.assertEqual(out, exp) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class AssociativeScanTestsDevice(TestCase): hw_classification = HardwareClassification.ACCELERATOR @@ -7433,7 +7428,6 @@ def inner_fn(xi): self.assertEqual(torch.compile(fn)(x), x) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class TestControlFlowTraced(TestCase): def setUp(self): @@ -12383,7 +12377,6 @@ def false_fn(): self.assertEqual(compiled(5, 7), g(5, 7)) -@unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") @skipIfNoDynamoSupport class TestControlFlowTracedDevice(TestCase): hw_classification = HardwareClassification.ACCELERATOR diff --git a/test/functorch/test_dims.py b/test/functorch/test_dims.py index 32d4a441d83a0..8fe699679f167 100644 --- a/test/functorch/test_dims.py +++ b/test/functorch/test_dims.py @@ -17,7 +17,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_LINUX, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TEST_WITH_ROCM, @@ -678,7 +677,7 @@ class TestMinDevice(TestBase): hw_classification = HardwareClassification.ACCELERATOR @unittest.skipIf( - IS_LINUX or TEST_WITH_ROCM or TEST_WITH_SLOW or IS_WINDOWS, + IS_LINUX or TEST_WITH_ROCM or TEST_WITH_SLOW, "https://github.com/pytorch/pytorch/issues/86710", ) def test_attn_device(self, device): diff --git a/test/functorch/test_eager_transforms.py b/test/functorch/test_eager_transforms.py index 3ff920417f8f2..f4c341d4d436f 100644 --- a/test/functorch/test_eager_transforms.py +++ b/test/functorch/test_eager_transforms.py @@ -16,7 +16,6 @@ # NB: numpy is a testing dependency! import numpy as np -from common_utils import expectedFailureIf import functorch import torch @@ -47,7 +46,6 @@ from torch.func import functional_call, linearize, stack_module_state from torch.testing import make_tensor from torch.testing._internal.common_cuda import ( - TEST_CUDA, tf32_on_and_off, with_tf32_off, ) @@ -63,7 +61,6 @@ HardwareClassification, instantiate_parametrized_tests, IS_FBCODE, - IS_WINDOWS, markDynamoStrictTest, parametrize, run_tests, @@ -3763,7 +3760,6 @@ def f(x): self.assertEqual(fx_f(new_cotangent, True, True), vjp_fn(new_cotangent)) # FIXME: test fails in Windows - @unittest.skipIf(IS_WINDOWS, "fails in Windows; needs investigation") @unittest.skipIf(IS_FBCODE, "can't subprocess in fbcode") # it is redundant to run this test twice on a machine that has GPUs @onlyCPU @@ -5507,7 +5503,6 @@ def wrapper(*args, **kwargs): @markDynamoStrictTest class TestCompileTransformsDevice(TestCase): # torch.compile is not supported on Windows CUDA. - @expectedFailureIf(IS_WINDOWS and TEST_CUDA) @unittest.skipIf( TEST_CUDA_MEM_LEAK_CHECK, "Leaking memory, see https://github.com/pytorch/pytorch/pull/150059 for example", diff --git a/test/functorch/test_ops.py b/test/functorch/test_ops.py index 2e56563530a92..4a26e689e3f9c 100644 --- a/test/functorch/test_ops.py +++ b/test/functorch/test_ops.py @@ -45,7 +45,6 @@ from torch.testing._internal.common_methods_invocations import op_db from torch.testing._internal.common_utils import ( is_iterable_of_tensors, - IS_S390X, noncontiguous_like, parametrize, run_tests, @@ -515,19 +514,7 @@ class TestOperators(TestCase): {torch.float32: tol(atol=3e-05, rtol=4e-06)}, device_type="cpu", ), - *( - [ - tol1( - "grid_sampler_2d", - { - torch.float32: tol(atol=1e-04, rtol=1e-04) - }, # Adjust values as needed - device_type="cpu", - ) - ] - if IS_S390X - else [] - ), + *[], ), ) def test_grad(self, device, dtype, op): diff --git a/test/functorch/test_vmap.py b/test/functorch/test_vmap.py index b2bcd8cda0ab8..8ef3b372c48fb 100644 --- a/test/functorch/test_vmap.py +++ b/test/functorch/test_vmap.py @@ -66,7 +66,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, instantiate_parametrized_tests, - IS_WINDOWS, markDynamoStrictTest, parametrize, run_tests, @@ -2472,7 +2471,6 @@ def foo(x): self.assertEqual(vmap(foo)(float_tensor), torch.tensor([1, 1, 1])) self.assertEqual(vmap(foo)(long_tensor), torch.tensor([0, 0, 0])) - @unittest.skipIf(IS_WINDOWS, reason="Windows not yet supported for torch.compile") def test_is_contiguous(self): def foo(x): if x.is_contiguous(): diff --git a/test/fx/test_matcher_utils.py b/test/fx/test_matcher_utils.py index 1c378dc64dd4f..6f0aefb42c132 100644 --- a/test/fx/test_matcher_utils.py +++ b/test/fx/test_matcher_utils.py @@ -13,13 +13,11 @@ pytorch_test_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) sys.path.append(pytorch_test_dir) -import unittest from torch.fx.passes.utils.matcher_utils import SubgraphMatcher from torch.fx.passes.utils.matcher_with_name_node_map_utils import ( SubgraphMatcherWithNameNodeMap, ) -from torch.testing._internal.common_utils import IS_WINDOWS from torch.testing._internal.common_utils import TestCase @@ -155,7 +153,6 @@ def maxpool(x, kernel_size, stride, padding, dilation): match_sp_result = maxpool_matcher.match(maxpool_sp_graph) self.assertEqual(len(match_sp_result), 1) - @unittest.skipIf(IS_WINDOWS, "Windows not yet supported for torch.compile") def test_split_to_graph_and_name_node_map(self): """Testing the internal helper function for splitting the pattern graph""" from torch.fx.passes.utils.matcher_with_name_node_map_utils import ( @@ -181,7 +178,6 @@ def pattern(x, weight): self.assertEqual(before_split_res[0], after_split_res[0]) self.assertEqual(before_split_res[1], after_split_res[1]) - @unittest.skipIf(IS_WINDOWS, "Windows not yet supported for torch.compile") def test_matcher_with_name_node_map_function(self): """Testing SubgraphMatcherWithNameNodeMap with function pattern""" @@ -229,7 +225,6 @@ def pattern(x, weight): "Expected custom_annotation to be 'annotation'" ) - @unittest.skipIf(IS_WINDOWS, "Windows not yet supported for torch.compile") def test_matcher_with_name_node_map_module(self): """Testing SubgraphMatcherWithNameNodeMap with module pattern""" diff --git a/test/higher_order_ops/test_with_effects.py b/test/higher_order_ops/test_with_effects.py index 984a38b4e45ed..4250b8ca27226 100644 --- a/test/higher_order_ops/test_with_effects.py +++ b/test/higher_order_ops/test_with_effects.py @@ -35,7 +35,6 @@ from torch.testing._internal.common_quantization import skipIfNoDynamoSupport from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TestCase, @@ -249,7 +248,6 @@ def f(x): res = torch.compile(f, backend="aot_eager")(*inputs) self.assertTrue(torch.allclose(res, f(*inputs))) - @unittest.skipIf(IS_WINDOWS, "triton") def test_compile_inductor(self): def f(x): torch.ops.aten._print("moo") @@ -262,7 +260,6 @@ def f(x): res = torch.compile(f, backend="inductor")(*inputs) self.assertTrue(torch.allclose(res, f(*inputs))) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @skipIfNoDynamoSupport def test_compile_inductor_external_op_return_none(self): with torch.library._scoped_library("mylib", "FRAGMENT") as lib: @@ -293,7 +290,6 @@ def f(x): res = torch.compile(f, backend="inductor")(*inputs) self.assertTrue(torch.allclose(res, f(*inputs))) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @skipIfNoDynamoSupport def test_inductor_preserves_effect_order_across_kernel_types(self): # Two ORDERED-effectful ops must keep program order even when they lower @@ -349,7 +345,6 @@ def f(x): finally: del lowerings[op_b] - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @skipIfNoDynamoSupport def test_inductor_effect_order_does_not_extend_lifetimes(self): # The effect edge between two ORDERED ops is an ordering constraint only. @@ -1005,7 +1000,6 @@ class TestWithEffectsDevice(TestCase): hw_classification = HardwareClassification.ACCELERATOR @onlyAccelerator - @unittest.skipIf(IS_WINDOWS, "triton") @skipCUDAIf(not SM80OrLater, "triton") @skipIfNoDynamoSupport def test_register_effectful_custom_op(self, device): @@ -1262,7 +1256,6 @@ def forward(self, arg1_1, arg2_1, arg3_1, arg4_1, arg5_1): self.assertTrue(torch.allclose(model(x)[0], out2[0], atol=1e-7, rtol=1e-4)) @onlyAccelerator - @unittest.skipIf(IS_WINDOWS, "triton") @skipCUDAIf(not SM80OrLater, "triton") def test_effectful_op_with_flex_attention(self, device): """Test that effectful custom ops work with flex_attention.""" diff --git a/test/inductor/test_aot_inductor.py b/test/inductor/test_aot_inductor.py index 6d00b44761010..67c1ef0fd48c8 100644 --- a/test/inductor/test_aot_inductor.py +++ b/test/inductor/test_aot_inductor.py @@ -89,10 +89,8 @@ from torch.testing._internal.common_utils import ( DeterministicGuard, HardwareClassification, - IS_CI, IS_FBCODE, IS_MACOS, - IS_WINDOWS, IS_X86, parametrize, random_matrix_with_scaled_reduction_dim, @@ -194,14 +192,6 @@ def use_fa3(): sub_kernel_autotuned, ) -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_torchinductor yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") - try: try: from .test_aot_inductor_utils import ( @@ -250,10 +240,7 @@ def use_fa3(): def get_module_ext_type(): - if IS_WINDOWS: - return "pyd" - else: - return "so" + return "so" def get_triton_grid_info(kernel, total_elements, src_code): @@ -1584,8 +1571,6 @@ def forward(self, y): @tf32_on_and_off(0.005) def test_deconv_freezing(self): dtypes = [torch.float] - if False: - dtypes.append(torch.bfloat16) for dtype, groups in itertools.product(dtypes, [2, 1]): iC = 4 oC = 2 diff --git a/test/inductor/test_aot_inductor_arrayref.py b/test/inductor/test_aot_inductor_arrayref.py index 587764feaf373..2aae06b5667e6 100644 --- a/test/inductor/test_aot_inductor_arrayref.py +++ b/test/inductor/test_aot_inductor_arrayref.py @@ -9,22 +9,13 @@ from torch._inductor.test_case import TestCase from torch._inductor.utils import run_and_get_cpp_code from torch.testing import FileCheck -from torch.testing._internal.common_utils import IS_CI, IS_FBCODE, IS_WINDOWS, xfailIf +from torch.testing._internal.common_utils import IS_FBCODE, xfailIf # TORCHINDUCTOR_LITE_MODE=1 (the inductor_aoti_fallback CI config) falls back to # ATen for every op; see LITE_MODE_TEST_FAILURES below. LITE_MODE = os.environ.get("TORCHINDUCTOR_LITE_MODE") == "1" - -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_torchinductor yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") - try: try: from .test_aot_inductor import ( diff --git a/test/inductor/test_aot_inductor_custom_ops.py b/test/inductor/test_aot_inductor_custom_ops.py index b3211dfd73f15..c374f7a8d5ca2 100644 --- a/test/inductor/test_aot_inductor_custom_ops.py +++ b/test/inductor/test_aot_inductor_custom_ops.py @@ -16,25 +16,14 @@ from torch.testing._internal.common_utils import ( find_library_location, HardwareClassification, - IS_CI, IS_FBCODE, IS_MACOS, IS_SANDCASTLE, - IS_WINDOWS, ) from torch.testing._internal.inductor_utils import GPU_TYPE, HAS_GPU_AND_TRITON from torch.testing._internal.logging_utils import LoggingTestCase, make_logging_test from torch.utils._python_dispatch import TorchDispatchMode - -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_torchinductor yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") - try: try: from .test_aot_inductor_utils import ( @@ -615,8 +604,6 @@ def setUp(self): raise unittest.SkipTest("non-portable load_library call used in test") else: lib_file_path = find_library_location("libaoti_custom_ops.so") - if IS_WINDOWS: - lib_file_path = find_library_location("aoti_custom_ops.dll") if not os.path.exists(lib_file_path): raise unittest.SkipTest("libaoti_custom_ops not built!") torch.ops.load_library(str(lib_file_path)) diff --git a/test/inductor/test_compile_subprocess.py b/test/inductor/test_compile_subprocess.py index d509de16dc6a1..65ded2081995d 100644 --- a/test/inductor/test_compile_subprocess.py +++ b/test/inductor/test_compile_subprocess.py @@ -19,8 +19,6 @@ from torch._inductor.graph import GraphLowering from torch._inductor.test_case import TestCase from torch.testing._internal.common_utils import ( - IS_CI, - IS_WINDOWS, isRocmArchAnyOf, MI350_ARCH, TEST_WITH_ASAN, @@ -36,16 +34,6 @@ ) -if IS_WINDOWS and IS_CI: - # TODO(xuhancn) : Debug and confirm pass_fds status on Windows. - sys.stderr.write( - "Almost UTs failed: pass_fds not supported on Windows, skip them on Windows.\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("pass_fds not supported on Windows") - - # Make the helper files in test/ importable pytorch_test_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) sys.path.append(pytorch_test_dir) diff --git a/test/inductor/test_compiled_autograd.py b/test/inductor/test_compiled_autograd.py index 104839b7bf41b..06117e0bee3b2 100644 --- a/test/inductor/test_compiled_autograd.py +++ b/test/inductor/test_compiled_autograd.py @@ -28,7 +28,6 @@ from torch._dynamo.testing import normalize_gm from torch._dynamo.utils import counters from torch._inductor import config as inductor_config -from torch._inductor.cpp_builder import is_msvc_cl from torch._inductor.test_case import run_tests, TestCase from torch.nn.attention.flex_attention import flex_attention from torch.nn.parallel import DistributedDataParallel as DDP @@ -41,7 +40,6 @@ ) from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_WINDOWS, noncontiguous_like, parametrize, scoped_load_inline, @@ -264,16 +262,7 @@ def fn(inp, index, value, grad_out): self.assertFalse(any("_unique" in reason for reason in counters["graph_break"])) def gen_cache_miss_log_prefix(self): - if IS_WINDOWS: - if is_msvc_cl(): - return "Cache miss due to new autograd node: struct " - else: - self.fail( - "Compilers other than msvc have not yet been verified on Windows." - ) - return "" - else: - return "Cache miss due to new autograd node: " + return "Cache miss due to new autograd node: " def test_reset(self): compiled_autograd.compiled_autograd_enabled = True diff --git a/test/inductor/test_cpu_cpp_wrapper.py b/test/inductor/test_cpu_cpp_wrapper.py index ba1e1a805e50a..6bd582b855eac 100644 --- a/test/inductor/test_cpu_cpp_wrapper.py +++ b/test/inductor/test_cpu_cpp_wrapper.py @@ -11,7 +11,6 @@ ) from torch.testing._internal.common_utils import ( IS_MACOS, - IS_WINDOWS, slowTest, TEST_MKL, TEST_WITH_ROCM, @@ -231,7 +230,7 @@ class BaseTest(NamedTuple): BaseTest("test_multihead_attention", "cpu", test_cpu_repro.CPUReproTests()), BaseTest( "test_multi_threading", - condition=not IS_WINDOWS, + condition=True, # Two threads compile, so we expect the output code to be printed twice. code_string_count={"py::gil_scoped_release_simple release;": 2}, ), diff --git a/test/inductor/test_cpu_select_algorithm.py b/test/inductor/test_cpu_select_algorithm.py index d71a5099d8bd3..d54dbe76d470c 100644 --- a/test/inductor/test_cpu_select_algorithm.py +++ b/test/inductor/test_cpu_select_algorithm.py @@ -28,7 +28,6 @@ HardwareClassification, IS_ARM64, IS_MACOS, - IS_WINDOWS, parametrize, requires_mkl, requires_onednn, @@ -1377,7 +1376,6 @@ def forward(self, arg152_1): "gelu", ), ) - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") def test_quantized_linear_with_pointwise( self, batch_size, in_features, out_features, bias, input_3d, dtype, epilogue ): @@ -1460,7 +1458,6 @@ def forward(self, x): "relu", ), ) - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") def test_quantized_linear_with_pointwise_binary( self, batch_size, @@ -1622,7 +1619,6 @@ def forward(self, x0, x1, other): @parametrize("in_features", (4, 68, 128)) # k should be a multiple of 4 @parametrize("out_features", (64, 65)) @parametrize("bias", (True, False)) - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") def test_quantized_linear_amx(self, batch_size, in_features, out_features, bias): v = torch.randn(batch_size, in_features).to(dtype=torch.float32) @@ -2219,10 +2215,6 @@ def forward(self, x): # each linear has different num of out features, thus invalid grouped gemm dtypes = [] - if False: - dtypes.append(torch.bfloat16) - if False: - dtypes.append(torch.float16) for dtype in dtypes: torch._dynamo.reset() torch._inductor.metrics.reset() @@ -2272,10 +2264,6 @@ def forward(self, x): return [linear(x) for linear in self.linears] dtypes = [] - if False: - dtypes.append(torch.bfloat16) - if False: - dtypes.append(torch.float16) for dtype in dtypes: if dtype == torch.float16 and input_3d: # reduce the number of tests @@ -2355,10 +2343,6 @@ def forward(self, x): return res0, res1 dtypes = [] - if False: - dtypes.append(torch.bfloat16) - if False: - dtypes.append(torch.float16) for dtype in dtypes: if input_3d and dtype == torch.float16: # Reduce the number of test cases @@ -3025,7 +3009,6 @@ def forward(self, x): @skipIfNoONEDNN @unittest.skipIf(not TEST_MKL, "Test requires MKL") @unittest.skip("MKLDNN is not enabled") - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") @inductor_config.patch({"freezing": True}) @patches @torch.no_grad @@ -3108,7 +3091,6 @@ def forward(self, qx): @skipIfNoONEDNN @unittest.skipIf(not TEST_MKL, "Test requires MKL") @unittest.skip("MKLDNN is not enabled") - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") @inductor_config.patch({"freezing": True}) @patches @torch.no_grad @@ -3198,7 +3180,6 @@ def forward(self, qx, other): @skipIfNoONEDNN @unittest.skipIf(not TEST_MKL, "Test requires MKL") @unittest.skip("MKLDNN is not enabled") - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") @inductor_config.patch({"freezing": True}) @patches @torch.no_grad @@ -3291,7 +3272,6 @@ def forward(self, x): @skipIfNoONEDNN @unittest.skipIf(not TEST_MKL, "Test requires MKL") @unittest.skip("MKLDNN is not enabled") - @unittest.skipIf(IS_WINDOWS, "Not supported on Windows") @inductor_config.patch({"freezing": True}) @patches @torch.no_grad @@ -3597,5 +3577,5 @@ def forward(self, x, weight): if __name__ == "__main__": from torch.testing._internal.inductor_utils import HAS_CPU - if HAS_CPU and not (IS_MACOS or IS_WINDOWS): + if HAS_CPU and not IS_MACOS: run_tests() diff --git a/test/inductor/test_cudagraph_trees.py b/test/inductor/test_cudagraph_trees.py index 7a6bcf431625c..4791a3acd123f 100644 --- a/test/inductor/test_cudagraph_trees.py +++ b/test/inductor/test_cudagraph_trees.py @@ -44,9 +44,7 @@ from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, IS_ARM64, - IS_CI, IS_LINUX, - IS_WINDOWS, IS_X86, parametrize, skipIfRocm, @@ -57,15 +55,6 @@ from torch.utils._mode_utils import no_dispatch from torch.utils._python_dispatch import TorchDispatchMode - -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_torchinductor yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") - importlib.import_module("functorch") importlib.import_module("filelock") diff --git a/test/inductor/test_flex_decoding.py b/test/inductor/test_flex_decoding.py index 000ad60c4de34..0cd3cbc3fecf2 100644 --- a/test/inductor/test_flex_decoding.py +++ b/test/inductor/test_flex_decoding.py @@ -1,7 +1,6 @@ # Owner(s): ["module: inductor"] import functools -import sys import unittest from collections import namedtuple from collections.abc import Callable @@ -45,18 +44,9 @@ skipXPUIf, ) from torch.testing._internal.common_quantized import _snr -from torch.testing._internal.common_utils import IS_CI, IS_WINDOWS from torch.utils._triton import has_triton_tma_device -if IS_WINDOWS and IS_CI: - # TODO(xuhancn) : Need track if it is a requirement on windows. - sys.stderr.write("This UT is validated on windows, a lot of crash. Skip it.\n") - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("skip on Windows") - - Tolerances = namedtuple("Tolerances", ["atol", "rtol"]) diff --git a/test/inductor/test_gpu_cpp_wrapper.py b/test/inductor/test_gpu_cpp_wrapper.py index 5b1ad875cba6f..6b51abee134f8 100644 --- a/test/inductor/test_gpu_cpp_wrapper.py +++ b/test/inductor/test_gpu_cpp_wrapper.py @@ -31,7 +31,6 @@ IS_FBCODE, IS_MACOS, IS_SANDCASTLE, - IS_WINDOWS, parametrize, skipIfXpu, slowTest, @@ -278,8 +277,6 @@ def test_custom_op_fallback_boxes_none_as_undefined_tensor(self): self.skipTest("non-portable load_library call used in test") else: lib_path = find_library_location("libaoti_custom_ops.so") - if IS_WINDOWS: - lib_path = find_library_location("aoti_custom_ops.dll") if not os.path.exists(lib_path): self.skipTest("libaoti_custom_ops not built") torch.ops.load_library(str(lib_path)) diff --git a/test/inductor/test_indexing.py b/test/inductor/test_indexing.py index 72328a3e2bc85..5ad5743e89660 100644 --- a/test/inductor/test_indexing.py +++ b/test/inductor/test_indexing.py @@ -31,7 +31,6 @@ from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, IS_MACOS, - IS_WINDOWS, parametrize, ) from torch.testing._internal.inductor_utils import ( @@ -55,7 +54,7 @@ # int64_t is long long on MacOS, but long on 64-bit Linux -LONG_SUFFIX = "LL" if IS_MACOS or IS_WINDOWS else "L" +LONG_SUFFIX = "LL" if IS_MACOS else "L" DO_PERF_TEST = os.environ.get("DO_PERF_TEST") == "1" REDUCTION_INVARIANT_X_LOAD = r"tl\.load\([^\n]*\[XBLOCK, 1\]" REDUCTION_INVARIANT_YX_LOAD = r"tl\.load\([^\n]*\[YBLOCK, 1, 1\]" diff --git a/test/inductor/test_inductor_lite_mode.py b/test/inductor/test_inductor_lite_mode.py index e7619250697b9..ea898e741057e 100644 --- a/test/inductor/test_inductor_lite_mode.py +++ b/test/inductor/test_inductor_lite_mode.py @@ -12,16 +12,6 @@ from torch._inductor.test_case import TestCase from torch._inductor.utils import run_and_get_cpp_code from torch.testing import FileCheck -from torch.testing._internal.common_utils import IS_CI, IS_WINDOWS - - -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_torchinductor yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") try: try: diff --git a/test/inductor/test_max_autotune.py b/test/inductor/test_max_autotune.py index 4930d9703d302..0eb87e12629c3 100644 --- a/test/inductor/test_max_autotune.py +++ b/test/inductor/test_max_autotune.py @@ -85,7 +85,6 @@ from torch.testing._internal.common_device_type import largeTensorTest from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_WINDOWS, parametrize, random_matrix_with_scaled_reduction_dim, skipIfRocm, @@ -1163,7 +1162,6 @@ def addmm(x, a, b): @fresh_cache() @skipIfXpu(msg="XPU doesn't support sm carveout") @unittest.skipIf(TEST_WITH_ROCM, "ROCm doesn't support sm carveout") - @unittest.skipIf(IS_WINDOWS, "Windows doesn't support persistent TMA") @unittest.skipIf( not has_triton_cuda_tma_device(), "Need device-side TMA support in Triton" ) diff --git a/test/inductor/test_memory_planning.py b/test/inductor/test_memory_planning.py index 34921de681fd9..f26002476f694 100644 --- a/test/inductor/test_memory_planning.py +++ b/test/inductor/test_memory_planning.py @@ -1,22 +1,11 @@ # Owner(s): ["module: inductor"] import re -import sys import unittest from types import SimpleNamespace -from torch.testing._internal.common_utils import IS_CI, IS_WINDOWS from torch.testing._internal.inductor_utils import GPU_TYPE, HAS_GPU, requires_gpu - -if IS_WINDOWS and IS_CI: - sys.stderr.write( - "Windows CI does not have necessary dependencies for test_memory_planning yet\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("requires sympy/functorch/filelock") - import torch from torch._C import FileCheck from torch._dynamo.utils import same diff --git a/test/inductor/test_mmdecomp.py b/test/inductor/test_mmdecomp.py index 14027785fd900..c91f84ced04d2 100644 --- a/test/inductor/test_mmdecomp.py +++ b/test/inductor/test_mmdecomp.py @@ -20,7 +20,6 @@ ) from torch.testing._internal.common_nn import NNTestCase from torch.testing._internal.common_utils import ( - IS_WINDOWS, parametrize, run_tests, TEST_XPU, @@ -582,6 +581,4 @@ def test_dynamic_shape_mm(self, device, dtype): ) if __name__ == "__main__": - # We don't support torch.compile() on Windows - if not IS_WINDOWS: - run_tests() + run_tests() diff --git a/test/inductor/test_static_triton_launcher.py b/test/inductor/test_static_triton_launcher.py index c16665c6154fe..599066a8fc06c 100644 --- a/test/inductor/test_static_triton_launcher.py +++ b/test/inductor/test_static_triton_launcher.py @@ -33,7 +33,7 @@ ) from torch._inductor.test_case import TestCase from torch.testing._internal.common_cuda import SM80OrLater -from torch.testing._internal.common_utils import IS_WINDOWS, skipIfRocm, skipIfXpu +from torch.testing._internal.common_utils import skipIfRocm, skipIfXpu from torch.testing._internal.inductor_utils import GPU_TYPE, HAS_XPU_AND_TRITON from torch.testing._internal.triton_utils import requires_gpu_and_triton from torch.utils._triton import has_triton_cuda_tma_device @@ -1372,7 +1372,4 @@ def gemm(a, b): if __name__ == "__main__": from torch._inductor.test_case import run_tests - - # TODO: Enable test on XPU windows once supported. - if not (HAS_XPU_AND_TRITON and IS_WINDOWS): - run_tests() + run_tests() diff --git a/test/inductor/test_torchinductor_opinfo.py b/test/inductor/test_torchinductor_opinfo.py index d01f1cefd1c2b..d33fc83d73f69 100644 --- a/test/inductor/test_torchinductor_opinfo.py +++ b/test/inductor/test_torchinductor_opinfo.py @@ -35,10 +35,8 @@ from torch.testing._internal.common_methods_invocations import op_db from torch.testing._internal.common_utils import ( IS_ARM64, - IS_CI, IS_LINUX, IS_MACOS, - IS_WINDOWS, IS_X86, skipCUDAMemoryLeakCheckIf, skipIfCrossRef, @@ -75,15 +73,6 @@ sys.exit(0) raise -if IS_WINDOWS and IS_CI: - # TODO(xuhancn) : improve the compiler build performance on windows. - sys.stderr.write( - "This UT is too slow on windows, and will cause out of time in CI. So skip it now.\n" - ) - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("skip slow test") - bf16 = torch.bfloat16 # not tested f64 = torch.float64 f32 = torch.float32 diff --git a/test/inductor/test_torchinductor_opinfo_properties.py b/test/inductor/test_torchinductor_opinfo_properties.py index c43612675aee0..0995f5af261a7 100644 --- a/test/inductor/test_torchinductor_opinfo_properties.py +++ b/test/inductor/test_torchinductor_opinfo_properties.py @@ -57,7 +57,6 @@ from torch.testing._internal.common_utils import ( getRocmVersion, IS_FBCODE, - IS_WINDOWS, parametrize, skipIfTorchDynamo, TEST_WITH_ASAN, @@ -805,7 +804,6 @@ def compile_fn(fn, backend): raise ValueError(f"Unknown backend: {backend}") -@unittest.skipIf(IS_WINDOWS, "Skipped on Windows") @unittest.skipIf(TEST_WITH_ASAN, "Skipped under ASAN") @unittest.skipIf(not HAS_GPU, "Requires GPU") class TestOpInfoProperties(TestCase): @@ -915,16 +913,6 @@ def test_batch_invariance(self, device, dtype, op, backend): across batch sizes, as split-k can produce different rounding based on how the work is partitioned. """ - if ( - op.name == "log1p" - and dtype == torch.float32 - and backend == "inductor_default" - and isRocmArchAnyOf(MI200_ARCH) - ): - # The static- vs dynamic-shape log1p mismatch (#191552) shows up on - # every MI300/MI350 run but only on some MI200 runs, so a strict - # xfail would flake there. - self.skipTest("log1p mismatch is intermittent on MI200 (#191552)") torch._dynamo.reset() device_type = torch.device(device).type diff --git a/test/nn/test_convolution.py b/test/nn/test_convolution.py index 750bdfcebe032..9357d5fb24453 100644 --- a/test/nn/test_convolution.py +++ b/test/nn/test_convolution.py @@ -56,7 +56,6 @@ run_tests, serialTest, set_default_dtype, - skipIfRocmArch, subtest, TEST_SCIPY, TEST_WITH_ROCM, @@ -3011,9 +3010,6 @@ def test_conv_transposed_large(self, device): @largeTensorTest("12GB") @serialTest() @skipXPU - # MI200-specific MIOpen failure, addressed by - # https://github.com/ROCm/rocm-libraries/pull/11809 - @skipIfRocmArch(MI200_ARCH) def test_conv_large(self, device): dtype = torch.half if self.device_type != "cpu" else torch.float conv = nn.Conv2d(2, 2, 8, 8, bias=False).to(device).to(dtype) diff --git a/test/nn/test_module_hooks.py b/test/nn/test_module_hooks.py index 6ebfea133cdba..3c48afaaf90aa 100644 --- a/test/nn/test_module_hooks.py +++ b/test/nn/test_module_hooks.py @@ -2,7 +2,6 @@ import gc import math import pickle -import unittest import warnings import weakref from collections import namedtuple, OrderedDict @@ -17,7 +16,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, instantiate_parametrized_tests, - IS_WINDOWS, parametrize as parametrize_test, run_tests, skipIfTorchDynamo, @@ -774,7 +772,6 @@ def load_hook_clear_incompatible(module, incompatible_keys): self.assertEqual([], ret.missing_keys) self.assertEqual([], ret.unexpected_keys) - @unittest.skipIf(IS_WINDOWS, "Tempfile permission issue on windows") @swap([True, False]) def test_load_state_dict_post_hook_backward_compatibility(self): def my_post_load_hook(mod, _): @@ -862,7 +859,6 @@ def forward(self, x): mod = MyLazyModule() self._test_register_state_dict_pre_hook(mod, mod.layer1) - @unittest.skipIf(IS_WINDOWS, "Tempfile permission issue on windows") def test_register_state_dict_pre_hook_backward_compat(self): called = False diff --git a/test/profiler/test_cpp_thread.py b/test/profiler/test_cpp_thread.py index 98274f36b5b00..19c58361114b0 100644 --- a/test/profiler/test_cpp_thread.py +++ b/test/profiler/test_cpp_thread.py @@ -6,10 +6,9 @@ import torch.utils.cpp_extension from torch.testing._internal.common_device_type import ( instantiate_device_type_tests, - skipCUDAIf, skipXPUIf, ) -from torch.testing._internal.common_utils import IS_WINDOWS, run_tests, TestCase +from torch.testing._internal.common_utils import run_tests, TestCase old_working_dir = os.getcwd() @@ -160,10 +159,6 @@ def check_trace(self, expected, mem=False) -> None: "not enough event recorded", ) - @skipCUDAIf( - IS_WINDOWS, - "Failing on windows cuda, see https://github.com/pytorch/pytorch/pull/130037 for slightly more context", - ) @skipXPUIf( True, "The XPU Profiler will not cover this case for now. Will support it in next period.", @@ -178,10 +173,6 @@ def test_with_enable_profiler_in_child_thread(self, device) -> None: } ) - @skipCUDAIf( - IS_WINDOWS, - "Failing on windows cuda, see https://github.com/pytorch/pytorch/pull/130037 for slightly more context", - ) @skipXPUIf( True, "The XPU Profiler will not cover this case for now. Will support it in next period.", @@ -196,10 +187,6 @@ def test_without_enable_profiler_in_child_thread(self, device) -> None: } ) - @skipCUDAIf( - IS_WINDOWS, - "Failing on windows cuda, see https://github.com/pytorch/pytorch/pull/130037 for slightly more context", - ) @skipXPUIf( True, "The XPU Profiler will not cover this case for now. Will support it in next period.", diff --git a/test/profiler/test_cuspy.py b/test/profiler/test_cuspy.py index c9c4a65397d38..5740ed3a12883 100644 --- a/test/profiler/test_cuspy.py +++ b/test/profiler/test_cuspy.py @@ -34,7 +34,6 @@ ) from torch.testing._internal.common_profiler import initialize_kineto_with_cuda from torch.testing._internal.common_utils import ( - IS_WINDOWS, run_tests, skipIfTorchDynamo, TemporaryFileName, @@ -251,7 +250,7 @@ def test_kernel_latency_timestamps_track_the_field_union(self): with patch.object( type(m._cupti), "enable_kernel_latency_timestamps", - lambda _self, _sub, enable: calls.append(enable) or True, + lambda _self, _sub, enable: True, ): timing = m.register( {ActivityKind.CONCURRENT_KERNEL: [Kernel.START.id, Kernel.END.id]}, @@ -3618,7 +3617,6 @@ def test_cuspy_zstd_perfetto_rejected(self): prof.profiler.export_chrome_trace.assert_not_called() -@unittest.skipIf(IS_WINDOWS, "Test is flaky on Windows") @unittest.skipIf(not TEST_CUDA, "CUDA is required") class TestCuspyProfiler(TestCase): """Cuspy driven through ``torch.profiler.profile`` (trace shape, op/kernel diff --git a/test/profiler/test_execution_trace.py b/test/profiler/test_execution_trace.py index cb358a49ee52d..50ee2f40dc1d4 100644 --- a/test/profiler/test_execution_trace.py +++ b/test/profiler/test_execution_trace.py @@ -30,7 +30,6 @@ skipCPUIf, ) from torch.testing._internal.common_utils import ( - IS_WINDOWS, run_tests, skipIfHpu, skipIfTorchDynamo, @@ -380,7 +379,6 @@ def test_execution_trace_env_disabled(self, device): self.assertTrue(p.execution_trace_observer is None) - @unittest.skipIf(IS_WINDOWS, "torch.compile does not support WINDOWS") @unittest.skipIf( sys.version_info >= (3, 12), "torch.compile is not supported on python 3.12+" ) @@ -448,7 +446,6 @@ def fn(a, b, c): if not found_call_compiled_fx_graph: raise AssertionError("Expected Call CompiledFxGraph node") - @unittest.skipIf(IS_WINDOWS, "torch.compile does not support WINDOWS") @unittest.skipIf( sys.version_info >= (3, 12), "torch.compile is not supported on python 3.12+" ) @@ -523,7 +520,6 @@ def fn(a, b, c): if not found_captured_triton_kernel_node: raise AssertionError("Expected captured triton kernel node") - @unittest.skipIf(IS_WINDOWS, "torch.compile does not support WINDOWS") @unittest.skipIf( not (has_triton() and (TEST_CUDA or TEST_XPU)), "need triton and device(CUDA or XPU) availability to run", diff --git a/test/profiler/test_memory_profiler.py b/test/profiler/test_memory_profiler.py index ce271fab7574d..d5c45fa8b3700 100644 --- a/test/profiler/test_memory_profiler.py +++ b/test/profiler/test_memory_profiler.py @@ -13,7 +13,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_MACOS, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TestCase, @@ -316,7 +315,7 @@ def test_extract_gradients_from_optimizer(self, device) -> None: self._test_extract_gradients_from_optimizer(device, set_to_none=False) @unittest.skipIf( - IS_MACOS or IS_WINDOWS, "https://github.com/pytorch/pytorch/issues/88721" + IS_MACOS, "https://github.com/pytorch/pytorch/issues/88721" ) def test_extract_gradients_from_optimizer_set_to_none(self, device) -> None: self._test_extract_gradients_from_optimizer(device, set_to_none=True) diff --git a/test/profiler/test_profiler.py b/test/profiler/test_profiler.py index 80c192ac8f732..d5bb5a61cc49d 100644 --- a/test/profiler/test_profiler.py +++ b/test/profiler/test_profiler.py @@ -64,7 +64,6 @@ IS_ARM64, IS_JETSON, IS_LINUX, - IS_WINDOWS, IS_X86, parametrize, run_tests, @@ -121,7 +120,6 @@ def setUpModule(): @unittest.skipIf(not HAS_PSUTIL, "Requires psutil to run") -@unittest.skipIf(IS_WINDOWS, "Test is flaky on Windows") class TestProfilerCUDA(TestCase): hw_classification = HardwareClassification.CUDA @@ -2203,7 +2201,6 @@ def test_activity_filter_invalid_type_name(self): y = torch.mm(x, x) @skipIfTorchDynamo("profiler gets ignored if dynamo activated") - @unittest.skipIf(IS_WINDOWS, "can't use os.fork() on Windows") # The child deadlocks once the parent has initialized Kineto's XPU profiler, # which setUpModule does on any XPU build. @unittest.skipIf( diff --git a/test/profiler/test_profiler_tree.py b/test/profiler/test_profiler_tree.py index 11e2e2f4795f5..47e8ef60735a3 100644 --- a/test/profiler/test_profiler_tree.py +++ b/test/profiler/test_profiler_tree.py @@ -21,7 +21,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_ARM64, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TEST_WITH_CROSSREF, @@ -82,7 +81,7 @@ # 2) We can diff the output to see how far we are from parity # # TODO: We also fail to capture events for Windows on some platforms. -ALLOW_CUDA_FAILURE = (torch.version.hip is not None) or IS_WINDOWS +ALLOW_CUDA_FAILURE = (torch.version.hip is not None) class TorchFunctionTensor(torch.Tensor): diff --git a/test/profiler/test_torch_tidy.py b/test/profiler/test_torch_tidy.py index f440274fe6e5e..b2e8bbf10eaf6 100644 --- a/test/profiler/test_torch_tidy.py +++ b/test/profiler/test_torch_tidy.py @@ -16,7 +16,6 @@ from torch.testing._internal.common_utils import ( IS_LINUX, IS_MACOS, - IS_WINDOWS, run_tests, TEST_WITH_TORCHDYNAMO, TestCase, @@ -368,7 +367,7 @@ def profiled_code(): ) @unittest.skipIf( - TEST_WITH_TORCHDYNAMO or IS_LINUX or IS_MACOS or IS_WINDOWS, + TEST_WITH_TORCHDYNAMO or IS_LINUX or IS_MACOS, "https://github.com/pytorch/pytorch/issues/87581", ) def test_module_and_optimizer_ids(self) -> None: diff --git a/test/run_test.py b/test/run_test.py index 3af22579eda2c..5b95f205d8384 100644 --- a/test/run_test.py +++ b/test/run_test.py @@ -31,7 +31,6 @@ _get_test_report_path, IS_CI, IS_MACOS, - IS_WINDOWS, retry_shell, sanitize_test_filename, set_cwd, @@ -1840,60 +1839,7 @@ def get_selected_tests(options) -> list[str]: selected_tests = exclude_tests(options.exclude, selected_tests) - if IS_WINDOWS and not options.ignore_win_blocklist: - from torch.testing._internal.common_cuda import SM120OrLater, SM89OrLater - - # Disable tests on Windows for SM89 and later - tests failing in ci - # Enable tests after fixing the failures - if SM89OrLater: - WINDOWS_BLOCKLIST.extend( - [ - # Windows fatal exception / access violation - "functorch/test_aotdispatch", - "functorch/test_control_flow", - "nn/test_convolution", - "profiler/test_profiler", - "test_modules", - "test_expanded_weights", - "test_nested_tensor", - "test_nestedtensor", - "test_nn", - # DLL load failed errors, missing dependencies - "test_custom_ops", - "test_testing", - # Features not supported on Windows ( e.g. rowwise scaling) - "test_decomp", - "test_transformers", - "test_ops", - # Output mismatch errors and long running tests - "test_linalg", - "test_matmul_cuda", - "functorch/test_ops", - "test_scaled_matmul_cuda", - ] - ) - - # Disable tests on Windows for SM120 and later - tests failing in ci - # Enable tests after fixing the failures - if SM120OrLater: - WINDOWS_BLOCKLIST.extend( - [ - # test_api fails on Windows SM120+. Triage pending. - "cpp/test_api", - ] - ) - - target_arch = os.environ.get("VSCMD_ARG_TGT_ARCH") - if target_arch != "x64": - WINDOWS_BLOCKLIST.append("cpp_extensions_aot_no_ninja") - WINDOWS_BLOCKLIST.append("cpp_extensions_aot_ninja") - WINDOWS_BLOCKLIST.append("cpp_extensions_jit") - WINDOWS_BLOCKLIST.append("jit") - WINDOWS_BLOCKLIST.append("jit_fuser") - - selected_tests = exclude_tests(WINDOWS_BLOCKLIST, selected_tests, "on Windows") - - elif TEST_WITH_ROCM: + if TEST_WITH_ROCM: selected_tests = exclude_tests(ROCM_BLOCKLIST, selected_tests, "on ROCm") # skip all distributed tests if distributed package is not available. diff --git a/test/spincli/test_spin.py b/test/spincli/test_spin.py index f1678e1c7293c..7986cc00f732e 100644 --- a/test/spincli/test_spin.py +++ b/test/spincli/test_spin.py @@ -8,7 +8,6 @@ import subprocess import sys import tempfile -import unittest from pathlib import Path from types import SimpleNamespace from unittest import mock @@ -18,7 +17,6 @@ from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_S390X, parametrize, run_tests, subtest, @@ -69,7 +67,6 @@ def _registered_commands(): class TestSpin(TestCase): - @unittest.skipIf(IS_S390X, "pyrefly doesn't support s390x") def test_autotype(self): with tempfile.TemporaryDirectory() as tmp_dir: here = Path(__file__).parent diff --git a/test/test_autograd.py b/test/test_autograd.py index 193f515b9ae43..f58dbbf5a19cd 100644 --- a/test/test_autograd.py +++ b/test/test_autograd.py @@ -69,10 +69,8 @@ gradgradcheck, HardwareClassification, instantiate_parametrized_tests, - IS_ARM64, IS_LINUX, IS_MACOS, - IS_WINDOWS, parametrize, run_tests, scoped_load_inline, @@ -7674,7 +7672,6 @@ def test_set_data_self_requires_grad(self): ): a.data = c - @unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") def test_thread_shutdown(self): code = """import torch from torch.autograd import Function @@ -14058,12 +14055,9 @@ def test_gradcheck_input_output_different_device(self, device): IS_LINUX or TEST_WITH_SLOW, "https://github.com/pytorch/pytorch/issues/181229" ) @unittest.skipIf( - TEST_WITH_ASAN or IS_LINUX or IS_MACOS or IS_WINDOWS, + TEST_WITH_ASAN or IS_LINUX or IS_MACOS, "https://github.com/pytorch/pytorch/issues/181203", ) - @unittest.skipIf( - IS_WINDOWS and IS_ARM64, "Fails on Windows ARM64; see issue #181228" - ) def test_strided_leaf_grad_layout(self, device): # (1) If leaf is non-overlapping and dense, grad's layout should match its leaf. for fmt_a in (torch.contiguous_format, torch.channels_last): @@ -17963,12 +17957,9 @@ class TestAutogradMultipleDispatchGeneric(TestCase): IS_LINUX or TEST_WITH_SLOW, "https://github.com/pytorch/pytorch/issues/181323" ) @unittest.skipIf( - TEST_WITH_ASAN or IS_LINUX or IS_MACOS or IS_WINDOWS, + TEST_WITH_ASAN or IS_LINUX or IS_MACOS, "https://github.com/pytorch/pytorch/issues/181228", ) - @unittest.skipIf( - IS_WINDOWS and IS_ARM64, "Fails on Windows ARM64; see issue #181228" - ) def test_is_retain_graph(self): retain_graph_set = False diff --git a/test/test_cpp_extensions_aot.py b/test/test_cpp_extensions_aot.py index 9f07d518420e7..41ce3f8b9eb2a 100644 --- a/test/test_cpp_extensions_aot.py +++ b/test/test_cpp_extensions_aot.py @@ -15,7 +15,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, instantiate_parametrized_tests, - IS_WINDOWS, parametrize, skipIfTorchDynamo, xfailIfTorchDynamo, @@ -100,7 +99,6 @@ def test_backward(self): expected_tensor_grad = torch.ones([4, 4], dtype=torch.double).mm(weights.t()) self.assertEqual(tensor.grad, expected_tensor_grad) - @unittest.skipIf(IS_WINDOWS, "Not available on Windows") def test_no_python_abi_suffix_sets_the_correct_library_name(self): # For this test, run_test.py will call # `python -m pip install . -v --no-build-isolation` in the @@ -144,7 +142,6 @@ def test_sigmoid_add_extension(self, device_type): class TestCppExtensionAOTCUDA(common.TestCase): hw_classification = HardwareClassification.CUDA - @unittest.skipIf(common.IS_WINDOWS, "Windows not supported") @unittest.skipIf(not TEST_CUDA, "CUDA not found") def test_cublas_extension(self): from torch_test_cpp_extension import cublas_extension @@ -153,7 +150,6 @@ def test_cublas_extension(self): z = cublas_extension.noop_cublas_function(x) self.assertEqual(z, x) - @unittest.skipIf(common.IS_WINDOWS, "Windows not supported") @unittest.skipIf(not TEST_CUDA, "CUDA not found") def test_cusolver_extension(self): from torch_test_cpp_extension import cusolver_extension @@ -163,7 +159,6 @@ def test_cusolver_extension(self): self.assertEqual(z, x) @common.skipIfRocm(msg="dlink build path has no ROCm arch handling") - @unittest.skipIf(common.IS_WINDOWS, "Windows not supported") @unittest.skipIf(not TEST_CUDA, "CUDA not found") @unittest.skipIf( os.getenv("USE_NINJA", "0") == "0", diff --git a/test/test_cuda.py b/test/test_cuda.py index 790928c04bd25..98342fc197c82 100644 --- a/test/test_cuda.py +++ b/test/test_cuda.py @@ -47,7 +47,6 @@ PLATFORM_SUPPORTS_GREEN_CONTEXT, PLATFORM_SUPPORTS_WORKQUEUE_CONFIG, ROCM_VERSION, - SM89OrLater, TEST_CUDNN, TEST_MULTIGPU, tf32_enabled, @@ -86,7 +85,6 @@ IS_JETSON, IS_LINUX, IS_SANDCASTLE, - IS_WINDOWS, IS_X86, load_tests, MI350_ARCH, @@ -178,8 +176,6 @@ def wrapper(self, *args, **kwargs): def skip_background_threads_on_windows(f): @functools.wraps(f) def wrapped(self, **kwargs): - if IS_WINDOWS and SM89OrLater and kwargs.get("use_background_threads"): - raise unittest.SkipTest("using background threads fails on Windows") return f(self, **kwargs) return wrapped @@ -685,7 +681,6 @@ def test_pinned_memory_empty_cache(self): # Pinned allocator background thread does not shut down cleanly on Windows # Python process hangs - @unittest.skipIf(IS_WINDOWS and SM89OrLater, "Fails on windows with SM89+") def test_pinned_memory_use_background_threads(self): script = """ import torch @@ -883,7 +878,6 @@ def test_out_of_memory(self): # CUDA memory allocations on windows do not OOM on rtx even when they cross allowed memory # Skip test until this is investigated - @unittest.skipIf(IS_WINDOWS and SM89OrLater, "Fails on windows with SM89+") @unittest.skipIf( TEST_CUDAMALLOCASYNC or IS_JETSON, "Segmentation fault (core dumped)" ) @@ -920,9 +914,6 @@ def test_out_of_memory_retry(self): @unittest.skipIf( IS_FBCODE or IS_SANDCASTLE, "glog may route c10 logs away from stderr" ) - # Same platform skips as test_out_of_memory_retry above: Windows/SM89+ does - # not reliably OOM past the free memory, Jetson segfaults on this pattern. - @unittest.skipIf(IS_WINDOWS and SM89OrLater, "Fails on windows with SM89+") @unittest.skipIf(IS_JETSON, "Segmentation fault (core dumped)") @skipIfRocmArch(MI350_ARCH) @serialTest() @@ -1174,9 +1165,6 @@ def test_serialization_array_with_storage(self): q_copy[1].fill_(10) self.assertEqual(q_copy[3], torch.cuda.IntStorage(10).fill_(10)) - @unittest.skipIf( - IS_WINDOWS and SM89OrLater, "preferred_blas_library not supported on Windows" - ) @unittest.skipIf(IS_FBCODE or IS_SANDCASTLE, "Does not work in fbcode yet") @setBlasBackendsToDefaultFinally def test_preferred_blas_library_settings(self): @@ -1277,9 +1265,6 @@ def test_current_solver_handle(self): self.assertIsInstance(handle, int) self.assertNotEqual(handle, 0) - @unittest.skipIf( - IS_WINDOWS and SM89OrLater, "preferred_blas_library not supported on Windows" - ) @unittest.skipIf(TEST_CUDAMALLOCASYNC, "temporarily disabled for async") @serialTest() @blas_library_context("cublas") @@ -3285,7 +3270,6 @@ def _worker(t): self.assertEqual(results[t].sum().item(), size * size) # Test is flaky on Windows (https://github.com/pytorch/pytorch/issues/57401) - @unittest.skipIf(IS_WINDOWS, "Test is flaky on Windows (see issue 57401)") @unittest.skipIf(not TEST_CUDNN, "CUDNN not available") def test_cudnn_multiple_threads_same_device(self): # This function is intended to test the lazy creation and reuse of per-thread @@ -5364,7 +5348,7 @@ def func_with_temps(t, val): torch.cuda.empty_cache() @unittest.skipIf( - (not TEST_CUDA_GRAPH) or IS_WINDOWS, + (not TEST_CUDA_GRAPH), "Graph bindings disallow concurrent replay; " + "still appears broken on Windows. See " + "https://github.com/pytorch/pytorch/pull/57556", @@ -6760,7 +6744,7 @@ def check_output(script: str) -> str: test_script = f"import os; import torch;os.environ['{VISIBLE_DEVICES}']='1024';torch.get_device_module().device_count();print(torch.cuda.device_count())" rc = check_output(test_script) self.assertEqual(rc, "0") - if TEST_WITH_ROCM and not IS_WINDOWS: + if TEST_WITH_ROCM: # hipGetDeviceCount initializes the runtime, so it cannot report # hipErrorNotInitialized. hsa_system_get_info returns # HSA_STATUS_ERROR_NOT_INITIALIZED (0x100B) until hsa_init. @@ -6785,7 +6769,7 @@ def check_output(script: str) -> str: # Check that `cuInit` was not called during the import # By using ctypes and calling cuDeviceCountGet() and expect CUDA_ERROR_NOT_INITIALIZED == 3 # See https://github.com/pytorch/pytorch/issues/116276 for more details - libcuda_name = "libcuda.so.1" if not IS_WINDOWS else "nvcuda.dll" + libcuda_name = "libcuda.so.1" cuda_driver_api_call = ( f"ctypes.CDLL('{libcuda_name}').cuDeviceGetCount(ctypes.byref(x))" ) @@ -6855,9 +6839,6 @@ def test_device_count_not_cached_pre_init(self): x = torch.cuda.device_count() self.assertEqual(f"{x}, 1", r) - @unittest.skipIf( - IS_WINDOWS, "test relies on fork; Windows multiprocessing uses spawn" - ) def test_is_pinned_no_context(self): test_script = """\ import torch @@ -8552,28 +8533,12 @@ def test_throw_on_cudamalloc_oom(self): def test_allocator_backend(self): def subprocess_env(): - if IS_WINDOWS: - # An empty env breaks Windows stdlib/CUDA extension loading (no PATH). - return { - k: os.environ[k] - for k in ( - "SYSTEMROOT", - "SYSTEMDRIVE", - "WINDIR", - "COMSPEC", - "PATH", - ) - if k in os.environ - } - else: - return { - k: os.environ[k] for k in ("LD_LIBRARY_PATH",) if k in os.environ - } + return { + k: os.environ[k] for k in ("LD_LIBRARY_PATH",) if k in os.environ + } def check_output(script: str) -> str: kwargs = {"env": subprocess_env(), "text": True} - if IS_WINDOWS: - kwargs["cwd"] = tempfile.gettempdir() return subprocess.check_output( [sys.executable, "-c", script], **kwargs ).strip() @@ -8823,20 +8788,9 @@ def test_device_memory_used(self): torch.cuda.synchronize() torch.cuda.empty_cache() b = torch.cuda.device_memory_used() - if IS_WINDOWS: - # NVML used memory does not reflect CUDA allocations on WDDM; only check API sanity - self.assertGreaterEqual(a, 0, "device_memory_used should be non-negative") - self.assertGreaterEqual(b, 0, "device_memory_used should be non-negative") - self.assertGreaterEqual( - b, a, "used memory should not decrease after allocation" - ) - total = torch.cuda.get_device_properties(0).total_memory - self.assertLessEqual(a, total, "used should not exceed total device memory") - self.assertLessEqual(b, total, "used should not exceed total device memory") - else: - mem_bytes = b - a - # test the order of magnitude - self.assertTrue(num_bytes // 32 <= mem_bytes <= num_bytes * 32) + mem_bytes = b - a + # test the order of magnitude + self.assertTrue(num_bytes // 32 <= mem_bytes <= num_bytes * 32) @unittest.skipIf(not TEST_PYNVML, "pynvml/amdsmi is not available") def test_power_draw(self): @@ -14738,7 +14692,7 @@ def test_initialization_before_support_check(self) -> None: patch.object( memory, "is_localization_supported", - side_effect=lambda device: order.append("query") or True, + side_effect=lambda device: True, ), patch.object(memory, "get_num_locality_domains", return_value=2), patch.dict(memory._LOCALITY_ALLOCATORS, clear=True), diff --git a/test/test_cuda_nvml_based_avail.py b/test/test_cuda_nvml_based_avail.py index b443f0aabc103..a14905b3bcf01 100644 --- a/test/test_cuda_nvml_based_avail.py +++ b/test/test_cuda_nvml_based_avail.py @@ -18,7 +18,6 @@ from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, IS_JETSON, - IS_WINDOWS, NoTest, parametrize, run_tests, @@ -55,7 +54,7 @@ def in_bad_fork_test() -> bool: _ = torch.cuda.is_available() return torch.cuda._is_in_bad_fork() - @unittest.skipIf(IS_WINDOWS or torch.version.hip is not None, "NVIDIA fork test") + @unittest.skipIf(torch.version.hip is not None, "NVIDIA fork test") def test_triton_driver_probe_does_not_poison_fork(self): if not has_triton_package(): self.skipTest("Triton not installed") @@ -74,7 +73,6 @@ def test_triton_driver_probe_does_not_poison_fork(self): # `torch.cuda.is_available()` assessment. The NVML-based assessment should be attempted when # `PYTORCH_NVML_BASED_CUDA_CHECK` is set to 1, reverting to the default CUDA Runtime API check otherwise. # If the NVML-based assessment is attempted but fails, the CUDA Runtime API check should be executed - @unittest.skipIf(IS_WINDOWS, "Needs fork") @parametrize("nvml_avail", [True, False]) @parametrize("avoid_init", ["1", "0", None]) def test_cuda_is_available(self, avoid_init, nvml_avail): diff --git a/test/test_custom_ops.py b/test/test_custom_ops.py index 54dbc12e49029..9eaab40eb609a 100644 --- a/test/test_custom_ops.py +++ b/test/test_custom_ops.py @@ -52,7 +52,6 @@ instantiate_parametrized_tests, IS_LINUX, IS_MACOS, - IS_WINDOWS, parametrize, run_tests, scoped_load_inline, @@ -88,7 +87,7 @@ def requires_compile(fun): - fun = unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work with windows")(fun) + fun = unittest.skipIf(False, "torch.compile doesn't work with windows")(fun) return fun @@ -2262,7 +2261,6 @@ def forward(self, x_1): return numpy_view_copy""", ) - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work on windows") def test_data_dependent_compile(self): import torch._dynamo.testing from torch._dynamo.utils import counters @@ -5406,15 +5404,13 @@ def add(x: Tensor, y: float) -> Tensor: Please use `add.register_fake` to add an fake impl.""", ) - if not IS_WINDOWS: - - @torch.compile(backend="eager") - def f(x, y): - return add(x, y) + @torch.compile(backend="eager") + def f(x, y): + return add(x, y) - x = torch.randn(3) - with self.assertRaisesRegex(RuntimeError, "no fake impl"): - f(x, y) + x = torch.randn(3) + with self.assertRaisesRegex(RuntimeError, "no fake impl"): + f(x, y) abstract_called = False @@ -5431,7 +5427,6 @@ def _(x, y): self.assertTrue(abstract_called) @skipIfTorchDynamo("recursive dynamo") - @unittest.skipIf(IS_WINDOWS, "torch.compile doesn't work on windows") def test_compile(self): called_impl = False called_abstract = False @@ -6840,7 +6835,6 @@ def test_yaml(self): loaded = read_profiles_from_yaml(yaml_str) self.assertEqual(op_profiles, loaded) - @unittest.skipIf(IS_WINDOWS, "Windows not supported for this test") def test_save_to_file(self): op_profile = self.get_sample_op_profile("mylib.foo.default") diff --git a/test/test_dataloader.py b/test/test_dataloader.py index b868de1b7e9be..f74efc5ddcbf2 100644 --- a/test/test_dataloader.py +++ b/test/test_dataloader.py @@ -32,7 +32,6 @@ IS_LINUX, IS_MACOS, IS_SANDCASTLE, - IS_WINDOWS, load_tests, parametrize, run_tests, @@ -650,10 +649,9 @@ def test_iterable_dataset_err(self): # takes in dummy var so this can also be used as a `worker_init_fn` def set_faulthander_if_available(_=None): faulthandler.enable(sys.__stderr__) - if not IS_WINDOWS: - # windows does not have faulthandler.register - # chain=False prevents the default behavior of killing the process - faulthandler.register(signal.SIGUSR1, file=sys.__stderr__, chain=False) + # windows does not have faulthandler.register + # chain=False prevents the default behavior of killing the process + faulthandler.register(signal.SIGUSR1, file=sys.__stderr__, chain=False) set_faulthander_if_available() @@ -661,13 +659,8 @@ def set_faulthander_if_available(_=None): # Process `pid` must have called `set_faulthander_if_available` def print_traces_of_all_threads(pid): - if not IS_WINDOWS: - # use the custom signal if available - os.kill(pid, signal.SIGUSR1) - else: - # otherwise we can still use the handler given by faulthandler.enable() - # at the cost of killing the process. - os.kill(pid, signal.SIGSEGV) + # use the custom signal if available + os.kill(pid, signal.SIGUSR1) # wait in parent process to give subprocess some time to print time.sleep(5) @@ -1320,7 +1313,6 @@ def _create_dataloader(is_train: bool) -> DataLoader[list[torch.Tensor]]: pass @unittest.skipIf(IS_SANDCASTLE, "subprocess doesn't work in FB internal CI") - @unittest.skipIf(IS_WINDOWS, "No 'resource' module on Windows") def test_fd_limit_exceeded(self): # See NOTE [ DataLoader on Linux and open files limit ] import subprocess @@ -1429,15 +1421,11 @@ def test_segfault(self): try: self.assertFalse(p.is_alive()) self.assertNotEqual(p.exitcode, 0) - if IS_WINDOWS: - self.assertIsInstance(p.exception, OSError) - self.assertRegex(str(p.exception), r"access violation reading ") - else: - self.assertIsInstance(p.exception, RuntimeError) - self.assertRegex( - str(p.exception), - r"DataLoader worker \(pid \d+\) is killed by signal: ", - ) + self.assertIsInstance(p.exception, RuntimeError) + self.assertRegex( + str(p.exception), + r"DataLoader worker \(pid \d+\) is killed by signal: ", + ) finally: p.terminate() @@ -1446,7 +1434,6 @@ def test_segfault(self): # After forking, set_num_threads(1) in the child process entails handling some inherited data-structures # of the Caffe2 thread-pool of the parent process, culminating in a segfault. # Reference: https://github.com/pytorch/pytorch/issues/54752 - @unittest.skipIf(IS_WINDOWS, "Needs fork") def test_no_segfault(self): p = ErrorTrackingProcess(target=_test_no_segfault) p.start() @@ -1937,7 +1924,7 @@ def test_worker_init_fn(self): self.assertEqual(12345, batch[1]) @unittest.skipIf( - IS_WINDOWS or IS_MACOS, + IS_MACOS, "`ValueError: cannot find context for 'forkserver'` in Windows", ) def test_worker_init_fn_forkserver(self): @@ -2506,7 +2493,6 @@ def __getitem__(self, idx): self.assertIn("__getitem__", error_message) self.assertIn("__getitems__", error_message) - @unittest.skipIf(IS_WINDOWS, "FIXME: stuck test") def test_partial_workers(self): r"""Check that workers exit even if the iterator is not exhausted.""" if TEST_PIN_MEMORY: @@ -2559,7 +2545,7 @@ def test_proper_exit(self): # not be called before process end. It is important to see that the # processes still exit in both cases. - if pin_memory and (not TEST_PIN_MEMORY or IS_WINDOWS): + if pin_memory and not TEST_PIN_MEMORY: # This test runs in a subprocess, which can only initialize the # accelerator with spawn. DataLoader with pin_memory=True initializes # the accelerator when its iterator is constructed. @@ -3215,7 +3201,6 @@ def setUp(self): self.persistent_workers = True @unittest.skipIf(IS_SANDCASTLE, "subprocess doesn't work in FB internal CI") - @unittest.skipIf(IS_WINDOWS, "No 'resource' module on Windows") def test_fd_limit_exceeded(self): # See NOTE [ DataLoader on Linux and open files limit ] import subprocess @@ -3381,7 +3366,6 @@ def test_dataset_not_reset(self): dataset.start = i @unittest.skipIf(IS_SANDCASTLE, "subprocess doesn't work in FB internal CI") - @unittest.skipIf(IS_WINDOWS, "Needs fork") def test_early_exit(self): import subprocess @@ -3486,7 +3470,6 @@ def test_multiprocessing_contexts(self): if ( ctx in ["spawn", "forkserver"] and TEST_CUDA - and not IS_WINDOWS and not IS_JETSON ): ds_cls = CUDACountingDataset @@ -3715,7 +3698,7 @@ def _run_ind_worker_queue_test(self, batch_size, num_workers): current_worker_idx = 0 @unittest.skipIf( - IS_WINDOWS or IS_MACOS, + IS_MACOS, "Flaky on Windows and MacOS https://github.com/pytorch/pytorch/issues/68643", ) def test_ind_worker_queue(self): @@ -3785,7 +3768,6 @@ def __getitem__(self, index): return torch.nn.functional.conv1d(self.x, torch.ones(1, 1, 2)) -@unittest.skipIf(IS_WINDOWS, "Needs fork") class TestConvAfterFork(TestCase): hw_classification = HardwareClassification.GENERIC diff --git a/test/test_dynamic_shapes.py b/test/test_dynamic_shapes.py index 6ee4d57077e81..679fdeba67e54 100644 --- a/test/test_dynamic_shapes.py +++ b/test/test_dynamic_shapes.py @@ -57,7 +57,6 @@ instantiate_parametrized_tests, IS_LINUX, IS_MACOS, - IS_WINDOWS, parametrize, run_tests, skipIfTorchDynamo, @@ -4412,8 +4411,7 @@ def func(a, b): or IS_LINUX or IS_MACOS or TEST_WITH_ROCM - or TEST_WITH_SLOW - or IS_WINDOWS, + or TEST_WITH_SLOW, "https://github.com/pytorch/pytorch/issues/163953", ) @skipIfTorchDynamo("mark_unbacked is not traceable") diff --git a/test/test_functional_autograd_benchmark.py b/test/test_functional_autograd_benchmark.py index 4f54f5b4eaea6..3a6acf0f4fe7a 100644 --- a/test/test_functional_autograd_benchmark.py +++ b/test/test_functional_autograd_benchmark.py @@ -8,7 +8,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, slowTest, TemporaryFileName, @@ -70,10 +69,6 @@ def test_fast_tasks(self): self._test_runner(task) @slowTest - @unittest.skipIf( - IS_WINDOWS, - "NamedTemporaryFile on windows does not have all the features we need.", - ) def test_slow_tasks(self): slow_tasks = ["fcn_resnet", "detr"] # deepspeech is voluntarily excluded as it takes too long to run without diff --git a/test/test_functionalization.py b/test/test_functionalization.py index da53d34f3fc5c..634d2a9850eeb 100644 --- a/test/test_functionalization.py +++ b/test/test_functionalization.py @@ -20,7 +20,6 @@ from torch.multiprocessing.reductions import StorageWeakRef from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TEST_WITH_TORCHDYNAMO, @@ -1877,16 +1876,12 @@ def f(x, running_mean, running_var): self.assert_functionalization( f, torch.randn(20, size, 35, 45), torch.zeros(size), torch.ones(size) ) - # On Windows, for instance_norm, the alias_copy's are reordered to come right before they need to be used - # whereas on other platforms, the alias_copy's are before the view_copy's. - # e.g., the alias_copy after the getitem_4 assignment would be moved to be right before the copy assignment. - if not IS_WINDOWS: - logs = self.get_logs( - f, torch.randn(20, size, 35, 45), torch.zeros(size), torch.ones(size) - ) - self.assertExpectedInline( - logs, - """\ + logs = self.get_logs( + f, torch.randn(20, size, 35, 45), torch.zeros(size), torch.ones(size) + ) + self.assertExpectedInline( + logs, + """\ @@ -1920,19 +1915,19 @@ def forward(self, arg0_1, arg1_1, arg2_1): copy__1 = torch.ops.aten.copy_.default(arg2_1, alias_copy_4); arg2_1 = alias_copy_4 = copy__1 = None return view_copy_5 """, - ) + ) - reinplaced_logs = self.get_logs( - f, - torch.randn(20, size, 35, 45), - torch.zeros(size), - torch.ones(size), - reapply_views=True, - run_reinplace=True, - ) - self.assertExpectedInline( - reinplaced_logs, - """\ + reinplaced_logs = self.get_logs( + f, + torch.randn(20, size, 35, 45), + torch.zeros(size), + torch.ones(size), + reapply_views=True, + run_reinplace=True, + ) + self.assertExpectedInline( + reinplaced_logs, + """\ @@ -1966,7 +1961,7 @@ def forward(self, arg0_1, arg1_1, arg2_1): copy__1 = torch.ops.aten.copy_.default(arg2_1, alias_4); arg2_1 = alias_4 = copy__1 = None return view_5 """, - ) + ) def test_mutation_overlapping_mem(self): def fn(x): diff --git a/test/test_functionalization_of_rng_ops.py b/test/test_functionalization_of_rng_ops.py index 89dcc70d5fd3f..19b85e44c4ff9 100644 --- a/test/test_functionalization_of_rng_ops.py +++ b/test/test_functionalization_of_rng_ops.py @@ -1,7 +1,5 @@ # Owner(s): ["oncall: pt2"] import functools -import sys -import unittest from unittest.mock import patch import torch @@ -15,18 +13,10 @@ from torch.testing._internal.common_utils import ( HardwareClassification, - IS_CI, - IS_WINDOWS, run_tests, TestCase, ) -if IS_WINDOWS and IS_CI: - sys.stderr.write("torch.compile not supported on windows") - if __name__ == "__main__": - sys.exit(0) - raise unittest.SkipTest("torch.compile not supported on windows") - def count_philox_rand(gm, args, freq): count = [node.target for node in gm.graph.nodes].count( diff --git a/test/test_futures.py b/test/test_futures.py index 611faa3b407fe..d3c38f3b3827c 100644 --- a/test/test_futures.py +++ b/test/test_futures.py @@ -4,9 +4,8 @@ import threading import time import torch -import unittest from torch.futures import Future -from torch.testing._internal.common_utils import IS_WINDOWS, TestCase, TemporaryFileName, run_tests +from torch.testing._internal.common_utils import TestCase, TemporaryFileName, run_tests from typing import TypeVar T = TypeVar("T") @@ -314,7 +313,6 @@ def slow_in_thread(fut, value): self.assertEqual(res[1].wait(), 2) t.join() - @unittest.skipIf(IS_WINDOWS, "TODO: need to fix this testcase for Windows") def test_wait_all(self): fut1 = Future[int]() fut2 = Future[int]() diff --git a/test/test_fx.py b/test/test_fx.py index 79314f60a0ea0..7d66125087e06 100644 --- a/test/test_fx.py +++ b/test/test_fx.py @@ -79,14 +79,9 @@ HardwareClassification, IS_FBCODE, IS_MACOS, - IS_ARM64, - IS_LINUX, - IS_CPU_CAPABILITY_SVE256, - IS_WINDOWS, TEST_WITH_CROSSREF, run_tests, skipIfTorchDynamo, - xfailIf, xfailIfNoAcceleratorTriton, ) from torch.testing._internal.common_utils import TestCase @@ -282,7 +277,7 @@ def setUp(self): ) torch.fx.proxy.TracerBase.check_mutable_operations = True - if not (IS_FBCODE or IS_WINDOWS or IS_MACOS): + if not (IS_FBCODE or IS_MACOS): lib_file_path = find_library_location("libtorchbind_test.so") torch.ops.load_library(str(lib_file_path)) @@ -1020,7 +1015,7 @@ def forward(self, a, b): self.checkGraphModule(m, (a, b)) def test_native_callable(self): - if IS_FBCODE or IS_WINDOWS or IS_MACOS: + if IS_FBCODE or IS_MACOS: raise unittest.SkipTest("non-portable load_library call used in test") # This test exercises the case where we use FX to translate from Python # code to some native callable object @@ -2258,7 +2253,6 @@ def is_leaf_module(self, m, module_qualified_name): f"Expected tensor_meta[1].shape == torch.Size([]), " f"got {tensor_meta[1].shape}" ) - @xfailIf(IS_ARM64 and IS_LINUX and IS_CPU_CAPABILITY_SVE256) # RuntimeError: label is too far def test_shape_prop_layout_3d(self): class ConvTest3d(torch.nn.Module): def __init__(self) -> None: @@ -3302,7 +3296,7 @@ def test_update_args_kwargs_yells_at_you(self): node.__update_args_kwargs((), {}) def test_torchbind_class_attribute_in_fx(self): - if IS_FBCODE or IS_WINDOWS or IS_MACOS: + if IS_FBCODE or IS_MACOS: self.skipTest( "torch.classes._TorchScriptTesting._StackString is registered, skipping" ) @@ -3319,7 +3313,7 @@ def forward(self): self.checkGraphModule(m, ()) def test_torchbind_class_attribute_in_fx_tensor_arg(self): - if IS_FBCODE or IS_WINDOWS or IS_MACOS: + if IS_FBCODE or IS_MACOS: self.skipTest( "torch.classes._TorchScriptTesting._ReLUClass is registered, skipping" ) @@ -5034,32 +5028,21 @@ def forward(self, x): else: kernel_event = "cudaLaunchKernel" kernel_event_relu = "cudaLaunchKernel" - - if IS_WINDOWS: - self._assert_profiler_stack_traces_for_nodes( - actual_traces, - { - "addmm": ("linear",), - "relu": ("relu",), - "addmm_1": ("linear",), - }, - ) - else: - # cuBLASLt added two internal cudaStreamIsCapturing checks before - # launching GEMM kernels starting with CUDA 13.4, which show up - # as extra runtime events ahead of each addmm's kernel launch. - extra_event = not torch.version.hip and _get_torch_cuda_version() >= (13, 4) - capture_1, capture_2 = "", "" - if extra_event: - capture_1 = ( - "event=cudaStreamIsCapturing node=addmm " - "stack_trace=x = self.linear1(x)\n" - ) * 2 - capture_2 = ( - "event=cudaStreamIsCapturing node=addmm_1 " - "stack_trace=x = self.linear2(x)\n" - ) * 2 - expected = f"""\ + # cuBLASLt added two internal cudaStreamIsCapturing checks before + # launching GEMM kernels starting with CUDA 13.4, which show up + # as extra runtime events ahead of each addmm's kernel launch. + extra_event = not torch.version.hip and _get_torch_cuda_version() >= (13, 4) + capture_1, capture_2 = "", "" + if extra_event: + capture_1 = ( + "event=cudaStreamIsCapturing node=addmm " + "stack_trace=x = self.linear1(x)\n" + ) * 2 + capture_2 = ( + "event=cudaStreamIsCapturing node=addmm_1 " + "stack_trace=x = self.linear2(x)\n" + ) * 2 + expected = f"""\ event=aten::t node=t stack_trace=x = self.linear1(x) event=aten::transpose node=t stack_trace=x = self.linear1(x) event=aten::as_strided node=t stack_trace=x = self.linear1(x) @@ -5073,7 +5056,7 @@ def forward(self, x): event=aten::as_strided node=t_1 stack_trace=x = self.linear2(x) event=aten::addmm node=addmm_1 stack_trace=x = self.linear2(x) {capture_2}event={kernel_event} node=addmm_1 stack_trace=x = self.linear2(x)""" - self.assertExpectedInline(actual_traces, expected) + self.assertExpectedInline(actual_traces, expected) @torch.fx.experimental._config.patch("enrich_profiler_metadata", True) def test_profiler_multiple_modules(self, device): diff --git a/test/test_jiterator.py b/test/test_jiterator.py index 7466bd6b993f1..4455ffa13d72e 100644 --- a/test/test_jiterator.py +++ b/test/test_jiterator.py @@ -11,7 +11,6 @@ from torch.cuda.jiterator import _create_jit_fn as create_jit_fn from torch.cuda.jiterator import _create_multi_output_jit_fn as create_multi_output_jit_fn from torch.testing._internal.common_utils import ( - IS_WINDOWS, NoTest, parametrize, run_tests, @@ -176,8 +175,6 @@ def test_invalid_function_name(self, code_string): create_jit_fn(code_string) def test_corrupt_kernel_cache_recompiles(self, device): - if IS_WINDOWS: - self.skipTest("prod JITerator reduction is disabled on Windows") script = textwrap.dedent(""" import torch diff --git a/test/test_linalg.py b/test/test_linalg.py index be0cd0eab52d9..79fb109f0b020 100644 --- a/test/test_linalg.py +++ b/test/test_linalg.py @@ -26,12 +26,12 @@ ) from torch.testing._internal.common_utils import \ - (TestCase, run_tests, TEST_SCIPY, IS_MACOS, IS_WINDOWS, slowTest, + (TestCase, run_tests, TEST_SCIPY, IS_MACOS, slowTest, TEST_WITH_ROCM, IS_FBCODE, IS_REMOTE_GPU, iter_indices, make_fullrank_matrices_with_distinct_singular_values, freeze_rng_state, IS_ARM64, IS_SANDCASTLE, TEST_OPT_EINSUM, isRocmArchAnyOf, parametrize, subtest, skipIfTorchDynamo, skipIfRocmArch, skipIfRocmVersionInRange, setBlasBackendsToDefaultFinally, setLinalgBackendsToDefaultFinally, serialTest, skipIfRocm, - MI200_ARCH, MI300_ARCH, MI350_ARCH, NAVI_ARCH, TEST_CUDA, + MI350_ARCH, NAVI_ARCH, TEST_CUDA, skipIfNoNvmath, _restore_fp32_precision, _snapshot_fp32_precision) from torch.testing._internal.common_device_type import \ (instantiate_device_type_tests, dtypes, has_cusolver, onlyCPU, skipCPUIfNoLapack, precisionOverride, @@ -2064,7 +2064,6 @@ def test_matrix_norm(self, device, dtype): # Test that linal.norm gives the same result as numpy when inputs # contain extreme values (inf, -inf, nan) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @unittest.skipIf(IS_MACOS, "Skipped on MacOS!") @skipCUDAIfNoLinalgsolver @skipCPUIfNoLapack @@ -6983,7 +6982,6 @@ def test_matmul_45724(self, device): torch.matmul(a, b, out=c) self.assertEqual(c, cpu_result) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @unittest.skipIf(SM90OrLater and not TEST_WITH_ROCM, "Expected failure on sm90") @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "cublas runtime error") @onlyCUDA @@ -7056,7 +7054,6 @@ def _test(m, k, n, transpose_a, transpose_b, test_equal=True): "CUDA error: CUBLAS_STATUS_NOT_SUPPORTED when calling cublasLtMatmul"): _test(17, k, n, use_transpose_a, use_transpose_b) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "cublas runtime error") @onlyCUDA def test__int_mm_errors(self, device): @@ -7191,7 +7188,6 @@ def test_grouped_mm_cpu_unaligned(self, device, dtype): self.assertEqual(out[i], out_ref) start = offs[i] - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "cublas runtime error") @onlyNativeDeviceTypes @parametrize("m", [32, 64]) @@ -7250,7 +7246,6 @@ def weight_int4pack_mm(a, b_int4pack, b_scales_and_zeros): mean_err = ((res - ref).abs() / ref).mean() self.assertTrue(mean_err < 0.05) - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "cublas runtime error") @onlyNativeDeviceTypes @parametrize("m", [32, 64]) @@ -8568,7 +8563,6 @@ def test_slogdet_errors_and_warnings(self, device, dtype): # FIXME One of the backends of lu_factor fails in windows. I haven't investigated which or why # https://github.com/pytorch/pytorch/issues/75225 - @unittest.skipIf(IS_WINDOWS, "Skipped on Windows!") @skipCPUIfNoLapack @dtypes(torch.double) def test_det_logdet_slogdet(self, device, dtype): @@ -11832,8 +11826,8 @@ def _check_grouped_gemm(self, device, strided, a_row_major, b_row_major, a_shape @dtypes(torch.bfloat16, torch.float16) def test_grouped_gemm_rocm_backend(self, device, backend, strided, a_row_major, b_row_major, a_shape, b_shape, offsets, backward, dtype): - if backend == "ck_tile" and not isRocmArchAnyOf(MI300_ARCH + MI350_ARCH): - self.skipTest("ck_tile grouped gemm is only dispatched on gfx942 and gfx950") + if backend == "ck_tile" and not isRocmArchAnyOf(MI350_ARCH): + self.skipTest("ck_tile grouped gemm is only dispatched on gfx950") env_var = {"ck": "ROCM_ALLOW_GROUP_GEMM_CK", "ck_tile": "ROCM_ALLOW_GROUP_GEMM_CK_TILE"}[backend] with mock.patch.dict(os.environ, {env_var: "1"}): self._check_grouped_gemm(device, strided, a_row_major, b_row_major, a_shape, b_shape, offsets, backward, dtype) diff --git a/test/test_matmul_cuda.py b/test/test_matmul_cuda.py index 52c93b1f61d29..5d6543c703bda 100644 --- a/test/test_matmul_cuda.py +++ b/test/test_matmul_cuda.py @@ -40,11 +40,8 @@ _restore_fp32_precision, _snapshot_fp32_precision, IS_JETSON, - MI200_ARCH, - MI300_ARCH, MI350_ARCH, NAVI3_5_ARCH, - NAVI3_ARCH, NAVI_ARCH, getRocmVersion, isRocmArchAnyOf, @@ -611,9 +608,9 @@ def test_cublas_addmm_bias_shapes(self, size: int, dtype: torch.dtype, backend): @onlyCUDA - # Fails with triton 3.7 on RDNA3/RDNA3.5 with the cublaslt backend + # Fails with triton 3.7 on RDNA3.5 with the cublaslt backend @decorateIf( - skipIfRocmArch(NAVI3_ARCH + NAVI3_5_ARCH), + skipIfRocmArch(NAVI3_5_ARCH), lambda params: params["backend"] == "cublaslt", ) @dtypes(torch.float16) @@ -751,10 +748,7 @@ def _convert_to_cpu(t): if N == M and M == P: M2_eye = torch.eye(N, device=device, dtype=dtype) out1_eye_gpu = torch.nn.functional.linear(M1, M2_eye.t(), torch.zeros_like(A)) - if TEST_WITH_ROCM and isRocmArchAnyOf(MI200_ARCH) and dtype == torch.float16: - self.assertEqual(M1_cpu.to(dtype=dtype), out1_eye_gpu.cpu(), atol=1e-4, rtol=0.001) - else: - self.assertEqual(M1_cpu.to(dtype=dtype), out1_eye_gpu.cpu()) + self.assertEqual(M1_cpu.to(dtype=dtype), out1_eye_gpu.cpu()) # baddbmm def _expand_to_batch(t: torch.Tensor): @@ -769,10 +763,7 @@ def _expand_to_batch(t: torch.Tensor): if N == M and M == P: M2_eye = torch.eye(N, device=device, dtype=dtype).expand(batch_size, N, N) out2_eye_gpu = torch.baddbmm(torch.zeros_like(A), M1, M2_eye, beta=beta, alpha=alpha) - if TEST_WITH_ROCM and isRocmArchAnyOf(MI200_ARCH) and dtype == torch.float16: - self.assertEqual(M1_cpu.to(dtype=dtype), out2_eye_gpu.cpu(), atol=1e-4, rtol=0.001) - else: - self.assertEqual(M1_cpu.to(dtype=dtype), out2_eye_gpu.cpu()) + self.assertEqual(M1_cpu.to(dtype=dtype), out2_eye_gpu.cpu()) # cross comparison self.assertEqual(out1_gpu, out2_gpu[0]) @@ -1191,8 +1182,8 @@ def test_grouped_gemm_rocm_ck_flag(self, backend): "ck": ("ROCM_ALLOW_GROUP_GEMM_CK", "kernel_grouped_gemm_xdl_splitk", "kernel_grouped_gemm_xdl_splitk"), "ck_tile": ("ROCM_ALLOW_GROUP_GEMM_CK_TILE", "ck_tile::GroupedGemmKernel", "ck_tile::GroupedGemmKernel"), }[backend] - if backend == "ck_tile" and not isRocmArchAnyOf(MI300_ARCH + MI350_ARCH): - raise unittest.SkipTest("ck_tile grouped gemm is only dispatched on gfx942 and gfx950") + if backend == "ck_tile" and not isRocmArchAnyOf(MI350_ARCH): + raise unittest.SkipTest("ck_tile grouped gemm is only dispatched on gfx950") HIPBLASLT_HINT = "Cijk_Alik_Bljk_BBS_BH_Bias_HA_S_SAV_UserArgs" def has_ck_kernel(kernels: set[str], hint: str) -> bool: @@ -1316,7 +1307,7 @@ def create_inputs(B=None): @parametrize("backend", ["cublas", "cublaslt"]) def test_addmm_baddmm_dtype_overload(self, input_dtype, M, N, K, batch_size, broadcast_self, high_precision_self, backend): if torch.version.hip and ( - _get_torch_rocm_version() < (7, 2, 1) or isRocmArchAnyOf(MI200_ARCH) + _get_torch_rocm_version() < (7, 2, 1) ): msg = "accuracy regression in hipblas and hipblaslt in ROCm 7.0 for certain shapes" if input_dtype == torch.bfloat16 and N == 1 and K == 32 and batch_size: diff --git a/test/test_multiprocessing.py b/test/test_multiprocessing.py index 5dce30ecac489..e1c85e3370173 100644 --- a/test/test_multiprocessing.py +++ b/test/test_multiprocessing.py @@ -26,7 +26,6 @@ instantiate_parametrized_tests, IS_LINUX, IS_MACOS, - IS_WINDOWS, load_tests, parametrize, run_tests, @@ -528,7 +527,6 @@ def test_simple_sharing(self, device): ctx = self._get_ctx(device) self._test_sharing(ctx, device, torch.float) - @skipXPUIf(IS_WINDOWS, "https://github.com/intel/torch-xpu-ops/issues/4068") @dtypes(torch.float32, torch.int64) def test_empty_tensor_sharing(self, device, dtype): self._test_empty_tensor_sharing(dtype, torch.device(device)) @@ -593,7 +591,6 @@ def test_is_shared_accelerator(self, device): self.assertTrue(t.is_shared()) @onlyAccelerator - @unittest.skipIf(IS_WINDOWS, "not applicable to Windows (only fails with fork)") def test_device_bad_call(self, device): # Initialize device t = torch.zeros(5, 5).to(device).cpu() @@ -606,7 +603,6 @@ def test_device_bad_call(self, device): self.assertIsInstance(outq.get(), RuntimeError) @onlyAccelerator - @unittest.skipIf(IS_WINDOWS, "not applicable to Windows (only fails with fork)") def test_wrong_device_fork(self, device): stderr = TestCase.runWithPytorchAPIUsageStderr( f"""\ @@ -759,7 +755,6 @@ def test_autograd_fine_with_spawn(self): with ctx.Pool(3) as pool: pool.map(simple_autograd_function, [1, 2, 3]) - @unittest.skipIf(IS_WINDOWS, "Test needs to use fork multiprocessing") def test_autograd_errors(self): ctx = mp.get_context("fork") simple_autograd_function() diff --git a/test/test_multiprocessing_spawn.py b/test/test_multiprocessing_spawn.py index b77105567cbaa..29761d191a438 100644 --- a/test/test_multiprocessing_spawn.py +++ b/test/test_multiprocessing_spawn.py @@ -11,7 +11,6 @@ import torch.multiprocessing as mp from torch.testing._internal.common_utils import ( - IS_WINDOWS, run_tests, TestCase, parametrize, @@ -134,14 +133,6 @@ def test_terminate_signal(self): # SIGABRT is aliased with SIGIOT message = "process 0 terminated with signal (SIGABRT|SIGIOT)" - # Termination through with signal is expressed as a negative exit code - # in multiprocessing, so we know it was a signal that caused the exit. - # This doesn't appear to exist on Windows, where the exit code is always - # positive, and therefore results in a different exception message. - # Exit code 22 means "ERROR_BAD_COMMAND". - if IS_WINDOWS: - message = "process 0 terminated with exit code 22" - with self.assertRaisesRegex(Exception, message): mp.start_processes(_test_terminate_signal_func, nprocs=2, start_method=self.start_method) @@ -231,18 +222,10 @@ def _test_process_exited(self): self.assertEqual(12, e.exit_code) -@unittest.skipIf( - IS_WINDOWS, - "Fork is only available on Unix", -) class ForkTest(TestCase, _TestMultiProcessing): start_method = 'fork' -@unittest.skipIf( - IS_WINDOWS, - "Fork is only available on Unix", -) class ParallelForkServerShouldWorkTest(TestCase, _TestMultiProcessing): orig_paralell_env_val = None @@ -259,10 +242,6 @@ def tearDown(self): os.environ[mp.ENV_VAR_PARALLEL_START] = self.orig_paralell_env_val -@unittest.skipIf( - IS_WINDOWS, - "Fork is only available on Unix", -) class ParallelForkServerPerfTest(TestCase): @unittest.skipIf( diff --git a/test/test_nn.py b/test/test_nn.py index 66de8a6d9ae02..38a2a875084d7 100644 --- a/test/test_nn.py +++ b/test/test_nn.py @@ -37,8 +37,7 @@ from torch.testing._internal.common_utils import dtype_name, freeze_rng_state, run_tests, TestCase, \ skipIfNoLapack, skipIfRocm, getRocmVersion, TEST_NUMPY, TEST_SCIPY, TEST_WITH_CROSSREF, TEST_WITH_ROCM, TEST_MULTIACCELERATOR, \ download_file, get_function_arglist, load_tests, skipIfMPS, MACOS_VERSION, \ - IS_ARM64, IS_MACOS, IS_WINDOWS, \ - parametrize as parametrize_test, subtest, instantiate_parametrized_tests, \ + IS_MACOS, parametrize as parametrize_test, subtest, instantiate_parametrized_tests, \ skipIfTorchDynamo, gcIfJetson, set_default_dtype, skipIfNoCuteDSL, \ TEST_WITH_TORCHDYNAMO from torch.testing._internal.common_cuda import TEST_CUDA, TEST_CUDNN, \ @@ -5146,7 +5145,6 @@ def test_upsampling_small_scale(self): expected_out_t = torch.tensor([[[[2.5]]]]) self.assertEqual(expected_out_t, out_t) - @unittest.skipIf(IS_WINDOWS and IS_ARM64, "Fails as 'Unexpected success' on Windows ARM64") # see https://github.com/pytorch/pytorch/issues/177250 def test_upsampling_bfloat16(self, dtype=torch.bfloat16): def helper(size, scale_factor, mode, device, memory_format=torch.contiguous_format): @@ -5258,7 +5256,6 @@ def helper(size, dtype, mode, device, is_channels_last): helper(size, dtype, mode, device, is_channels_last) - @unittest.skipIf(IS_WINDOWS, "requires mmap/mprotect") @unittest.skipUnless(TEST_NUMPY, "requires numpy") def test_interpolate_uint8_overread(self): # Regression test for vectorized resize overreads (NEON vld3_u8 and diff --git a/test/test_ops.py b/test/test_ops.py index ec67d5debaaf9..3a8fd842213ec 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -66,7 +66,6 @@ IS_CI, IS_FBCODE, is_iterable_of_tensors, - IS_S390X, IS_SANDCASTLE, noncontiguous_like, parametrize, @@ -832,9 +831,7 @@ def _to_tensormeta(x): @onlyNativeDeviceTypesAnd(["hpu"]) @suppress_warnings @skipOps( - {skip("grid_sampler_2d", device_type="cpu", dtypes=(torch.float32,))} - if IS_S390X - else set() + set() ) @ops(op_db, allowed_dtypes=(torch.float32, torch.long, torch.complex64)) def test_noncontiguous_samples(self, device, dtype, op): diff --git a/test/test_out_dtype_op.py b/test/test_out_dtype_op.py index f06cf729bd6bb..eb98971c6a296 100644 --- a/test/test_out_dtype_op.py +++ b/test/test_out_dtype_op.py @@ -10,7 +10,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, IS_FBCODE, - IS_WINDOWS, IS_REMOTE_GPU, run_tests, TestCase, @@ -194,7 +193,6 @@ def singleton_list_out(x): class TestOutDtypeOpDevice(TestCase): hw_classification = HardwareClassification.ACCELERATOR - @unittest.skipIf(IS_WINDOWS, "_int_mm unavailable") @unittest.skipIf(TEST_CUDA and not SM80OrLater, "_int_mm unavailable") @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "cublas runtime error") @skipIfNoDynamoSupport diff --git a/test/test_public_bindings.py b/test/test_public_bindings.py index 06ff78c4993c3..963cd3cdb0140 100644 --- a/test/test_public_bindings.py +++ b/test/test_public_bindings.py @@ -14,7 +14,6 @@ from torch.testing._internal.common_utils import ( IS_JETSON, IS_MACOS, - IS_WINDOWS, run_tests, skipIfTorchDynamo, TestCase, @@ -244,7 +243,7 @@ def _is_mod_public(modname): return True @unittest.skipIf( - IS_WINDOWS or IS_MACOS, + IS_MACOS, "Inductor/Distributed modules hard fail on windows and macos", ) @skipIfTorchDynamo("Broken and not relevant for now") @@ -373,7 +372,7 @@ def onerror(modname): self.assertEqual("", "\n".join(errors)) # AttributeError: module 'torch.distributed' has no attribute '_shard' - @unittest.skipIf(IS_WINDOWS or IS_JETSON, "Distributed Attribute Error") + @unittest.skipIf(IS_JETSON, "Distributed Attribute Error") @skipIfTorchDynamo("Broken and not relevant for now") def test_correct_module_names(self): """ diff --git a/test/test_reductions.py b/test/test_reductions.py index bb0199b8ca900..f0ca7cebb21a8 100644 --- a/test/test_reductions.py +++ b/test/test_reductions.py @@ -23,8 +23,7 @@ parametrize, serialTest, subtest, gradcheck, gradgradcheck, skipIfMPS, - skipIfTorchDynamo, - IS_WINDOWS) + skipIfTorchDynamo) from torch.testing._internal.common_device_type import ( OpDTypes, onlyCPU, onlyCUDA, onlyNativeDeviceTypes, expectedFailureMeta, expectedFailureXPU, instantiate_device_type_tests, dtypes, dtypesIfCUDA, dtypesIfCPU, dtypesIfXPU, onlyAccelerator, largeMPSBufferTest, largeTensorTest, ops, @@ -643,10 +642,7 @@ def compare_logcumsumexp(a, expected=None): complex(inf, nan), complex(nan, nan), ]) - # windows give strange results on the second-to-last results where it gives inf + pi/4 j - # instead of inf + nan j - if not IS_WINDOWS: - compare_logcumsumexp(a3_input, a3_expected) + compare_logcumsumexp(a3_input, a3_expected) a4_input = torch.tensor([ complex(-inf, inf), @@ -662,8 +658,7 @@ def compare_logcumsumexp(a, expected=None): 1.2 + 2.1j, complex(nan, nan), ]) - if not IS_WINDOWS: - compare_logcumsumexp(a4_input, a4_expected) + compare_logcumsumexp(a4_input, a4_expected) @skipIfMPS def test_sum_parallel(self, device): @@ -1782,12 +1777,6 @@ def is_integral(dtype): return dtype in integral_types() exact_dtype = True - # On Windows CI, the current version of `numpy` promotes all lower integers - # dtypes to int32 while `torch` promotes them to int64. Hence we skip on checking - # the exact dtype. - # PR : https://github.com/pytorch/pytorch/pull/38628#issuecomment-655905370 - if IS_WINDOWS and is_integral(dtype): - exact_dtype = False # For uint8, numpy promotes to uint64 while torch promotes to int64. # So we must skip this as well. if dtype == torch.uint8: diff --git a/test/test_scaled_matmul_cuda.py b/test/test_scaled_matmul_cuda.py index 3103ff75382ee..a42f6bb44c3d8 100644 --- a/test/test_scaled_matmul_cuda.py +++ b/test/test_scaled_matmul_cuda.py @@ -53,7 +53,6 @@ from torch.testing._internal.common_xpu import Xe2_Or_Later from torch.testing._internal.common_utils import ( - IS_WINDOWS, isRocmArchAnyOf, MI350_ARCH, NAVI4_ARCH, @@ -1876,7 +1875,7 @@ def test_float8_scale_fast_accum(self, device) -> None: out_fp8_s = scaled_mm_wrap(x, y, scale_a=scale_a, scale_b=scale_b, out_dtype=e4m3_type, use_fast_accum=True) self.assertEqual(out_fp8, out_fp8_s) - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not SM89OrLater, "rowwise implementation is currently sm89-sm100 specific") @parametrize("use_fast_accum", [True, False]) def test_float8_rowwise_scaling_sanity(self, device, use_fast_accum: bool) -> None: @@ -1904,7 +1903,7 @@ def test_float8_rowwise_scaling_sanity(self, device, use_fast_accum: bool) -> No out_fp8.to(torch.float32), torch.full((M, N), K * (fill_value**2), device=device) ) - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipIfTorchDynamo("error message checks rely on eager exception types") def test_float8_error_messages(self, device) -> None: M, K, N = (1024, 512, 2048) @@ -2012,7 +2011,7 @@ def e5m2(): ): e5m2() - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not SM89OrLater, "rowwise implementation is currently sm89-sm100 specific") @parametrize("base_dtype", [torch.bfloat16, torch.float16, torch.float32]) @parametrize("shapes", [ @@ -2085,7 +2084,7 @@ def test(): # fp32 output is now supported on both the cuBLAS and CUTLASS row-wise paths. test() - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not SM89OrLater, "rowwise implementation is currently sm89-sm100 specific") @parametrize("output_dtype", [torch.bfloat16, torch.float16, torch.float32]) @parametrize("wrap_v2", [True, False]) @@ -2132,7 +2131,7 @@ def test_scaled_mm_row_wise_no_bias_output_dtypes(self, output_dtype, wrap_v2, d self.assertEqual(out, out_emulated, atol=7e-2, rtol=7e-2) @onlyCUDA - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not SM89OrLater, "rowwise implementation is currently sm89-sm100 specific") @parametrize("wrap_v2", [True, False]) def test_scaled_mm_row_wise_fp32_out_with_bias_errors(self, wrap_v2, device): @@ -2165,7 +2164,7 @@ def test_scaled_mm_row_wise_fp32_out_with_bias_errors(self, wrap_v2, device): ) @onlyOn(["cuda", "xpu"]) - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not IS_SM90, "DeepSeek style (1x128, 128x128) blockwise scaling requires SM90 (Hopper)") @parametrize("output_dtype", [torch.bfloat16, torch.float32]) @parametrize("lhs_block,rhs_block", [(1, 1), (128, 1), (1, 128)]) @@ -2415,7 +2414,7 @@ def hp_to_scaled(t, scale, block): @onlyOn(["cuda", "xpu"]) - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @skipCUDAIf(not IS_SM90, "DeepSeek style (1x128, 128x128) blockwise scaling requires SM90 (Hopper)") @parametrize("output_dtype", [torch.bfloat16, torch.float32]) @parametrize("lhs_block,rhs_block", [(1, 1), (128, 1), (1, 128)]) @@ -2497,7 +2496,7 @@ def test_scaled_mm_vs_emulated_block_wise_verify_small_shapes( ) @onlyCUDA - @unittest.skipIf(not PLATFORM_SUPPORTS_FP8 or IS_WINDOWS, f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @unittest.skipIf(IS_SM90, "DeepSeek style (1x128, 128x128) blockwise scaling works on SM90 (Hopper)") @runOnRocmArch(MI350_ARCH) @parametrize("output_dtype", [torch.bfloat16, ]) @@ -2578,7 +2577,6 @@ def test_zero_dim_tensorwise(self, which_dim_zero, use_torch_compile, device) -> self.assertEqual(out_fp32, out_fp8.to(torch.float)) @onlyCUDA - @unittest.skipIf(IS_WINDOWS, "Windows doesn't support row-wise scaling") @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @unittest.skipIf(not SM90OrLater, "sm89 kernel isn't opted into carveout yet") def test_honor_sm_carveout(self, device) -> None: @@ -3011,7 +3009,7 @@ def test_blockwise_mxfp8_nvfp4_mxfp4_numerics(self, test_case_name, fast_accum, raise AssertionError(f"sqnr {sqnr.item()} should be > {approx_match_sqnr_target}") @skipXPU - @unittest.skipIf(not PLATFORM_SUPPORTS_MX_GEMM or IS_WINDOWS, mx_skip_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_MX_GEMM, mx_skip_msg) def test_passed_swizzle_arrays(self, device) -> None: # Ensure that incorrectly-sized swizzle arrays are caught M, N, K = 128, 128, 128 @@ -3132,7 +3130,7 @@ def test_passed_swizzle_arrays(self, device) -> None: ) - @unittest.skipIf(not PLATFORM_SUPPORTS_MX_GEMM or IS_WINDOWS, mx_skip_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_MX_GEMM, mx_skip_msg) @parametrize("recipe", ["mxfp8", "mxfp4", "nvfp4"]) def test_blockwise_mxfp8_nvfp4_mxfp4_error_messages(self, device, recipe) -> None: if "xpu" in device: diff --git a/test/test_schema_check.py b/test/test_schema_check.py index a54309348f0b0..64c8b717dad74 100644 --- a/test/test_schema_check.py +++ b/test/test_schema_check.py @@ -9,7 +9,6 @@ from torch.testing._internal.common_utils import ( HardwareClassification, - IS_WINDOWS, run_tests, slowTestIf, TEST_WITH_TORCHDYNAMO, @@ -510,7 +509,7 @@ class TestSchemaCheckModeOpInfo(TestCase): hw_classification = HardwareClassification.ACCELERATOR @ops(op_db, dtypes=OpDTypes.supported) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_schema_correctness(self, device, dtype, op): # Currently torch.equal isn't supported with torch.complex32 or torch.bcomplex32. # There's also errors with complex64 and complex128 diff --git a/test/test_serialization.py b/test/test_serialization.py index 2e8a73303ab01..4a2d95881fdb6 100644 --- a/test/test_serialization.py +++ b/test/test_serialization.py @@ -59,7 +59,6 @@ IS_CI, IS_FBCODE, IS_FILESYSTEM_UTF8_ENCODING, - IS_WINDOWS, parametrize, run_tests, serialTest, @@ -72,12 +71,7 @@ from torch.testing._internal.two_tensor import TwoTensor from torch.utils._import_utils import import_dill from pickle import UnpicklingError - - -if not IS_WINDOWS: - from mmap import MAP_PRIVATE, MAP_SHARED -else: - MAP_SHARED, MAP_PRIVATE = None, None +from mmap import MAP_PRIVATE, MAP_SHARED # These tests were all copied from `test/test_torch.py` at some point, so see # the actual blame, see this revision @@ -1346,7 +1340,7 @@ def test_weights_only_safe_globals_build_with_slots(self, slots): self.assertEqual(loaded_obj, obj) def test_weights_only_safe_globals_blocklist(self): - module = 'nt' if IS_WINDOWS else 'posix' + module = 'posix' error_msg = f"unsupported GLOBAL {module}.execv whose module {module} is blocked" with BytesIOContext() as f: torch.save(os.execv, f) @@ -4299,7 +4293,6 @@ def test_serialization_load_bom_data_cfloat(self): self.assertTrue(torch.equal(tensor_be_no_bom, tensor_le_bom)) self.assertTrue(torch.equal(tensor_be_no_bom, tensor_be_bom)) - @unittest.skipIf(IS_WINDOWS, "NamedTemporaryFile on windows") @parametrize('path_type', (str, Path)) @parametrize('weights_only', (True, False)) def test_serialization_mmap_loading_options(self, weights_only, path_type): @@ -4327,10 +4320,6 @@ def forward(self, input): self.assertEqual(model_mmap_state_dict(input), model_non_mmap_state_dict(input.clone())) def test_serialization_mmap_loading(self): - if IS_WINDOWS: - with self.assertRaisesRegex(RuntimeError, "Changing the default mmap options is currently not supported"): - torch.serialization.set_default_mmap_options(2) - return m = torch.nn.Linear(3, 5) sd = m.state_dict() with tempfile.NamedTemporaryFile() as f: @@ -4352,7 +4341,6 @@ def test_serialization_mmap_loading(self): finally: torch.serialization.set_default_mmap_options(MAP_PRIVATE) - @unittest.skipIf(IS_WINDOWS, "mmap ctx doesn't work on Windows") def test_serialization_mmap_loading_ctx(self): sd = torch.nn.Linear(3, 5).state_dict() with tempfile.NamedTemporaryFile() as f: @@ -4646,7 +4634,6 @@ def test_has_format_version(self): self.assertTrue(opened_zipfile.has_record(".format_version")) self.assertEqual(opened_zipfile.get_record(".format_version"), b'1') - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") def test_corrupted_checkpoint_error_message(self): """Test that corrupted checkpoint files produce helpful error messages.""" sd = torch.nn.Linear(2, 3).state_dict() @@ -4743,7 +4730,6 @@ def test_load_record_referenced_with_conflicting_sizes(self): self.assertEqual(untyped_loaded.nbytes(), 6) @parametrize('path_type', (str, Path)) - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") def test_mmap_load_offset_calculation(self, path_type): calculate_offsets_before = serialization_config.load.calculate_storage_offsets try: @@ -5611,7 +5597,6 @@ def _require_gds(self): def test_gds_config_defaults_to_off(self): self.assertFalse(serialization_config.load.use_gds) - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") @parametrize("path_type", (str, Path)) def test_gds_falls_back_for_cpu_map_location(self, path_type): # map_location is not CUDA, so the load must silently take the usual path. @@ -5640,7 +5625,6 @@ def test_gds_falls_back_for_file_object(self): for v in loaded.values(): self.assertEqual(v.device.type, map_location) - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") @parametrize("path_type", (str, Path)) def test_gds_load_round_trip(self, path_type): self._require_gds() @@ -5657,7 +5641,6 @@ def test_gds_load_round_trip(self, path_type): self.assertEqual(v, reference[k]) self.assertTrue(torch.equal(v, sd[k].cuda())) - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") @parametrize("dtype", (torch.float32, torch.float64, torch.uint8, torch.int64)) def test_gds_load_dtypes(self, dtype): self._require_gds() @@ -5675,7 +5658,6 @@ def test_gds_load_dtypes(self, dtype): self.assertTrue(torch.equal(loaded["t"], t.cuda())) self.assertEqual(loaded["empty"].numel(), 0) - @unittest.skipIf(IS_WINDOWS, "TemporaryFileName on windows") def test_gds_load_indexed_device(self): self._require_gds() sd = torch.nn.Linear(64, 64).state_dict() diff --git a/test/test_show_pickle.py b/test/test_show_pickle.py index b10edcc064e58..8a27494ca2db4 100644 --- a/test/test_show_pickle.py +++ b/test/test_show_pickle.py @@ -2,11 +2,10 @@ import io import tempfile -import unittest import torch import torch.utils.show_pickle -from torch.testing._internal.common_utils import IS_WINDOWS, run_tests, TestCase +from torch.testing._internal.common_utils import run_tests, TestCase # Must be importable by name for torch.save to pickle it. @@ -20,7 +19,6 @@ def forward(self, x): class TestShowPickle(TestCase): - @unittest.skipIf(IS_WINDOWS, "Can't re-open temp file on Windows") def test_saved_model(self): m = MyCoolModule(torch.tensor([2.0])) diff --git a/test/test_sparse.py b/test/test_sparse.py index aa4bf2f98e718..61f9d08128ae2 100644 --- a/test/test_sparse.py +++ b/test/test_sparse.py @@ -10,7 +10,7 @@ import warnings from torch.testing import make_tensor from torch.testing._internal.common_utils import HardwareClassification, TestCase, run_tests, do_test_dtypes, \ - load_tests, TEST_NUMPY, TEST_SCIPY, IS_WINDOWS, gradcheck, coalescedonoff, \ + load_tests, TEST_NUMPY, TEST_SCIPY, gradcheck, coalescedonoff, \ DeterministicGuard, first_sample, TEST_WITH_CROSSREF, TEST_WITH_ROCM, skipIfTorchDynamo, skipIfMPS, \ parametrize, subtest, is_coalesced_indices, suppress_warnings, instantiate_parametrized_tests, \ skipIfCrossRef, set_warn_always_context @@ -130,9 +130,7 @@ def wrapped(fn, inputs, *args, **kwargs): gradcheck = functools.partial(gradcheck, check_batched_grad=False) gradcheck = _make_lowp_aware_gradcheck(gradcheck) -CUSPARSE_SPMM_COMPLEX128_SUPPORTED = ( - IS_WINDOWS and torch.version.cuda -) or (not IS_WINDOWS and not TEST_WITH_ROCM) +CUSPARSE_SPMM_COMPLEX128_SUPPORTED = not TEST_WITH_ROCM HIPSPARSE_SPMM_COMPLEX128_SUPPORTED = bool(torch.version.hip) @@ -2014,7 +2012,7 @@ def fn(S, D): test_shape(7, 8, 9, 20, False) test_shape(7, 8, 9, 20, True) - @unittest.skipIf(IS_LINUX or IS_MACOS or TEST_WITH_ROCM or IS_WINDOWS, "https://github.com/pytorch/pytorch/issues/174389") + @unittest.skipIf(IS_LINUX or IS_MACOS or TEST_WITH_ROCM, "https://github.com/pytorch/pytorch/issues/174389") @coalescedonoff @dtypes(torch.double) @dtypesIfMPS(torch.float32) @@ -5453,7 +5451,7 @@ def test_unsupported_backend_error_message(self, mth, layout, device): mth(inp) @onlyNativeDeviceTypes - @all_sparse_layouts('layout', include_strided=not True) + @all_sparse_layouts('layout', include_strided=False) @dtypes(torch.float64, torch.cdouble) @parametrize("masked", [subtest(False, name='sparse'), subtest(True, name='masked')]) @parametrize("fast_mode", [subtest(False, name='slow'), subtest(True, name='fast')]) diff --git a/test/test_sparse_csr.py b/test/test_sparse_csr.py index 5e2c4a1f27473..df66f8f98240d 100644 --- a/test/test_sparse_csr.py +++ b/test/test_sparse_csr.py @@ -52,7 +52,6 @@ IS_FBCODE, IS_LINUX, IS_REMOTE_GPU, - IS_WINDOWS, instantiate_parametrized_tests, load_tests, parametrize, @@ -87,7 +86,7 @@ # sharding on sandcastle. This line silences flake warnings load_tests = load_tests # noqa: PLW0127 -no_mkl_sparse = IS_WINDOWS or not TEST_MKL +no_mkl_sparse = not TEST_MKL def _check_cusparse_spgemm_available(): diff --git a/test/test_sparse_semi_structured.py b/test/test_sparse_semi_structured.py index b2d7f8a066acd..6f4a523c37429 100644 --- a/test/test_sparse_semi_structured.py +++ b/test/test_sparse_semi_structured.py @@ -36,7 +36,6 @@ _restore_fp32_precision, _snapshot_fp32_precision, HardwareClassification, - IS_WINDOWS, parametrize, run_tests, subtest, @@ -240,7 +239,6 @@ def forward(self, x): f"stride mismatch: {sparse_result.stride()} != {sparse_compile_result.stride()}" ) - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") @unittest.skipIf( "cusparselt" not in SEMI_STRUCTURED_SUPPORTED_BACKENDS, "cusparselt not supported on this machine", @@ -262,7 +260,6 @@ def test_mlp_contiguous_relu_compile_cusparselt(self): "cutlass" not in SEMI_STRUCTURED_SUPPORTED_BACKENDS, "cutlass not supported on this machine", ) - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") @unittest.skipIf(TEST_WITH_ROCM, "Not supported on ROCm") def test_mlp_contiguous_relu_compile_cutlass(self): """ @@ -273,7 +270,6 @@ def test_mlp_contiguous_relu_compile_cutlass(self): "cutlass", dense_input_shape ) - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") @unittest.skipIf( "cusparselt" not in SEMI_STRUCTURED_SUPPORTED_BACKENDS, "cusparselt not supported on this machine", @@ -301,7 +297,6 @@ def fn(x): output.backward(output) @unittest.skipIf(not torch.cuda.is_available(), "requires CUDA") - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") def test_cutlass_mm_functionalization_decomp(self): """Test that semi_structured::cutlass_mm decomposes under FunctionalTensorMode. @@ -344,8 +339,6 @@ def setUp(self): super().setUp() if len(SEMI_STRUCTURED_SUPPORTED_BACKENDS) == 0: self.skipTest("semi-structured sparsity has no available backend!") - if IS_WINDOWS: - self.skipTest("torch.compile not supported on windows") @inference_dtypes @parametrize_backends @@ -471,8 +464,6 @@ def test_mm_sparse_first_TN(self, dtype, dense_input_shape, device, backend): Ensure torch.mm(A_sparse.t(), B) throws error """ SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = rand_sparse_semi_structured_mask(128, 256, dtype=dtype) A_sparse = to_sparse_semi_structured(A) @@ -492,8 +483,6 @@ def test_mm_sparse_second_NT(self, dense_input_shape, dtype, device, backend): Ensure torch.mm(A, B_sparse.t()) is correct """ SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") B = rand_sparse_semi_structured_mask(256, 128, dtype=dtype) B_sparse = to_sparse_semi_structured(B) @@ -517,8 +506,6 @@ def test_mm_sparse_second_NN(self, dense_input_shape, dtype, device, backend): Ensure torch.mm(A, B_sparse) throws error """ SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") B = rand_sparse_semi_structured_mask(256, 128, dtype=dtype) B_sparse = to_sparse_semi_structured(B) @@ -538,8 +525,6 @@ def test_linear(self, dense_input_shape, inference_mode, device, backend): Test nn.Linear has the same numerics """ SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") input = torch.rand((dense_input_shape), device=device).half() model = nn.Linear(128, 256).to(device).half() m, n = model.weight.shape @@ -593,8 +578,6 @@ def test_mlp(self, device, dense_input_shape, backend): @parametrize_backends def test_values(self, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = rand_sparse_semi_structured_mask(128, 128) A_sparse = to_sparse_semi_structured(A) if A_sparse.values().shape != (128, 64): @@ -607,8 +590,6 @@ def test_values(self, backend): @parametrize_backends def test_indices(self, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = rand_sparse_semi_structured_mask(128, 128) A_sparse = to_sparse_semi_structured(A) if A_sparse.indices().shape != (128, 8): @@ -644,8 +625,6 @@ def test_min_sparse_shape(self, dtype, device, backend): @parametrize_backends def test_unsupported_shape(self, dtype, device, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = rand_sparse_semi_structured_mask(2, 2, dtype=dtype, device=device) with self.assertRaisesRegex(RuntimeError, "Error original_tensor.shape"): A_sparse = to_sparse_semi_structured(A) @@ -654,8 +633,6 @@ def test_unsupported_shape(self, dtype, device, backend): @parametrize_backends def test_unsupported_dtype(self, dtype, device, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = rand_sparse_semi_structured_mask(128, 128, dtype=dtype, device=device) if ( @@ -670,8 +647,6 @@ def test_unsupported_dtype(self, dtype, device, backend): @parametrize_backends def test_unsupported_dim(self, device, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") A = torch.rand(128, 128, 128, device=device, dtype=torch.float16) with self.assertRaisesRegex(RuntimeError, "Error original_tensor.dim"): @@ -688,9 +663,6 @@ def setUp(self): "SparseSemiStructuredTensor training only supported on SM8x (Ampere)" ) - if IS_WINDOWS: - self.skipTest("CUTLASS not supported on windows") - @training_dtypes @unittest.skipIf(TEST_WITH_ROCM, "Not supported on ROCm") @unittest.skipIf( @@ -1095,7 +1067,7 @@ def tearDown(self): super().tearDown() @unittest.skipIf( - TEST_WITH_ROCM or IS_WINDOWS, "ROCm and Windows doesn't support CUTLASS" + TEST_WITH_ROCM, "ROCm and Windows doesn't support CUTLASS" ) @inference_dtypes def test_linear_cutlass(self, device, dtype): @@ -1197,14 +1169,12 @@ def run_test( _restore_fp32_precision(orig) @unittest.skipIf( - TEST_WITH_ROCM or IS_WINDOWS, "ROCm and Windows doesn't support CUTLASS" + TEST_WITH_ROCM, "ROCm and Windows doesn't support CUTLASS" ) @parametrize("backend", ["cutlass"]) @inference_dtypes def test_sparse_semi_structured_ops_cutlass(self, device, dtype, backend): SparseSemiStructuredTensor._FORCE_CUTLASS = backend == "cutlass" - if backend == "cutlass" and IS_WINDOWS: - self.skipTest("CUTLASS not supported on Windows") def run_test(m, n, k, device, dtype, dtype_out, use_input, rtol, atol): mat1 = rand_sparse_semi_structured(m, k, dtype, device) @@ -1823,7 +1793,6 @@ def test_cslt_sparse_mm_fp8_default_out_dtype_rocm(self, device): dense_result = torch.mm(A_fp8.to(torch.float32), B_fp8.to(torch.float32)) torch.testing.assert_close(sparse_result, dense_result, rtol=1e-1, atol=1e-1) - @unittest.skipIf(IS_WINDOWS, "torch.compile not supported on windows") @unittest.skipIf( not PLATFORM_SUPPORTS_FP8_SPARSE, "FP8 sparse requires cuSPARSELt v0.6.2+ on SM 8.9+ or MI300+ on ROCm 7.12+", diff --git a/test/test_stateless_rng.py b/test/test_stateless_rng.py index 983eb1a3186e8..b6e0fa3cd1ef1 100644 --- a/test/test_stateless_rng.py +++ b/test/test_stateless_rng.py @@ -10,7 +10,6 @@ ) from torch.testing._internal.common_dtype import floating_types_and from torch.testing._internal.common_utils import ( - IS_S390X, parametrize, run_tests, subtest, @@ -1162,12 +1161,9 @@ def test_full_range_uint64_packs_two_uint32(self, device): n = 128 b32 = random.randint(key, (2 * n,), dtype=torch.uint32) b64 = random.randint(key, (n,), dtype=torch.uint64) - if not IS_S390X: - self.assertEqual( - b64.view(torch.uint32), b32.reshape(-1, 2).flip(-1).reshape(-1) - ) - else: - self.assertEqual(b64.view(torch.uint32), b32) + self.assertEqual( + b64.view(torch.uint32), b32.reshape(-1, 2).flip(-1).reshape(-1) + ) @parametrize("dtype", [torch.uint8, torch.uint16, torch.uint32, torch.uint64]) def test_full_range_statistically_uniform(self, device, dtype): diff --git a/test/test_tensor_creation_ops.py b/test/test_tensor_creation_ops.py index 86dc9d24fcfcb..8ed8a9ec91f3f 100644 --- a/test/test_tensor_creation_ops.py +++ b/test/test_tensor_creation_ops.py @@ -28,7 +28,6 @@ set_default_dtype, set_default_tensor_type, TEST_SCIPY, - IS_WINDOWS, IS_FBCODE, IS_SANDCASTLE, IS_ARM64, @@ -3230,7 +3229,6 @@ def test_arange_inference(self): torch.tensor(1, dtype=torch.int16)).dtype) @parametrize('shared', [True, False]) - @unittest.skipIf(IS_WINDOWS, "NamedTemporaryFile on windows") def test_from_file(self, shared): dtype = torch.float64 t = torch.randn(2, 5, dtype=dtype) diff --git a/test/test_testing.py b/test/test_testing.py index 43e580f095ec7..00f65c52c3721 100644 --- a/test/test_testing.py +++ b/test/test_testing.py @@ -26,7 +26,7 @@ from torch.testing import make_tensor from torch.testing._internal.common_utils import ( - IS_CI, IS_FBCODE, IS_JETSON, IS_MACOS, IS_SANDCASTLE, IS_WINDOWS, TestCase, run_tests, slowTest, + IS_CI, IS_FBCODE, IS_JETSON, IS_MACOS, IS_SANDCASTLE, TestCase, run_tests, slowTest, parametrize, reparametrize, subtest, instantiate_parametrized_tests, dtype_name, TEST_CUDA, TEST_WITH_CROSSREF, TEST_WITH_PERIODIC, TEST_WITH_ROCM, decorateIf, periodic, skipIfTorchDynamo, skipIfXpu, getRocmVersion, TemporaryFileName, sanitize_pytest_xml, @@ -594,7 +594,6 @@ def test_fn(): common_cuda.xfailCUDAIfSM89OrLaterOnWindows(test_fn), test_fn ) - @unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") def test_filtering_env_var(self): # Test environment variable selected device type test generator. @@ -704,7 +703,6 @@ def _count_junit_tags(normalized: str) -> collections.Counter[str]: # The fixture runs as the default config, so its XML doesn't depend on the test # config or device; skip the configs and GPU builds that would only repeat it. -@unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") @skipIfTorchDynamo("subprocess test does not need Dynamo coverage") @unittest.skipIf(TEST_WITH_CROSSREF, "subprocess test does not need crossref coverage") @@ -2989,7 +2987,7 @@ def test_circular_dependencies(self) -> None: "torch._inductor.kernel.flex_gemm.quack_ops", # depends on cutlass "torch.profiler._cuspy", # depends on cupti-python ] - if IS_WINDOWS or IS_MACOS or IS_JETSON: + if IS_MACOS or IS_JETSON: # Distributed should be importable on Windows, but not on Mac if IS_MACOS or IS_JETSON: ignored_modules.append("torch.distributed.") diff --git a/test/test_torch.py b/test/test_torch.py index a718ebbf138e0..386d74482e9ed 100644 --- a/test/test_torch.py +++ b/test/test_torch.py @@ -67,7 +67,6 @@ all_types_complex_float8_and, all_passthru_types_and, ) from torch.testing._internal.two_tensor import TwoTensor -from torch.testing._internal.common_utils import IS_WINDOWS if TEST_WITH_TORCHINDUCTOR: from torch._inductor.test_case import TestCase @@ -160,7 +159,7 @@ def _rand_shape(self, dim, min_size, max_size): return tuple(shape) @onlyNativeDeviceTypes - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) @dtypes(torch.int8, torch.uint8, torch.int16, torch.int32, torch.int64, torch.bool, torch.float32, torch.complex64, torch.float64, torch.complex128, torch.uint16, torch.uint32, torch.uint64) @@ -254,7 +253,7 @@ def test_int64_upsample3d(self, device, dtype): @dtypes(torch.int8, torch.uint8, torch.int16, torch.int32, torch.int64, torch.bool, torch.float32, torch.complex64, torch.float64, torch.complex128, torch.uint16, torch.uint32, torch.uint64) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage(self, device, dtype): v = make_tensor((3, 5), dtype=dtype, device=device, low=-9, high=9) self.assertEqual(v.storage()[0], v[0][0]) @@ -284,7 +283,7 @@ def test_storage(self, device, dtype): @dtypes(torch.int8, torch.uint8, torch.int16, torch.int32, torch.int64, torch.bool, torch.float32, torch.complex64, torch.float64, torch.complex128) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_setitem(self, device, dtype): storage_type_name = torch.storage._dtype_to_storage_type_map()[dtype] if torch.device(device).type == 'cuda': @@ -311,7 +310,7 @@ def test_storage_setitem(self, device, dtype): @skipIfTorchDynamo("Not a suitable test for TorchDynamo") @onlyNativeDeviceTypes - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_use_count(self, device): a = torch.randn(10, device=device) prev_cf = torch._C._storage_Use_Count(a.untyped_storage()._cdata) @@ -355,7 +354,7 @@ def raises_on_data_ptr(storage): @onlyNativeDeviceTypes @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_tensor_storage_type(self, device, dtype): a = make_tensor((10,), dtype=dtype, device=device, low=-9, high=9) @@ -366,7 +365,7 @@ def test_tensor_storage_type(self, device, dtype): @onlyNativeDeviceTypes @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16, torch.uint16, torch.uint32, torch.uint64)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_tensor_from_storage(self, device, dtype): a = make_tensor((4, 5, 3), dtype=dtype, device=device, low=-9, high=9) a_s = a.storage() @@ -384,7 +383,7 @@ def test_tensor_from_storage(self, device, dtype): @onlyNativeDeviceTypes @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_set_storage(self, device, dtype): a = make_tensor((4, 5, 3), dtype=dtype, device=device, low=-9, high=9) a_s = a.storage() @@ -425,7 +424,7 @@ def _check_storage_meta(self, s, s_check): @onlyNativeDeviceTypes @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_typed_storage_meta(self, device, dtype): args_list = [ [], @@ -439,7 +438,7 @@ def test_typed_storage_meta(self, device, dtype): self._check_storage_meta(s, s_check) @onlyNativeDeviceTypes - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_untyped_storage_meta(self, device): args_list = [ [], @@ -454,7 +453,7 @@ def test_untyped_storage_meta(self, device): @onlyNativeDeviceTypes @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_from_tensor(self, device, dtype): t_check = make_tensor((4, 5, 3), dtype=dtype, device=device, low=-9, high=9) t = t_check.to('meta') @@ -464,7 +463,7 @@ def test_storage_meta_from_tensor(self, device, dtype): self._check_storage_meta(s, s_check) @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_errors(self, device, dtype): s0 = torch.TypedStorage([1, 2, 3, 4], device='meta', dtype=dtype) @@ -504,7 +503,7 @@ def test_storage_meta_errors(self, device, dtype): @onlyCPU @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_ok(self, device, dtype): s0 = torch.TypedStorage([1, 2, 3, 4], device='meta', dtype=dtype) @@ -520,7 +519,7 @@ def test_module_share_memory(self, device): model.share_memory() @dtypes(torch.float32, torch.complex64) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_deepcopy(self, device, dtype): from copy import deepcopy a = torch.randn(5, 5, dtype=dtype, device=device) @@ -548,7 +547,7 @@ def test_deepcopy(self, device, dtype): self.assertEqual(deepcopy(a).foo, 3) @dtypes(torch.float32, torch.complex64) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_deepcopy_scalar(self, device, dtype): from copy import deepcopy a = torch.tensor(5, dtype=dtype, device=device) @@ -3736,7 +3735,7 @@ def test_narrow_copy_non_contiguous(self, device): # FIXME: find a test suite for the take operator @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_take(self, device, dtype): idx_size = (4,) @@ -7055,7 +7054,7 @@ def test_set_default_tensor_type_warnings(self, device): torch.set_default_tensor_type(default_type) @dtypes(*all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_errors(self, device, dtype): s0 = torch.TypedStorage([1, 2, 3, 4], device='meta', dtype=dtype) @@ -11255,7 +11254,7 @@ def test_tensor_item_no_warning(self): self.assertEqual(len(w), 0) @parametrize("dtype", all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_ok(self, dtype): s0 = torch.TypedStorage([1, 2, 3, 4], device='meta', dtype=dtype) @@ -11263,7 +11262,7 @@ def test_storage_meta_ok(self, dtype): s0.resize_(10) @parametrize("dtype", all_types_and_complex_and(torch.half, torch.bool, torch.bfloat16)) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_storage_meta_errors(self, dtype): s0 = torch.TypedStorage([1, 2, 3, 4], device='meta', dtype=dtype) diff --git a/test/test_unary_ufuncs.py b/test/test_unary_ufuncs.py index 672851c058beb..a920e4634e117 100644 --- a/test/test_unary_ufuncs.py +++ b/test/test_unary_ufuncs.py @@ -54,7 +54,7 @@ ) from torch.utils import _pytree as pytree -from torch.testing._internal.common_utils import IS_WINDOWS, slowTestIf +from torch.testing._internal.common_utils import slowTestIf if TEST_SCIPY: import scipy @@ -277,7 +277,7 @@ def _helper_reference_numerics( # and noncontiguities. @suppress_warnings @ops(reference_filtered_ops) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_reference_numerics_normal(self, device, dtype, op): tensors = generate_elementwise_unary_tensors( op, device=device, dtype=dtype, requires_grad=False @@ -286,7 +286,7 @@ def test_reference_numerics_normal(self, device, dtype, op): @suppress_warnings @ops(reference_filtered_ops) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_reference_numerics_small(self, device, dtype, op): if dtype == torch.bool: raise self.skipTest("bool has no small values") @@ -298,7 +298,7 @@ def test_reference_numerics_small(self, device, dtype, op): @suppress_warnings @ops(reference_filtered_ops) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_reference_numerics_large(self, device, dtype, op): if dtype in (torch.bool, torch.uint8, torch.int8): raise self.skipTest("bool, uint8, and int8 dtypes have no large values") @@ -313,7 +313,7 @@ def test_reference_numerics_large(self, device, dtype, op): reference_filtered_ops, allowed_dtypes=floating_and_complex_types_and(torch.bfloat16, torch.half), ) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_reference_numerics_extremal(self, device, dtype, op): tensors = generate_elementwise_unary_extremal_value_tensors( op, device=device, dtype=dtype, requires_grad=False @@ -322,7 +322,7 @@ def test_reference_numerics_extremal(self, device, dtype, op): # Tests for testing (non)contiguity consistency @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_contig_vs_every_other(self, device, dtype, op): contig = make_tensor( (1026,), device=device, dtype=dtype, low=op.domain[0], high=op.domain[1] @@ -339,7 +339,7 @@ def test_contig_vs_every_other(self, device, dtype, op): self.assertEqual(result, expected) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_contig_vs_transposed(self, device, dtype, op): contig = make_tensor( (789, 357), device=device, dtype=dtype, low=op.domain[0], high=op.domain[1] @@ -356,7 +356,7 @@ def test_contig_vs_transposed(self, device, dtype, op): self.assertEqual(result, expected) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_non_contig(self, device, dtype, op): shapes = [(5, 7), (1024,)] for shape in shapes: @@ -373,7 +373,7 @@ def test_non_contig(self, device, dtype, op): self.assertEqual(op(contig, **torch_kwargs), op(non_contig, **torch_kwargs)) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_non_contig_index(self, device, dtype, op): contig = make_tensor( (2, 2, 1, 2), @@ -392,7 +392,7 @@ def test_non_contig_index(self, device, dtype, op): self.assertEqual(op(contig, **torch_kwargs), op(non_contig, **torch_kwargs)) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_non_contig_expand(self, device, dtype, op): shapes = [(1, 3), (1, 7), (5, 7)] for shape in shapes: @@ -414,7 +414,7 @@ def test_non_contig_expand(self, device, dtype, op): ) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_contig_size1(self, device, dtype, op): contig = make_tensor( (5, 100), dtype=dtype, device=device, low=op.domain[0], high=op.domain[1] @@ -430,7 +430,7 @@ def test_contig_size1(self, device, dtype, op): self.assertEqual(op(contig, **torch_kwargs), op(contig2, **torch_kwargs)) @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_contig_size1_large_dim(self, device, dtype, op): contig = make_tensor( (5, 2, 3, 1, 4, 5, 3, 2, 1, 2, 3, 4), @@ -452,7 +452,7 @@ def test_contig_size1_large_dim(self, device, dtype, op): # Tests that computation on a multiple batches is the same as # per-batch computation. @ops(unary_ufuncs) - @slowTestIf(IS_WINDOWS) + @slowTestIf(False) def test_batch_vs_slicing(self, device, dtype, op): input = make_tensor( (1024, 512), dtype=dtype, device=device, low=op.domain[0], high=op.domain[1] diff --git a/test/test_utils.py b/test/test_utils.py index b9286903fc7a6..fbcad6e957082 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -34,7 +34,6 @@ from torch.testing._internal.common_utils import ( # type: ignore[attr-defined] IS_FBCODE, IS_SANDCASTLE, - IS_WINDOWS, load_tests, skipIfTorchDynamo, TEST_WITH_ASAN, @@ -683,7 +682,6 @@ class TestHipify(TestCase): def test_import_hipify(self): from torch.utils.hipify import hipify_python # noqa: F401 - @unittest.skipIf(IS_WINDOWS, "Creating symlinks may require privileges on Windows") def test_canonicalize_hip_source(self): # `_canonicalize_hip_source` must leave a source that already lives under # the build dir untouched (return its abspath), so a source symlinked @@ -920,7 +918,7 @@ def test_load_standalone(self): is_standalone=True, ) - ext = ".exe" if IS_WINDOWS else "" + ext = "" self.assertEqual( exec_path, os.path.join(build_dir, f"standalone_load_test{ext}") ) @@ -1100,12 +1098,11 @@ def test_installed_torch_dir_prefers_the_editable_loader_paths(self): loader = types.SimpleNamespace(paths=[checkout, installed]) with mock.patch.object(torch, "__loader__", loader): self.assertEqual(installed_torch_dir(checkout), installed) - if not IS_WINDOWS: - os.symlink(os.path.join(root, "src"), os.path.join(root, "alias")) - aliased = os.path.join(root, "alias", "torch") - loader = types.SimpleNamespace(paths=[aliased, installed]) - with mock.patch.object(torch, "__loader__", loader): - self.assertEqual(installed_torch_dir(checkout), installed) + os.symlink(os.path.join(root, "src"), os.path.join(root, "alias")) + aliased = os.path.join(root, "alias", "torch") + loader = types.SimpleNamespace(paths=[aliased, installed]) + with mock.patch.object(torch, "__loader__", loader): + self.assertEqual(installed_torch_dir(checkout), installed) # Only an entry holding lib/ is an install tree; otherwise the # extension module's spec decides, as it does without any paths. loader = types.SimpleNamespace(paths=[checkout, os.path.join(root, "x")]) @@ -1137,7 +1134,6 @@ def test_stale_checkout_artifacts(self): os.makedirs(os.path.join(clean, "lib", "libshm")) self.assertEqual(torch._utils_internal._stale_checkout_artifacts(clean), []) - @unittest.skipIf(IS_WINDOWS, "_load_global_deps is a no-op on Windows") def test_load_global_deps_reports_missing_library(self): real_exists = os.path.exists @@ -1541,7 +1537,6 @@ def nvmlShutdown(): class TestDeviceLazyInit(TestCase): - @unittest.skipIf(IS_WINDOWS, "pthread_atfork not available on Windows") def test_fork_poison_on_lazy_init(self, device): torch.empty(1, device=device) diff --git a/test/test_xpu.py b/test/test_xpu.py index 86b047bd40fd9..fdff3b2009aa9 100644 --- a/test/test_xpu.py +++ b/test/test_xpu.py @@ -42,7 +42,6 @@ find_library_location, instantiate_parametrized_tests, IS_LINUX, - IS_WINDOWS, IS_X86, parametrize, run_tests, @@ -200,7 +199,6 @@ def test_get_device_capability(self): if torch.xpu.is_bf16_supported(including_emulation=True): self.assertIn(torch.bfloat16, supported_dtypes) - @unittest.skipIf(IS_WINDOWS, "not applicable to Windows (only fails with fork)") def test_wrong_xpu_fork(self): stderr = TestCase.runWithPytorchAPIUsageStderr( """\ @@ -223,9 +221,6 @@ def run(rank): ) self.assertRegex(stderr, "Cannot re-initialize XPU in forked subprocess.") - @unittest.skipIf( - IS_WINDOWS, "Only for lazy initialization on Linux, not applicable on Windows." - ) def test_lazy_init(self): """Validate that no XPU calls are made during `import torch` call""" @@ -523,9 +518,6 @@ def fake_import(name, *args, **kwargs): with self.assertRaisesRegex(RuntimeError, "Failed to import pyzes"): api() - @unittest.skipIf( - IS_WINDOWS, "Only for lazy initialization on Linux, not applicable on Windows." - ) def test_no_xpu_device_query_on_inductor_import(self): """Validate that importing torch._inductor.lowering does not trigger XPU device queries""" @@ -736,20 +728,6 @@ def test_event_ipc_handle(self): e1.ipc_handle() return - if IS_WINDOWS: - with self.assertRaisesRegex( - RuntimeError, "XPU IPC events are not supported on Windows" - ): - e2 = torch.xpu.Event(enable_timing=False, interprocess=True) - e2.record() - - with self.assertRaisesRegex( - RuntimeError, "XPU IPC events are not supported on Windows" - ): - e3 = torch.xpu.Event(enable_timing=False, interprocess=True) - e3.ipc_handle() - return - # IPC and timing cannot both be enabled; error fires at record() time. with self.assertRaisesRegex( RuntimeError, "XPUEvent cannot have both IPC and timing enabled" @@ -3149,7 +3127,6 @@ def check(live_data_ptrs): @instantiate_parametrized_tests @unittest.skipIf(not Xe2_Or_Later, "XPU IPC not available") -@unittest.skipIf(IS_WINDOWS, "XPU IPC not available on non-Linux platforms") @unittest.skipIf( TEST_WITH_TSAN, "TSAN is not fork-safe since we're forking in a multi-threaded environment", diff --git a/test/test_xpu_expandable_segments.py b/test/test_xpu_expandable_segments.py index d0cde9306ad39..91c6688cfab95 100644 --- a/test/test_xpu_expandable_segments.py +++ b/test/test_xpu_expandable_segments.py @@ -5,7 +5,7 @@ from test_xpu import TestXpu, TestXpuOpsXPU # noqa: F401 import torch -from torch.testing._internal.common_utils import IS_WINDOWS, run_tests +from torch.testing._internal.common_utils import run_tests REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent @@ -17,7 +17,7 @@ sys.path.remove(str(REPO_ROOT)) if __name__ == "__main__": - if torch.xpu.is_available() and not IS_WINDOWS: + if torch.xpu.is_available(): get_disabled_tests(".") torch._C._accelerator_setAllocatorSettings("expandable_segments:True") diff --git a/test/torch_np/test_nep50_examples.py b/test/torch_np/test_nep50_examples.py index b819013afb6be..13ccbb621cbe3 100644 --- a/test/torch_np/test_nep50_examples.py +++ b/test/torch_np/test_nep50_examples.py @@ -32,7 +32,6 @@ from torch._numpy.testing import assert_allclose from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, - IS_WINDOWS, parametrize, run_tests, TestCase, @@ -234,24 +233,8 @@ def test_compare_ufuncs(self, name, scalar, array): if result is not None and result_numpy is not None: expected_numpy_dtype = result_numpy.dtype expected_torch_dtype = result.tensor.numpy().dtype - if IS_WINDOWS: - if ( - array.tensor.numpy().dtype != _np.bool_ - and result.tensor.numpy().dtype != result_numpy.dtype - ): - type_mismatch = True - - if ( - array.tensor.numpy().dtype == _np.bool_ - and result_numpy.dtype == _np.int32 - and result.tensor.numpy().dtype != _np.int64 - ): - expected_numpy_dtype = _np.int32 - expected_torch_dtype = tnp.int64 - type_mismatch = True - else: - if result.tensor.numpy().dtype != result_numpy.dtype: - type_mismatch = True + if result.tensor.numpy().dtype != result_numpy.dtype: + type_mismatch = True if type_mismatch: raise AssertionError( diff --git a/test/torchci/test_testing.py b/test/torchci/test_testing.py index 532e44fe81c15..9fbd84bb21a94 100644 --- a/test/torchci/test_testing.py +++ b/test/torchci/test_testing.py @@ -24,7 +24,6 @@ from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, IS_SANDCASTLE, - IS_WINDOWS, parametrize, run_tests, skipIfTorchDynamo, @@ -160,7 +159,6 @@ def _table(header: tuple[str, ...], rows: list[tuple[Any, ...]]) -> str: # torchci test run reports, on TestJunitXml's fixture suite. -@unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") @skipIfTorchDynamo("subprocess test does not need Dynamo coverage") @unittest.skipIf(TEST_WITH_CROSSREF, "subprocess test does not need crossref coverage") @@ -376,7 +374,6 @@ def test_concurrent_copies(self) -> None: ) -@unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") @skipIfTorchDynamo("subprocess test does not need Dynamo coverage") @unittest.skipIf(TEST_WITH_CROSSREF, "subprocess test does not need crossref coverage") @@ -458,7 +455,6 @@ def test_writer_error_does_not_change_tests(self, mode) -> None: instantiate_parametrized_tests(TestReportFailureIsolation) -@unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") @skipIfTorchDynamo("subprocess test does not need Dynamo coverage") @unittest.skipIf(TEST_WITH_CROSSREF, "subprocess test does not need crossref coverage") @@ -508,7 +504,6 @@ def test_run_test_forwarding(self) -> None: self.assertEqual(args("/reports"), []) -@unittest.skipIf(IS_WINDOWS, "Skipping because doesn't work for windows") @unittest.skipIf(IS_SANDCASTLE, "Skipping because doesn't work on sandcastle") @skipIfTorchDynamo("subprocess test does not need Dynamo coverage") @unittest.skipIf(TEST_WITH_CROSSREF, "subprocess test does not need crossref coverage") diff --git a/torch/testing/_internal/common_methods_invocations.py b/torch/testing/_internal/common_methods_invocations.py index 5b98cecf9f452..86e16c92fc05a 100644 --- a/torch/testing/_internal/common_methods_invocations.py +++ b/torch/testing/_internal/common_methods_invocations.py @@ -47,7 +47,7 @@ TEST_WITH_ROCM, IS_FBCODE, IS_LINUX, IS_MACOS, TEST_SCIPY, torch_to_numpy_dtype_dict, numpy_to_torch_dtype, TEST_WITH_ASAN, GRADCHECK_NONDET_TOL, slowTest, TEST_WITH_SLOW, - TEST_WITH_TORCHINDUCTOR, skipIfNoTritonDSL, skipIfNoCuteDSL, skipIfRocm, skipIfRocmArch, MI200_ARCH + TEST_WITH_TORCHINDUCTOR, skipIfNoTritonDSL, skipIfNoCuteDSL, skipIfRocm ) from torch.testing._utils import wrapper_set_seed @@ -15473,10 +15473,6 @@ def sample_inputs_abs(op_info, device, dtype, requires_grad, op_kwargs=None, **k dtypes=(torch.int64,)), # RuntimeError: Convolution is supported only for Floating types DecorateInfo(unittest.expectedFailure, 'TestCommon', 'test_dtypes', device_type='mps'), - # MIOpen's fp16 bwd-data solver ConvAsmImplicitGemmGTCDynamicBwdXdlopsNHWC is inaccurate on gfx90a - # https://github.com/ROCm/rocm-libraries/issues/12322 - DecorateInfo(skipIfRocmArch(MI200_ARCH), 'TestCommon', 'test_complex_half_reference_testing', - device_type='cuda', dtypes=(torch.chalf,)), DecorateInfo( unittest.expectedFailure, 'TestCommon', 'test_noncontiguous_samples', device_type='mps', dtypes=(torch.int64,) diff --git a/torch/testing/_internal/common_nn.py b/torch/testing/_internal/common_nn.py index 4b308bba361bd..ccbb672d65c40 100644 --- a/torch/testing/_internal/common_nn.py +++ b/torch/testing/_internal/common_nn.py @@ -15,7 +15,7 @@ import torch.nn.functional as F from torch.testing._internal import common_utils from torch.testing._internal.common_utils import TestCase, to_gpu, freeze_rng_state, is_iterable, \ - gradcheck, gradgradcheck, MI300_ARCH, set_default_dtype, skipIfRocmArch, skipIfTorchDynamo, TEST_WITH_ROCM, \ + gradcheck, gradgradcheck, set_default_dtype, skipIfTorchDynamo, TEST_WITH_ROCM, \ TEST_ACCELERATOR, TEST_MPS from torch.testing._internal.common_cuda import SM90OrLater from torch.autograd.gradcheck import _get_numerical_jacobian, _iter_tensors @@ -2591,11 +2591,6 @@ def get_new_module_tests(): desc='multilayer_coder', with_tf32=True, tf32_precision=0.05 if SM90OrLater else 0.03, - # gfx942 runs TF32 on the XF32 hardware path; this K=4 multilayer entry - # amplifies the TF32-class per-gemm error to 4e-3..2e-2 relative on every - # compare, which no absolute tolerance describes. The _fp32 sibling keeps - # the correctness coverage; see https://github.com/pytorch/pytorch/issues/196605. - tf32_decorator=skipIfRocmArch(MI300_ARCH), default_dtype=torch.double, ), dict( diff --git a/torch/testing/_internal/common_utils.py b/torch/testing/_internal/common_utils.py index 71747fb7db12b..af16a9f106961 100644 --- a/torch/testing/_internal/common_utils.py +++ b/torch/testing/_internal/common_utils.py @@ -1563,8 +1563,6 @@ def printErrors(self) -> None: unittest.main(argv=argv, testLoader=testLoader) IS_LINUX = sys.platform == "linux" -# Windows support has been removed; kept (always False) for API compatibility -IS_WINDOWS = False IS_MACOS = sys.platform == "darwin" IS_X86 = platform.machine() in ('x86_64', 'i386') IS_ARM64 = platform.machine() in ('arm64', 'aarch64', 'ARM64') @@ -2518,12 +2516,12 @@ def skipIfNotMiopenSuggestNHWC(fn): )(fn) def skipIfWindows(func=None, *, msg="test doesn't currently work on the Windows stack"): - decorator = lazy_skip_if(lambda: IS_WINDOWS, f"skipIfWindows: {msg}") + decorator = lazy_skip_if(lambda: False, f"skipIfWindows: {msg}") return decorator(func) if func is not None else decorator def skipIfWindowsXPU(func=None, *, msg="test doesn't currently work on the Windows stack"): decorator = lazy_skip_if( - lambda: IS_WINDOWS and torch.xpu.is_available(), f"skipIfWindowsXPU: {msg}" + lambda: False, f"skipIfWindowsXPU: {msg}" ) return decorator(func) if func is not None else decorator diff --git a/torch/testing/_internal/distributed/distributed_test.py b/torch/testing/_internal/distributed/distributed_test.py index 989a53d510dc4..03093b178a6c3 100644 --- a/torch/testing/_internal/distributed/distributed_test.py +++ b/torch/testing/_internal/distributed/distributed_test.py @@ -88,7 +88,6 @@ IS_LINUX, IS_MACOS, IS_SANDCASTLE, - IS_WINDOWS, skip_but_pass_in_sandcastle, skip_but_pass_in_sandcastle_if, TemporaryFileName, @@ -1397,7 +1396,7 @@ def test_send_recv_nccl_autograd_profiler(self): @requires_nccl_version((2, 7, 0), "Need NCCL 2.7+ for send/recv") @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_send_recv_nccl_torch_profiler(self): @@ -1468,7 +1467,7 @@ def test_send_recv_autograd_profiler(self): ) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_send_recv_torch_profiler(self): @@ -1574,7 +1573,7 @@ def test_send_recv_any_source_autograd_profiler(self): ) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode code causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_send_recv_any_source_torch_profiler(self): @@ -1634,7 +1633,7 @@ def test_send_recv_with_tag_autograd_profiler(self): ) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode code causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_send_recv_with_tag_torch_profiler(self): @@ -1705,7 +1704,7 @@ def test_isend_autograd_profiler(self): ) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode code causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_isend_torch_profiler(self): @@ -6229,7 +6228,7 @@ def test_ddp_profiling_autograd_profiler(self): @skip_if_lt_x_gpu(2) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode code causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) def test_ddp_profiling_torch_profiler(self): @@ -6318,7 +6317,7 @@ def _validate_execution_trace_nccl(self, et_file: str) -> None: @skip_if_lt_x_gpu(2) @skip_but_pass_in_sandcastle_if(IS_FBCODE, "Kineto in fbcode code causes hang") @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "torch.profiler not enabled for mac/windows: https://github.com/pytorch/pytorch/pull/56124", ) @unittest.skipIf(BACKEND != "nccl", "Tests nccl metadata primarily.") @@ -7953,7 +7952,7 @@ def test_different_graph_across_ranks(self): @require_backend_is_available({"gloo"}) @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "MacOS uses uv transport which does not have as robust error handling as tcp transport", ) def test_monitored_barrier_gloo(self): @@ -8105,7 +8104,7 @@ def test_monitored_barrier_gloo_rank_0_timeout(self): @require_backend_is_available({"gloo"}) @skip_if_small_worldsize @skip_but_pass_in_sandcastle_if( - IS_MACOS or IS_WINDOWS, + IS_MACOS, "MacOS uses uv transport which does not have as robust error handling as tcp transport", ) def test_monitored_barrier_failure_order(self):