Here is a complete sample program
/************************************************** *************************
* Copyright (C) 2009 by Geoffrey McRae *
* geoff@rabidhost.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
************************************************** *************************/
/*
* This program is a working example of getting the high resolution time
* using a thread locked to a single core to avoid the time going backwards
* on SMP systems
*/
#define _GNU_SOURCE
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
pthread_cond_t thread_time_cond1 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t thread_time_mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t thread_time_cond2 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t thread_time_mutex2 = PTHREAD_MUTEX_INITIALIZER;
struct timespec *thread_time_data;
clockid_t thread_time_clk_id;
int thread_time_ret;
void* thread_time_func(void *data) {
/* Set our affinity to one core so the time never goes backwards */
unsigned long mask = 1;
pthread_setaffinity_np(pthread_self(), sizeof(mask), (cpu_set_t*)&mask);
/* Lock the primary mutex for our condition */
pthread_mutex_lock(&thread_time_mutex1);
while(1) {
/* Wait until someone wants the current time */
pthread_cond_wait(&thread_time_cond1, &thread_time_mutex1);
thread_time_ret = clock_gettime(thread_time_clk_id, thread_time_data);
/* Lock the 2nd mutex, signal the 2nd cond, and unlock */
pthread_mutex_lock(&thread_time_mutex2);
pthread_cond_signal(&thread_time_cond2);
pthread_mutex_unlock(&thread_time_mutex2);
}
pthread_exit(NULL);
return NULL;
}
int clock_gettime_core(clockid_t clk_id, struct timespec *tp) {
int ret;
/* Lock the mutex so we dont change things in the thread mid stride */
pthread_mutex_lock(&thread_time_mutex1);
thread_time_clk_id = clk_id;
thread_time_data = tp;
/* Signal the thread to run */
pthread_mutex_lock(&thread_time_mutex2);
pthread_cond_signal(&thread_time_cond1);
pthread_mutex_unlock(&thread_time_mutex1);
/* Wait for the thread to tell us our data is ready */
pthread_cond_wait(&thread_time_cond2, &thread_time_mutex2);
ret = thread_time_ret;
/* Finally unlock the mutex so this function can be called again */
pthread_mutex_unlock(&thread_time_mutex2);
return ret;
}
pthread_mutex_t thread_test_mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned long long old;
unsigned long long cur;
void* test_thread(void *data) {
struct timespec ts;
while(1) {
pthread_mutex_lock(&thread_test_mutex);
clock_gettime_core(CLOCK_REALTIME, &ts);
cur = ((unsigned long long)ts.tv_sec * 1000000000L) + ts.tv_nsec;
if (cur < old) printf("Time went backwards. diff = %qu, cur = %qu\n", ((unsigned long long)old - cur), cur);
/* Print out the time every second to show that we have not deadlocked */
if ((cur / 1000000000L) != (old / 1000000000L))
printf("Sec: %lld\n", cur);
old = cur;
pthread_mutex_unlock(&thread_test_mutex);
}
pthread_exit(NULL);
return NULL;
}
int main(int argc, char **argv) {
pthread_attr_t thread_attr;
pthread_t thread_time;
/* Create the time thread */
pthread_attr_init(&thread_attr);
pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
pthread_create(&thread_time, &thread_attr, thread_time_func, NULL);
/* Create the test threads */
old = 0;
pthread_t thread_test;
pthread_create(&thread_test, NULL, test_thread, NULL);
pthread_create(&thread_test, NULL, test_thread, NULL);
pthread_join(thread_test, NULL);
return 0;
}
Compile with:
gcc clock.c -o clock -lrt -lpthread
In theory you could remove the pthread_setaffinity_np call as the same thread will be always used to query the time, however if the CPU scheduler decides to move the thread to another core, the time may jump backwards.