Hi~
If the lthreads run on different lcores, a race condition with lthread_mutex
may occur.
Like this:
lthread1 run on lcore=1
lthread2 run on lcore=2
If the mutex is owned by lthread2, lthread1 try to lock the mutex that will
block thread1. lthread_sched on lcore1 will insert lthread1 to the blocked
queue of the mutex. lthread1 blocks until lthread2 unlock the mutex.
Is that right?
Let's go back to the previous question.
Refer to http://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_cond_wait.html
"The pthread_cond_wait() and pthread_cond_timedwait() functions are used to
block on a condition variable. They are called with mutex locked by the calling
thread or undefined behaviour will result.
These functions atomically release mutex and cause the calling thread to block
on the condition variable cond; atomically here means "atomically with respect
to access by another thread to the mutex and then the condition variable"."
So I think there is a problem with pthread_cond_wait implemented by lthread. If
that is the case, could lthread fix this problem?
Regards,
Wubenqing
________________________________
From: Wiles, Keith<mailto:[email protected]>
Date: 2018-07-18 23:01
To: 吴本卿(研五 福州)<mailto:[email protected]>
CC: [email protected]<mailto:[email protected]>
Subject: Re: [dpdk-dev] Does lthread_cond_wait need a mutex?
> On Jul 17, 2018, at 10:43 PM, [email protected] wrote:
>
> Hi~
> Reference:
> http://doc.dpdk.org/guides-18.05/sample_app_ug/performance_thread.html?highlight=lthread
> The L-thread subsystem provides a set of functions that are logically
> equivalent to the corresponding functions offered by the POSIX pthread
> library.
> I think there is a bug with pthread_cond_wait of lthread implement.
> Look at this code, there are two lthread:
>
> lthread1:
> pthread_mutex_lock(mutex); //a1
> if (predicate == FALSE) { //a2
> pthread_cond_wait(cond, mutex) //a3
> }
> pthread_mutex_unlock(mutex); //a4
>
> int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
> {
> if (override) {
> pthread_mutex_unlock(mutex); //a31
> int rv = lthread_cond_wait(*(struct lthread_cond **)cond, 0); //a32
>
> pthread_mutex_lock(mutex); //a33
> return rv;
> }
> return _sys_pthread_funcs.f_pthread_cond_wait(cond, mutex);
> }
>
> lthread2:
> pthread_mutex_lock(mutex); //b1
> predicate = TRUE; //b2
> pthread_mutex_unlock(mutex); //b3
> pthread_cond_signal(cond); //b4
>
>
> If the sequence is:
> a1->a2->a31->b1->b2->b3->b4->a32
> Will lthread1 sleep forever?
Maybe is it possible, my brain is not working this morning. Please remember
that lthreads must give up control or lthread will continue to and can not be
preempted.
Does that fix the problem?
>
> ________________________________
> 吴本卿(研五 福州)
Regards,
Keith
