bboard

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>

pthread_mutex_t lock;
struct timespec first;
struct timespec current;

void timeoutThread(void* args) {
    int err;
    pthread_condattr_t attr;
    pthread_cond_t cond;
    struct timespec timeout;

    clock_gettime(CLOCK_MONOTONIC, &timeout);
    timeout.tv_sec += 3;

    pthread_condattr_init(&attr);
    pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
    pthread_cond_init(&cond, &attr);

    usleep(1000000);
    err = pthread_cond_timedwait(&cond, &lock, &time);
    clock_gettime(CLOCK_MONOTONIC, ¤t);
    printf("[%d.%d] ", (int)(current.tv_sec - start.tv_sec), (int)(current.tv_nsec - start.tv_nsec));
    switch(err) {
        case ETIMEDOUT: printf("Timeout expired\n"); break;
        case EINVAL:    perror("Error: "); break;
        default:        printf("Took it in time\n"); break;
    }
}

int main(void) {
    pthread_t handle;

    pthread_mutex_init(&lock, NULL);

    clock_gettime(CLOCK_MONOTONIC, &start);
    clock_gettime(CLOCK_MONOTONIC, ¤t);

    printf("[%d.%d] ", (int)(current.tv_sec - start.tv_sec), (int)(current.tv_nsec - start.tv_nsec));
    printf("Start\n");

    pthread_create(&handle, NULL, (void*)timedThread, NULL);

    pthread_mutex_lock(&lock);
    usleep(5000000);
    pthread_mutex_unlock(&lock);

    clock_gettime(CLOCK_MONOTONIC, ¤t);
    printf("[%d.%d] ", (int)(current.tv_sec - start.tv_sec), (int)(current.tv_nsec - start.tv_nsec));
    printf("Done\n");

    return 0;
}

clock_gettime(CLOCK_REALTIME, &start);
clock_gettime(CLOCK_REALTIME, &timeout);
printf("%d HELLO\n",get_seconds_elapsed(timeout,start));
timeout.tv_sec += 1;
usleep(timeout);
clock_gettime(CLOCK_REALTIME, &timeout);
printf("%d WORLD\n",get_seconds_elapsed(timeout,start));

0 HELLO
1 WORLD

0 HELLO
3601 WORLD

The pthread_cond_timedwait() and pthread_cond_wait() functions shall block on a condition variable. The application shall ensure that these functions are called with mutex locked by the calling thread; otherwise, an error (for PTHREAD_MUTEX_ERRORCHECK and robust mutexes) or undefined behavior (for other mutexes) results.

pthread_mutex_timedlock()

sem_timedwait()

pthread_cond_timedwait()

struct timespec next_wait;
clock_gettime(CLOCK_REALTIME, &next_wait);
int res;

while (1) {
    next_wait.tv_nsec += 1000000;                       /* Wait one millisecond */
    next_wait.tv_sec += next_wait.tv_nsec / 1000000000; /* Increase seconds if applicable */
    next_wait.tv_nsec %= 1000000000;                    /* Reset nsec below 1B nsec */
    if (pthread_mutex_timedlock(&sem, &next_wait) == 0) {
        doSomeStuff();
        pthread_cond_timedwait(&sem, &next_wait);
    }
}

sudo ntpdate

Posted by funkyass
by not using outdated time syncing software? ntpdate was replaced with ntpd.

Posted by kode54
Yes, jitter stacks. What, you thought they'd make up for it by returning to you *earlier* the next switch?

Posted by funkyass
Is all this running on a hard real time os?