Merge pull request #28421 from ngoldbaum/skip-32-bit

charris · web-flow · commit 9a2b8b401cec · 2025-03-03T13:42:56.000-07:00
BUG: skip legacy dtype multithreaded test on 32 bit runners
diff --git a/numpy/_core/tests/test_array_coercion.py b/numpy/_core/tests/test_array_coercion.py
@@ -14,7 +14,8 @@
 from numpy._core._rational_tests import rational
 
 from numpy.testing import (
-    assert_array_equal, assert_warns, IS_PYPY)
+    assert_array_equal, assert_warns, IS_PYPY, IS_64BIT
+)
 
 
 def arraylikes():
@@ -718,8 +719,7 @@ def __array__(self, dtype=None, copy=None):
         arr = np.array([ArrayLike])
         assert arr[0] is ArrayLike
 
-    @pytest.mark.skipif(
-            np.dtype(np.intp).itemsize < 8, reason="Needs 64bit platform")
+    @pytest.mark.skipif(not IS_64BIT, reason="Needs 64bit platform")
     def test_too_large_array_error_paths(self):
         """Test the error paths, including for memory leaks"""
         arr = np.array(0, dtype="uint8")
diff --git a/numpy/_core/tests/test_multiarray.py b/numpy/_core/tests/test_multiarray.py
@@ -30,7 +30,7 @@
     assert_array_equal, assert_raises_regex, assert_array_almost_equal,
     assert_allclose, IS_PYPY, IS_WASM, IS_PYSTON, HAS_REFCOUNT,
     assert_array_less, runstring, temppath, suppress_warnings, break_cycles,
-    check_support_sve, assert_array_compare,
+    check_support_sve, assert_array_compare, IS_64BIT
     )
 from numpy.testing._private.utils import requires_memory, _no_tracing
 from numpy._core.tests._locales import CommaDecimalPointLocale
@@ -978,7 +978,7 @@ def test_too_big_error(self):
         assert_raises(ValueError, np.zeros, shape, dtype=np.int8)
         assert_raises(ValueError, np.ones, shape, dtype=np.int8)
 
-    @pytest.mark.skipif(np.dtype(np.intp).itemsize != 8,
+    @pytest.mark.skipif(not IS_64BIT,
                         reason="malloc may not fail on 32 bit systems")
     def test_malloc_fails(self):
         # This test is guaranteed to fail due to a too large allocation
diff --git a/numpy/_core/tests/test_multithreading.py b/numpy/_core/tests/test_multithreading.py
@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from numpy.testing import IS_WASM
+from numpy.testing import IS_WASM, IS_64BIT
 from numpy.testing._private.utils import run_threaded
 from numpy._core import _rational_tests
 
@@ -257,20 +257,16 @@ def func(arr):
             f.result()
 
 
+@pytest.mark.skipif(
+    not IS_64BIT,
+    reason="Sometimes causes failures or crashes due to OOM on 32 bit runners"
+)
 def test_legacy_usertype_cast_init_thread_safety():
     def closure(b):
         b.wait()
         np.full((10, 10), 1, _rational_tests.rational)
 
-    try:
-        run_threaded(closure, 250, pass_barrier=True)
-    except RuntimeError:
-        # The 32 bit linux runner will trigger this with 250 threads. I can
-        # trigger it on my Linux laptop with 500 threads but the CI runner is
-        # more resource-constrained.
-        # Reducing the number of threads means the test doesn't trigger the
-        # bug. Better to skip on some platforms than add a useless test.
-        pytest.skip("Couldn't spawn enough threads to run the test")
+    run_threaded(closure, 250, pass_barrier=True)
 
 @pytest.mark.parametrize("dtype", [bool, int, float])
 def test_nonzero(dtype):
diff --git a/numpy/_core/tests/test_regression.py b/numpy/_core/tests/test_regression.py
@@ -14,7 +14,8 @@
         assert_, assert_equal, IS_PYPY, assert_almost_equal,
         assert_array_equal, assert_array_almost_equal, assert_raises,
         assert_raises_regex, assert_warns, suppress_warnings,
-        _assert_valid_refcount, HAS_REFCOUNT, IS_PYSTON, IS_WASM
+        _assert_valid_refcount, HAS_REFCOUNT, IS_PYSTON, IS_WASM,
+        IS_64BIT,
         )
 from numpy.testing._private.utils import _no_tracing, requires_memory
 from numpy._utils import asbytes, asunicode
@@ -2264,7 +2265,7 @@ def test_void_compare_segfault(self):
     def test_reshape_size_overflow(self):
         # gh-7455
         a = np.ones(20)[::2]
-        if np.dtype(np.intp).itemsize == 8:
+        if IS_64BIT:
             # 64 bit. The following are the prime factors of 2**63 + 5,
             # plus a leading 2, so when multiplied together as int64,
             # the result overflows to a total size of 10.
diff --git a/numpy/f2py/tests/test_return_real.py b/numpy/f2py/tests/test_return_real.py
@@ -1,8 +1,8 @@
 import platform
 import pytest
-import numpy as np
 
 from numpy import array
+from numpy.testing import IS_64BIT
 from . import util
 
 
@@ -53,8 +53,7 @@ def check_function(self, t, tname):
     "but not when run in isolation",
 )
 @pytest.mark.skipif(
-    np.dtype(np.intp).itemsize < 8,
-    reason="32-bit builds are buggy"
+    not IS_64BIT, reason="32-bit builds are buggy"
 )
 class TestCReturnReal(TestReturnReal):
     suffix = ".pyf"
diff --git a/numpy/f2py/tests/test_semicolon_split.py b/numpy/f2py/tests/test_semicolon_split.py
@@ -1,6 +1,7 @@
 import platform
 import pytest
-import numpy as np
+
+from numpy.testing import IS_64BIT
 
 from . import util
 
@@ -11,8 +12,7 @@
     "but not when run in isolation",
 )
 @pytest.mark.skipif(
-    np.dtype(np.intp).itemsize < 8,
-    reason="32-bit builds are buggy"
+    not IS_64BIT, reason="32-bit builds are buggy"
 )
 class TestMultiline(util.F2PyTest):
     suffix = ".pyf"
@@ -44,8 +44,7 @@ def test_multiline(self):
     "but not when run in isolation",
 )
 @pytest.mark.skipif(
-    np.dtype(np.intp).itemsize < 8,
-    reason="32-bit builds are buggy"
+    not IS_64BIT, reason="32-bit builds are buggy"
 )
 @pytest.mark.slow
 class TestCallstatement(util.F2PyTest):
diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py
@@ -283,7 +283,7 @@
 import numpy as np
 from numpy.testing import (
     assert_, assert_array_equal, assert_raises, assert_raises_regex,
-    assert_warns, IS_PYPY, IS_WASM
+    assert_warns, IS_PYPY, IS_WASM, IS_64BIT
     )
 from numpy.testing._private.utils import requires_memory
 from numpy.lib import format
@@ -926,8 +926,7 @@ def test_large_file_support(tmpdir):
 
 
 @pytest.mark.skipif(IS_PYPY, reason="flaky on PyPy")
-@pytest.mark.skipif(np.dtype(np.intp).itemsize < 8,
-                    reason="test requires 64-bit system")
+@pytest.mark.skipif(not IS_64BIT, reason="test requires 64-bit system")
 @pytest.mark.slow
 @requires_memory(free_bytes=2 * 2**30)
 def test_large_archive(tmpdir):
diff --git a/numpy/testing/_private/utils.py b/numpy/testing/_private/utils.py
@@ -45,7 +45,7 @@
         'HAS_REFCOUNT', "IS_WASM", 'suppress_warnings', 'assert_array_compare',
         'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64', 'IS_PYSTON',
         'IS_MUSL', 'check_support_sve', 'NOGIL_BUILD',
-        'IS_EDITABLE', 'IS_INSTALLED', 'NUMPY_ROOT', 'run_threaded',
+        'IS_EDITABLE', 'IS_INSTALLED', 'NUMPY_ROOT', 'run_threaded', 'IS_64BIT',
         ]
 
 
@@ -104,6 +104,7 @@ class KnownFailureException(Exception):
     IS_MUSL = True
 
 NOGIL_BUILD = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+IS_64BIT = np.dtype(np.intp).itemsize == 8
 
 def assert_(val, msg=''):
     """
