GeezerVison

Even with this PR the zip function is not thread-safe: when iterating over zip(range(100), range(100)) one can obtain a tuple (2,3). What does PR (hopefully) does is modifying the code so that the interpreter does not crash. For this reason I would like to be careful with the term "thread-safe". I choose not to make zip fully thread safe because of the performance impact, see the discussion in #120496

Thanks for clarifying. The word safe is a bit confusing, I guess a lot of other people would read it as thread-safe. I think we need to clarify the reason why zip isn't safe in free-threaded build.

I think we want to enable re-use under certain conditions. We should probably put the logic in some internal function, possibly in pycore_object.h. I think the condition for the free-threaded build is:

1. ob_tid matches _Py_ThreadId()
2. ob_ref_local is 1
3. ob_ref_shared is 0

The logic is that no other thread calling zip_next can re-use lz->result because of the thread id condition (condition 1). And no thread outside of zip_next can incref that object because the combined conditions ensure that lz->result is the only reference.

@colesbury Thanks for the hint! I implementeded the suggestion

• I placed the logic in a single method _Py_Reuse_Immutable_Object so we can use the trick code for several other cases (e.g. itertools.pairwise, enumerate). The location and name of the new method can be changed though
• I re-ordered the three conditions because I suspect that ob_ref_local is most informative and fastest to check
• I am now checking ob_ref_shared to be zero, but perhaps we should check on Py_ARITHMETIC_RIGHT_SHIFT(Py_ssize_t, ob_ref_shared , _Py_REF_SHARED_SHIFT)?

The preferred style is to use for loops instead of using list comprehensions for side effects.

We run lots of unit tests in CI, so they individually need to be very fast. For the free-threaded tests, we should aim for <0.1 seconds on two cores (i.e., when run with taskset -c 0-1 on Linux)

On my system (windows) the test is 0.07 seconds for the free-threading build. I will reduce the number of threads and iterations a bit so it is even faster.