CODEWITHSUNDEEP
cmultithreadingtimerposixposix-api
Scissor
Scissor

Reputation: 153

Timer freezes after some time

I am running the following program which implements a timer. When a thread awake after receiving a signal on condition variable from the previous running thread, it creates a timer and send a signal to the next thread on timer expiration. I want it to run for some time, but the timer stops ticking after some runs.

//Import 
#define _POSIX_C_SOURCE 199309
#include <sched.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#define NUM_THREADS 10

#define CLOCKID CLOCK_REALTIME
#define SIG SIGUSR1
timer_t timerid;

pthread_cond_t   condA[NUM_THREADS+1]  = PTHREAD_COND_INITIALIZER;
pthread_mutex_t  mutex  = PTHREAD_MUTEX_INITIALIZER;

pthread_t tid[NUM_THREADS];
int state = 0;

static void handler(int sig, siginfo_t *si, void *uc)
{
    if(si->si_value.sival_ptr != &timerid){
        printf("Stray signal\n");
    } else {
        //printf("Caught signal %d from timer\n", sig);
    }

        pthread_cond_signal(&condA[state]);
}

void *threadA(void *data_)
{
    int i = 0, s;
    long int loopNum, j;

    int turn = (intptr_t)data_;

    struct timeval tval_result;

    // Timer's part starts

    struct sigevent sev;
    struct itimerspec its;
    long long freq_nanosecs;
    sigset_t mask;
    struct sigaction sa;
    // TImer'spart ends

    while(1)
    {

        /* Wait for state A */
        pthread_mutex_lock(&mutex);

        for (;state != turn;)
        {
            s = pthread_cond_wait(&condA[turn], &mutex);
            if (s != 0)
                perror("pthread_cond_wait");
           // printf("main(): state = %d\n", state);
        }
        pthread_mutex_unlock(&mutex);

        //do stuff
        for(j=0;j<10000;j++)
            {//some dummy time consuming works}

        sa.sa_flags = SA_SIGINFO;
        sa.sa_sigaction = handler;
        sigemptyset(&sa.sa_mask);
        sigaction(SIG, &sa, NULL);

        sev.sigev_notify = SIGEV_SIGNAL;
        sev.sigev_signo = SIG;
        sev.sigev_value.sival_ptr = &timerid;
        timer_create(CLOCKID, &sev, &timerid);
        /* Start the timer */

        its.it_value.tv_sec = 0;
        its.it_value.tv_nsec = 2000;
        its.it_interval.tv_sec = 0;
        its.it_interval.tv_nsec = 0;

        timer_settime(timerid, 0, &its, NULL);
        pthread_mutex_lock(&mutex);
        state = (state +1)%NUM_THREADS;
        //pthread_cond_signal(&condA[state]);
        pthread_mutex_unlock(&mutex);
        // Timer's code ends
    }

}

int main(int argc, char *argv[])
{
    int data = 0;
    int err;

    while(data < NUM_THREADS)
    {
        //create our threads
        err = pthread_create(&tid[data], NULL, threadA, (void *)(intptr_t)data);
        if(err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        else
           // printf("\n Thread created successfully\n");

        data++;
    }

    pthread_exit(NULL);
}

Although no printf statements are executing, why is it freezing after some time? If no. of timers are limited, what other strategy should I use to redress this issue?

Upvotes: 0

Views: 160

Answers (1)

Art
Art

Reputation: 20392

POSIX says:

It is not safe to use the pthread_cond_signal() function in a signal handler that is invoked asynchronously.

Most likely you end up corrupting the state of pthread_cond_wait/pthread_cond_signal and anything can happen.

Don't mix threads and signal handlers, it leads only to madness. There are very few things you're allowed to do inside a signal handler, even fewer that are thread related, it's very hard to ensure that the right thread ends up handling the right signal, etc.

If you're doing threads anyway implement a timer in one thread that calculates how much time it needs to sleep to deliver the next event (don't just hardcode it to your timer period since that will make your timer drift), sleep that much and call pthread_cond_signal.

Also, it's bad form to have naked pthread_cond_signal calls and most often a bug. You might get unlucky and call it just before the other thread does the pthread_cond_wait and your signal will get lost. The normal thing to do is to set a variable (protected by a mutex, that's why pthread_cond_signal wants a mutex) and then signal that the variable is set.

If you think this is too much work, condition variables are probably not the right mechanism in this case and you should use semaphores instead. Incidentally sem_post is legal to call from a signal handler according to POSIX, but I still think it's a bad idea to mix threads with signals.

Upvotes: 1

Related Questions