* Set C recursion limit to 1500, set cost of eval loop to 2 frames, and compiler mutliply to 2.
exception instance, rather than to a ``(typ, exc, tb)`` tuple.
(Contributed by Irit Katriel in :gh:`103176`.)
+* :func:`sys.setrecursionlimit` and :func:`sys.getrecursionlimit`.
+ The recursion limit now applies only to Python code. Builtin functions do
+ not use the recursion limit, but are protected by a different mechanism
+ that prevents recursion from causing a virtual machine crash.
+
tempfile
--------
# ifdef __wasi__
# define C_RECURSION_LIMIT 500
# else
-# define C_RECURSION_LIMIT 800
+ // This value is duplicated in Lib/test/support/__init__.py
+# define C_RECURSION_LIMIT 1500
# endif
#endif
from functools import cmp_to_key
from test import seq_tests
-from test.support import ALWAYS_EQ, NEVER_EQ
+from test.support import ALWAYS_EQ, NEVER_EQ, C_RECURSION_LIMIT
class CommonTest(seq_tests.CommonTest):
def test_repr_deep(self):
a = self.type2test([])
- for i in range(sys.getrecursionlimit() + 100):
+ for i in range(C_RECURSION_LIMIT + 1):
a = self.type2test([a])
self.assertRaises(RecursionError, repr, a)
import unittest
import collections
import sys
+from test.support import C_RECURSION_LIMIT
class BasicTestMappingProtocol(unittest.TestCase):
def test_repr_deep(self):
d = self._empty_mapping()
- for i in range(sys.getrecursionlimit() + 100):
+ for i in range(C_RECURSION_LIMIT + 1):
d0 = d
d = self._empty_mapping()
d[1] = d0
"run_with_tz", "PGO", "missing_compiler_executable",
"ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",
"LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",
- "Py_DEBUG", "EXCEEDS_RECURSION_LIMIT",
+ "Py_DEBUG", "EXCEEDS_RECURSION_LIMIT", "C_RECURSION_LIMIT",
+ "skip_on_s390x",
]
#For recursion tests, easily exceeds default recursion limit
EXCEEDS_RECURSION_LIMIT = 5000
+
+# The default C recursion limit (from Include/cpython/pystate.h).
+C_RECURSION_LIMIT = 1500
+
+#Windows doesn't have os.uname() but it doesn't support s390x.
+skip_on_s390x = unittest.skipIf(hasattr(os, 'uname') and os.uname().machine == 's390x',
+ 'skipped on s390x')
return self
enum._test_simple_enum(_Precedence, ast._Precedence)
+ @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
@support.cpython_only
def test_ast_recursion_limit(self):
fail_depth = support.EXCEEDS_RECURSION_LIMIT
import unittest
-from test.support import cpython_only, requires_limited_api
+from test.support import cpython_only, requires_limited_api, skip_on_s390x
try:
import _testcapi
except ImportError:
@cpython_only
class TestRecursion(unittest.TestCase):
+ @skip_on_s390x
def test_super_deep(self):
def recurse(n):
import warnings
from test import support
from test.support import (script_helper, requires_debug_ranges,
- requires_specialization)
+ requires_specialization, C_RECURSION_LIMIT)
from test.support.os_helper import FakePath
-
class TestSpecifics(unittest.TestCase):
def compile_single(self, source):
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
def test_extended_arg(self):
- repeat = 2000
+ repeat = int(C_RECURSION_LIMIT * 0.9)
longexpr = 'x = x or ' + '-x' * repeat
g = {}
code = textwrap.dedent('''
@support.cpython_only
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
def test_compiler_recursion_limit(self):
- # Expected limit is sys.getrecursionlimit() * the scaling factor
- # in symtable.c (currently 3)
- # We expect to fail *at* that limit, because we use up some of
- # the stack depth limit in the test suite code
- # So we check the expected limit and 75% of that
- # XXX (ncoghlan): duplicating the scaling factor here is a little
- # ugly. Perhaps it should be exposed somewhere...
- fail_depth = sys.getrecursionlimit() * 3
- crash_depth = sys.getrecursionlimit() * 300
- success_depth = int(fail_depth * 0.75)
+ # Expected limit is C_RECURSION_LIMIT * 2
+ # Duplicating the limit here is a little ugly.
+ # Perhaps it should be exposed somewhere...
+ fail_depth = C_RECURSION_LIMIT * 2 + 1
+ crash_depth = C_RECURSION_LIMIT * 100
+ success_depth = int(C_RECURSION_LIMIT * 1.8)
def check_limit(prefix, repeated, mode="single"):
expect_ok = prefix + repeated * success_depth
import unittest
import weakref
from test import support
-from test.support import import_helper
+from test.support import import_helper, C_RECURSION_LIMIT
class DictTest(unittest.TestCase):
def test_repr_deep(self):
d = {}
- for i in range(sys.getrecursionlimit() + 100):
+ for i in range(C_RECURSION_LIMIT + 1):
d = {1: d}
self.assertRaises(RecursionError, repr, d)
import pickle
import sys
import unittest
+from test.support import C_RECURSION_LIMIT
class DictSetTest(unittest.TestCase):
def test_deeply_nested_repr(self):
d = {}
- for i in range(sys.getrecursionlimit() + 100):
+ for i in range(C_RECURSION_LIMIT//2 + 100):
d = {42: d.values()}
self.assertRaises(RecursionError, repr, d)
import collections.abc
import types
import unittest
-
+from test.support import C_RECURSION_LIMIT
class TestExceptionGroupTypeHierarchy(unittest.TestCase):
def test_exception_group_types(self):
class DeepRecursionInSplitAndSubgroup(unittest.TestCase):
def make_deep_eg(self):
e = TypeError(1)
- for i in range(2000):
+ for i in range(C_RECURSION_LIMIT + 1):
e = ExceptionGroup('eg', [e])
return e
import pickle
import random
import sys
-from test.support import bigmemtest, _1G, _4G
+from test.support import bigmemtest, _1G, _4G, skip_on_s390x
zlib = import_helper.import_module('zlib')
# zlib.decompress(func1(data)) == zlib.decompress(func2(data)) == data
#
# Make the assumption that s390x always has an accelerator to simplify the skip
-# condition. Windows doesn't have os.uname() but it doesn't support s390x.
-skip_on_s390x = unittest.skipIf(hasattr(os, 'uname') and os.uname().machine == 's390x',
- 'skipped on s390x')
-
+# condition.
class VersionTestCase(unittest.TestCase):
--- /dev/null
+Increase C recursion limit for functions other than the main interpreter
+from 800 to 1500. This should allow functions like ``list.__repr__`` and
+``json.dumps`` to handle all the inputs that they could prior to 3.12
int starting_recursion_depth;
/* Be careful here to prevent overflow. */
- int COMPILER_STACK_FRAME_SCALE = 3;
+ int COMPILER_STACK_FRAME_SCALE = 2;
PyThreadState *tstate = _PyThreadState_GET();
if (!tstate) {
return 0;
int starting_recursion_depth;
/* Be careful here to prevent overflow. */
- int COMPILER_STACK_FRAME_SCALE = 3;
+ int COMPILER_STACK_FRAME_SCALE = 2;
PyThreadState *tstate = _PyThreadState_GET();
if (!tstate) {
return 0;
/* See comments in symtable.c. */
-#define COMPILER_STACK_FRAME_SCALE 3
+#define COMPILER_STACK_FRAME_SCALE 2
int
_PyAST_Validate(mod_ty mod)
#undef CALL_SEQ
/* See comments in symtable.c. */
-#define COMPILER_STACK_FRAME_SCALE 3
+#define COMPILER_STACK_FRAME_SCALE 2
int
_PyAST_Optimize(mod_ty mod, PyArena *arena, int optimize, int ff_features)
tstate->cframe = cframe.previous;
assert(tstate->cframe->current_frame == frame->previous);
assert(!_PyErr_Occurred(tstate));
- _Py_LeaveRecursiveCallTstate(tstate);
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return retval;
}
# pragma warning(disable:4102)
#endif
+
+/* _PyEval_EvalFrameDefault() is a *big* function,
+ * so consume 3 units of C stack */
+#define PY_EVAL_C_STACK_UNITS 2
+
PyObject* _Py_HOT_FUNCTION
_PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)
{
frame->previous = &entry_frame;
cframe.current_frame = frame;
+ tstate->c_recursion_remaining -= (PY_EVAL_C_STACK_UNITS - 1);
if (_Py_EnterRecursiveCallTstate(tstate, "")) {
tstate->c_recursion_remaining--;
tstate->py_recursion_remaining--;
/* Restore previous cframe and exit */
tstate->cframe = cframe.previous;
assert(tstate->cframe->current_frame == frame->previous);
- _Py_LeaveRecursiveCallTstate(tstate);
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return NULL;
}
tstate->cframe = cframe.previous;
assert(tstate->cframe->current_frame == frame->previous);
assert(!_PyErr_Occurred(tstate));
- _Py_LeaveRecursiveCallTstate(tstate);
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return retval;
}
return NULL;
}
-/* When compiling the use of C stack is probably going to be a lot
- lighter than when executing Python code but still can overflow
- and causing a Python crash if not checked (e.g. eval("()"*300000)).
- Using the current recursion limit for the compiler seems too
- restrictive (it caused at least one test to fail) so a factor is
- used to allow deeper recursion when compiling an expression.
-
- Using a scaling factor means this should automatically adjust when
+/* Using a scaling factor means this should automatically adjust when
the recursion limit is adjusted for small or large C stack allocations.
*/
-#define COMPILER_STACK_FRAME_SCALE 3
+#define COMPILER_STACK_FRAME_SCALE 2
struct symtable *
_PySymtable_Build(mod_ty mod, PyObject *filename, PyFutureFeatures *future)
projects / thirdparty / Python / cpython.git / commitdiff
