[Bug nptl/25847] pthread_cond_signal failed to wake up pthread_cond_wait due to a bug in undoing stealing

["arun11299 at gmail dot com" <sourceware-bugzilla@sourceware.org>]

https://sourceware.org/bugzilla/show_bug.cgi?id=25847

Arun <arun11299 at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |arun11299 at gmail dot com

--- Comment #3 from Arun <arun11299 at gmail dot com> ---
I am probably facing the same issue with Python as well where GIL (Global
Interpreter Lock) is the one locking the critical region of code.

My setup involves spawning 4 to 8 Python threads and each thread would be
making lots of Redis socket calls. Python releases the GIL whenever a socket
call is made so that other threads can make some progress.

Below is the backtrace of the thread which was supposed to release the GIL by
doing a condition signal first.

-------------------

(gdb) bt

#0  0x00007f12c99e04b0 in futex_wait (private=<optimized out>, expected=4,
futex_word=0xa745b0 <gil_cond+16>)
    at ../sysdeps/unix/sysv/linux/futex-internal.h:61

#1  0x00007f12c99e04b0 in futex_wait_simple (private=<optimized out>,
expected=4, futex_word=0xa745b0 <gil_cond+16>)
    at ../sysdeps/nptl/futex-internal.h:135
#2  0x00007f12c99e04b0 in __condvar_quiesce_and_switch_g1 (private=<optimized
out>,
                                                           g1index=<synthetic
pointer>,
                                                           wseq=<optimized
out>,
                                                           cond=0xa745a0
<gil_cond>) at pthread_cond_common.c:412

#3  0x00007f12c99e04b0 in __pthread_cond_signal (cond=0xa745a0 <gil_cond>) at
pthread_cond_signal.c:78

#4  0x000000000050bfc8 in drop_gil.lto_priv (tstate=0x146ee3f0) at
../Python/ceval_gil.h:187
#5  0x000000000050c0ed in PyEval_SaveThread () at ../Python/ceval.c:356
#6  0x00000000005c04bb in sock_call_ex (s=0x7f125b97a9a8, writing=1, sock_func=

    0x5bdbf0 <sock_send_impl>, data=0x7f12594650a0, connect=0, err=0x0,
timeout=-1000000000) at ../Modules/socketmodule.c:899
#7  0x00000000005c0659 in sock_sendall (s=0x7f125b97a9a8, args=<optimized out>)
at ../Modules/socketmodule.c:3833
#8  0x000000000050a8af in _PyCFunction_FastCallDict (kwargs=<optimized out>,
nargs=<optimized out>, args=<optimized out>, func_obj=<built-in method sendall
of socket object at remote 0x7f125b97a9a8>) at ../Objects/methodobject.c:234
#9  0x000000000050a8af in _PyCFunction_FastCallKeywords (kwnames=<optimized
out>, nargs=<optimized out>, stack=<optimized out>, func=<optimized out>) at
../Objects/methodobject.c:294
#10 0x000000000050a8af in call_function.lto_priv (pp_stack=0x7f1259465250,
oparg=<optimized out>, kwnames=<optimized out>)
    at ../Python/ceval.c:4851
#11 0x000000000050c5b9 in _PyEval_EvalFrameDefault (f=<optimized out>,
throwflag=<optimized out>) at ../Python/ceval.c:3335
#12 0x0000000000509d48 in PyEval_EvalFrameEx (throwflag=0, f=Frame 0x16cdcbf8,
for file /usr/lib/python3/dist-packages/redis/connection.py, line 590, in
send_packed_command (self=<Connection(pid=12668, host='10.64.219.4', port=6379,
db=0, password=None, socket_timeout=None, socket_connect_timeout=None,
socket_keepalive=None, socket_keepalive_options={}, retry_on_timeout=False,
encoder=<Encoder(encoding='utf-8', encoding_errors='strict',
decode_responses=True) at remote 0x7f1259c84be0>, _sock=<socket at remote
0x7f125b97a9a8>, _parser=<HiredisParser(socket_read_size=65536,
_buffer=<bytearray at remote 0x7f1259c848b8>, _sock=<...>,
_reader=<hiredis.Reader at remote 0x7f1259c8b0c0>, _next_response=False) at
remote 0x7f1259c84518>, _description_args={'host': '10.64.219.4', 'port': 6379,
'db': 0}, _connect_callbacks=[]) at remote 0x7f1259c84ba8>,
command=[b'*2\r\n$3\r\nGET\r\n$54\r\nproj_00|mock1|cps|07b6e3d7-5ed1-36e8-81ef-e53777298405\r\n'],
item=b'*2\r\n$3\r\nGET\r\n$54\r\nproj_00|mock1|cps|07b6e3d7-5ed1-36e8-81ef-e53777298405\r\n'))
at ../Python/ceval.c:754
#13 0x0000000000509d48 in _PyFunction_FastCall (globals=<optimized out>,
nargs=382585848, args=<optimized out>, co=<optimized out>)
    at ../Python/ceval.c:4933


-------------------

Part of the python code that drops the GIL:

--------------------
static void
drop_gil(struct _ceval_runtime_state *ceval, PyThreadState *tstate)
{
    struct _gil_runtime_state *gil = &ceval->gil;
    if (!_Py_atomic_load_relaxed(&gil->locked)) {
        Py_FatalError("drop_gil: GIL is not locked");
    }

    /* tstate is allowed to be NULL (early interpreter init) */
    if (tstate != NULL) {
        /* Sub-interpreter support: threads might have been switched
           under our feet using PyThreadState_Swap(). Fix the GIL last
           holder variable so that our heuristics work. */
        _Py_atomic_store_relaxed(&gil->last_holder, (uintptr_t)tstate);
    }

    MUTEX_LOCK(gil->mutex);
    _Py_ANNOTATE_RWLOCK_RELEASED(&gil->locked, /*is_write=*/1);
    _Py_atomic_store_relaxed(&gil->locked, 0);
    COND_SIGNAL(gil->cond);
    MUTEX_UNLOCK(gil->mutex);

#ifdef FORCE_SWITCHING
    if (_Py_atomic_load_relaxed(&ceval->gil_drop_request) && tstate != NULL) {
        MUTEX_LOCK(gil->switch_mutex);
        /* Not switched yet => wait */
        if (((PyThreadState*)_Py_atomic_load_relaxed(&gil->last_holder)) ==
tstate)
        {
            assert(is_tstate_valid(tstate));
            RESET_GIL_DROP_REQUEST(tstate->interp);
            /* NOTE: if COND_WAIT does not atomically start waiting when
               releasing the mutex, another thread can run through, take
               the GIL and drop it again, and reset the condition
               before we even had a chance to wait for it. */
            COND_WAIT(gil->switch_cond, gil->switch_mutex);
        }
        MUTEX_UNLOCK(gil->switch_mutex);
    }
#endif
}
--------------------

-- 
You are receiving this mail because:
You are on the CC list for the bug.