Question

I am coding a telemetry system in C++ and have been having some difficulty syncing certain threads with the standard pthread_cond_timedwait and pthread_cond_broadcast.

The problem was that I needed some way for the function that was doing the broadcasting to know if another thread acted on the broadcast.

After some hearty searching I decided I might try using a barrier for the two threads instead. However, I still wanted the timeout functionality of the pthread_cond_timedwait.

Here is basically what I came up with: (However it feels excessive)

Listen Function: Checks for a period of milliseconds to see if an event is currently being triggered.

bool listen(uint8_t eventID, int timeout)
{  
    int waitCount = 0;  
    while(waitCount <= timeout)
    {  
        globalEventID = eventID;
        if(getUpdateFlag(eventID) == true)
        {
            pthread_barrier_wait(&barEvent);
            return true;
        }
        threadSleep(); //blocks for 1 millisecond
        ++waitCount;
    }
    return false;
}

Trigger Function: Triggers an event for a period of milliseconds by setting an update flag for the triggering period

bool trigger(uint8_t eventID, int timeout)
    int waitCount = 0;  
    while(waitCount <= timeout)
    {  
        setUpdateFlag(eventID, true); //Sets the update flag to true
        if(globalEventID == eventID)
        {
            pthread_barrier_wait(&barEvent);
            return true;
        }
        threadSleep(); //blocks for 1 millisecond
        ++waitCount;
    }
    setUpdateFlag(eventID, false);
    return false;
}

My questions: Is another way to share information with the broadcaster, or are barriers really the only efficient way? Also, is there another way of getting timeout functionality with barriers?

Answer 1

Based on your described problem:

Specifically, I am trying to let thread1 know that the message it is
waiting for has been parsed and stored in a global list by thread2,
and that thread2 can continue parsing and storing because thread1 will
now copy that message from the list ensuring that thread2 can
overwrite that message with a new version and not disrupt the
operations of thread1.

It sounds like your problem can be solved by having both threads alternately wait on the condition variable. Eg. in thread 1:

pthread_mutex_lock(&mutex);
while (!message_present)
    pthread_cond_wait(&cond, &mutex);
copy_message();
message_present = 0;
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mutex);

process_message();

and in thread 2:

parse_message();

pthread_mutex_lock(&mutex);
while (message_present)
    pthread_cond_wait(&cond, &mutex);
store_message();
message_present = 1;
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mutex);