[LUAU] pthreads signaling question

[Jim Thompson]

On Mar 10, 2005, at 4:01 PM, Charles Lockhart wrote:

> I just upgraded a RH9 box to FC1.  I then rebuilt a multi-threaded 
> program and tried to run it, but found some behaviors that don't make 
> sense to me.  One of the threads sleeps on a conditional wait ( 
> pthread_cond_wait(&my_cond, &my_mutex)), and when a different thread 
> calls pthread_cond_broadcast(&my_cond), I kind of expect the first 
> thread to wake it's shiny smiling face and do some work.  But it 
> doesn't.  Shouldn't it?  It used to.
>
> I have found some references to bugs in RH9 of people  running into 
> "stalls" with similar stuff, but that never happened to me on RH9, so 
> I figured it ought to work on FC1 as well.
>
> Any info?  Can anyone confirm or deny that I'm doing something goofy?  
> I didn't really change anything, so if there's some other library I'm 
> supposed to link to or something, please lemme know.  Or for anything 
> else too.
>
> Thanks in advance,
>
> -Charles

pthread_cond_broadcast() will (attempt) to waken *ALL* threads waiting 
on that condition variable.   If there is more than one, they'll
race, and the first one that gets past the mutex 'wins'.   
pthread_cond_signal() will attempt to waken *one* thread (typically the 
first
thread waiting on the condition variable.)

Perhaps you're just running into side-effects of the scheduler.  It 
seems to work here (gentoo, 2.6.10 kernel).  See the code and output 
below.
(I'm not bragging on the code, it was quick-n-dirty.)

The Fedora Project officially ended support for Fedora Core 1 (FC1) on 
September 20th, 2004.  FC3 was released November 8, 2004.
Maybe you should run FC3 (which is current) .vs a release that is now 
known as "Fedora Legacy".  (http://fedora.redhat.com/)

jim

/home/jim> cat thread_signal.c
#include <pthread.h>
#include <stdio.h>

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int workToDo = 0;

#define NTHREADS 5

void *
func(void *parm)
{
     int rc;
     int id = (int) parm;

     while (1) {
         /* Usually worker threads will loop on these operations */
         if ((rc = pthread_mutex_lock(&mutex)) < 0) {
           fprintf(stderr, "thread %d, pthread_mutex_lock(): %s\n",
               id, strerror(rc)); /* strerror not thread-safe */
           pthread_exit(NULL);
         }

         while (!workToDo) {
             printf("\tThread %d blocked\n", id);
             if ((rc = pthread_cond_wait(&cond, &mutex)) < 0) {
               fprintf(stderr, "thread %d, pthread_cond_wait(): %s\n",
                   id, strerror(rc)); /* not thread-safe */
               pthread_exit(NULL);
             }
         }
          printf("\tThread %d awake, finish work!\n", id);

          /* Under protection of the lock, complete or remove the work   
   */
          /* from whatever worker queue we have. Here it is simply a 
flag  */
          workToDo = 0;

         if ((rc = pthread_mutex_unlock(&mutex)) < 0) {
           fprintf(stderr, "thread %d, pthread_mutex_unlock(): %s\n",
               id, strerror(rc)); /* strerror not thread-safe */
           pthread_exit(NULL);
         }
   }
   return NULL;
}

int
main(int argc, char **argv)
{
   pthread_t threadid[NTHREADS];
   int rc, i;

   printf("Create %d threads\n", NTHREADS);
   for (i = 0; i < NTHREADS; i++) {
       if ((rc = pthread_create(&threadid[i], NULL, func, (void *)i)) < 
0) {
         perror("pthread_create");
         exit(1);
       }
    }

   sleep(1);  /* Sleep is not a robust way to serialize threads */

   for (i = 0; i < 5; ++i) {
       printf("Wake up a worker, work to do...\n");

       if ((rc = pthread_mutex_lock(&mutex)) < 0) {
           perror("pthread_mutex_lock()");
           exit(1);
       }

       /* In the real world, all the threads might be busy, and
        * we would add work to a queue instead of simply using a flag
        * In that case the boolean predicate might be some boolean
        * statement like: if (the-queue-contains-work)
        */

       if (workToDo) {
           printf("Work already present, likely threads are busy\n");
       }
       workToDo = 1;

#ifdef COND_SIGNAL
       if ((rc = pthread_cond_signal(&cond)) < 0) {
           perror("pthread_cond_signal()");
           exit(1);
       }
#else
       if ((rc = pthread_cond_broadcast(&cond)) < 0) {
           perror("pthread_cond_signal()");
           exit(1);
       }
#endif

       if ((rc = pthread_mutex_unlock(&mutex)) < 0) {
           perror("pthread_mutex_unlock()");
           exit(1);
       }

       sleep(1); /* Sleep is not a robust way to serialize threads */
   }

   exit(0);
}

/home/jim> gcc thread_signal.c -o thread_signal -lpthread
/home/jim> gcc -DCOND_SIGNAL=1 thread_signal.c -o thread_cond_signal 
-lpthread
/home/jim> gcc thread_signal.c -o thread_cond_broadcast -lpthread
/home/jim> ./thread_cond_signal
Create 5 threads
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
Wake up a worker, work to do...
         Thread 1 awake, finish work!
         Thread 1 blocked
Wake up a worker, work to do...
         Thread 2 awake, finish work!
         Thread 2 blocked
Wake up a worker, work to do...
         Thread 3 awake, finish work!
         Thread 3 blocked
Wake up a worker, work to do...
         Thread 4 awake, finish work!
         Thread 4 blocked
/home/jim> ./thread_cond_broadcast
Create 5 threads
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
Wake up a worker, work to do...
         Thread 0 awake, finish work!
         Thread 0 blocked
         Thread 1 blocked
         Thread 2 blocked
         Thread 3 blocked
         Thread 4 blocked
/home/jim>