pthread_cond_wait and pthread_cond_signal's performance - c++

Question

I have two threads.
One that reads from the a queue. I don't want it to run on while(1) to read, so I'm thinking about giving it a condition variable each looping:
while(1){
while queue is not empty
wait(cond)
pop()
}
instead of:
while(1){
while queue is not empty
pop
}
and a thread that pushes to the queue.If I use the wait and signal method , then that thread needs to notify by signaling the popping thread every time(!) it pushes
The question is what is better to use?
If the queue is mostly not empty, then it's worthless (or is it not?) to send signals because the popping thread isn't waiting and I'm afraid it would reduce performance.
However, if the queue is half the time empty, then looping on it as in the second method to pop might be a busy wait.
I'm hoping someone here would eliminate my fears by disqualifying the fact that sending a signal to a thread that's not waiting on it is still ok
Thanks

Answer 1

First just to make sure, pthread_cond_signal does not send a signal in the signal(2) sense. It just flags the condition variable and releases any variable that's waiting for it. So if you call pthread_cond_signal before the consuming process calls well, that's just going to be ignored.
Secondly, is pthread_cond_wait fast or slow? Well, it depends. You can use it poorly and you can use it well. If you use it poorly I'm sure it will perform terribly. If you only wait when you actually need to I think it will perform nicely.
So, since you need to hold a mutex to use condition variables, you might as well check if there is data at this point (and use this mutex as a synchronization point).
An idea for a queue data structure:
struct q {
struct qe *h;
struct qe *t;
pthread_mutex_t m;
pthread_cond_t c;
int len;
};
The consumer (assuming you only have one consumer, if you have multiple to need to lock around the head check):
void *consumer(void*arg) {
struct q *q = arg;
while(1) {
pthread_mutex_lock(&q->m);
if(q->h == NULL)
pthread_cond_wait(&q->c, &q->m);
/* We hold the mutex when we exit pthread_cond_wait */
pthread_mutex_unlock(&q->m); /* we can make the check without the mutex */
while(q->h != NULL) {
pthread_mutex_lock(&q->m); /* but we need it to modify */
pop();
pthread_mutex_unlock(&q->m);
/* Process data */
}
}
}
The producer:
void *producer(void*arg) {
int i;
struct q *q = arg;
while(1) {
pthread_mutex_lock(&q->m);
push(q, some_data);
if(q->h == q->t) /* only one element */
pthread_cond_signal(&q->c);
pthread_mutex_unlock(&q->m);
}
return NULL;
}