def setrecursionlimit(space, new_limit): """setrecursionlimit() sets the maximum number of nested calls that can occur before a RuntimeError is raised. On PyPy the limit is approximative and checked at a lower level. The default 1000 reserves 768KB of stack space, which should suffice (on Linux, depending on the compiler settings) for ~1400 calls. Setting the value to N reserves N/1000 times 768KB of stack space. Note that there are other factors that also limit the stack size. The operating system typically sets a maximum which can be changed manually (e.g. with "ulimit" on Linux) for the main thread. For other threads you can configure the limit by calling "threading.stack_size()". """ from rpython.rlib.rstack import _stack_set_length_fraction from rpython.rlib.rgc import increase_root_stack_depth if new_limit <= 0: raise oefmt(space.w_ValueError, "recursion limit must be positive") # Some programs use very large values to mean "don't check, I want to # use as much as possible and then segfault". Add a silent upper bound # of 10**6 here, because huge values cause huge shadowstacks to be # allocated (or MemoryErrors). if new_limit > 1000000: new_limit = 1000000 space.sys.recursionlimit = new_limit _stack_set_length_fraction(new_limit * 0.001) increase_root_stack_depth(int(new_limit * 0.001 * 163840))
def entry_point(argv): if we_are_translated(): from rpython.rlib import rstack rstack._stack_set_length_fraction(50.0) else: import sys sys.setrecursionlimit(100000) (filename, ret, args, conf) = parse_options(argv, default_config) config = conf if config["ReadStatefile"] and filename is not None: do_come_up(filename) boot() if filename is None: print_help(argv, config) return ret # quit early. (result, timing) = run(config, filename, args) if config["WriteStatefile"]: do_settle(filename) if config["Print"]: print result if config["Verbose"]: CompoundShape.print_verbose() if config["Verbose"] or config["Stats"]: print_statistics(timing, filename) return 0
def entry_point(argv): _stack_set_length_fraction(0.1) try: return f(1) except StackOverflow: glob.n = 0 _stack_set_length_fraction(float(argv[1])) try: return f(1) except StackOverflow: print glob.n return 0
def setrecursionlimit(space, new_limit): """setrecursionlimit() sets the maximum number of nested calls that can occur before a RuntimeError is raised. On PyPy the limit is approximative and checked at a lower level. The default 1000 reserves 768KB of stack space, which should suffice (on Linux, depending on the compiler settings) for ~1400 calls. Setting the value to N reserves N/1000 times 768KB of stack space. """ from rpython.rlib.rstack import _stack_set_length_fraction if new_limit <= 0: raise oefmt(space.w_ValueError, "recursion limit must be positive") space.sys.recursionlimit = new_limit _stack_set_length_fraction(new_limit * 0.001)
def setrecursionlimit(space, new_limit): """setrecursionlimit() sets the maximum number of nested calls that can occur before a RuntimeError is raised. On PyPy the limit is approximative and checked at a lower level. The default 1000 reserves 768KB of stack space, which should suffice (on Linux, depending on the compiler settings) for ~1400 calls. Setting the value to N reserves N/1000 times 768KB of stack space. Note that there are other factors that also limit the stack size. The operating system typically sets a maximum which can be changed manually (e.g. with "ulimit" on Linux) for the main thread. For other threads you can configure the limit by calling "threading.stack_size()". """ from rpython.rlib.rstack import _stack_set_length_fraction from rpython.rlib.rgc import increase_root_stack_depth if new_limit <= 0: raise oefmt(space.w_ValueError, "recursion limit must be positive") space.sys.recursionlimit = new_limit _stack_set_length_fraction(new_limit * 0.001) increase_root_stack_depth(int(new_limit * 0.001 * 163840))