Clean code and add back max clock resolution measure

.gitignore

@@ -3,3 +3,6 @@
 simple-server/build/main
 simple-client/build/main
 latency-measure/build/main
+latency-measure/build/main
+clock-res/build/clockres
+clock-res/build/clockres_arm

clock-res/build/Makefile

@@ -33,6 +33,6 @@ run: $(PROG)
 	./$^
 
 clean:
-	$(RM) $(OBJS) $(PROG) $(subst .c,.d,$(SRCS))
+	$(RM) $(OBJS) $(PROG) $(ARM_PROG) $(subst .c,.d,$(SRCS))
 
 .PHONY: clean FORCE

clock-res/src/clockres.c

 #include <errno.h>
 #include <error.h>
-#include <inttypes.h>
 #include <pthread.h>
 #include <sched.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
+#include <stdint.h>
+#include <inttypes.h>
 
 #define CLOCK_ID CLOCK_MONOTONIC
 #define NSEC_PER_SEC INT64_C(1000000000)
 
 typedef struct thread_stat {
   int nb_cycles;
-  int64_t max_res;
-  int64_t min_res;
+  uint64_t max_res;
+  uint64_t min_res;
 } thread_stat_t;
 
 typedef struct thread_param {
   int priority;
   int max_cycles;
-  int64_t interval;
+  uint64_t interval;
   thread_stat_t stat;
 } thread_param_t;
 
@@ -30,120 +30,94 @@ typedef struct main_param {
   int refresh_rate;
 } main_param_t;
 
-static inline int64_t calcdiff_ns(struct timespec t1, struct timespec t2)
-{
-	int64_t diff;
-	diff = NSEC_PER_SEC * (int64_t)((int) t1.tv_sec - (int) t2.tv_sec);
-	diff += ((int) t1.tv_nsec - (int) t2.tv_nsec);
-	return diff;
-}
+static void process_options(int argc, char *argv[], thread_param_t * param, main_param_t * main_param);
+
+static inline uint64_t calcdiff_ns(struct timespec t1, struct timespec t2);
+static inline uint64_t max(uint64_t a, uint64_t b);
+static inline uint64_t min(uint64_t a, uint64_t b);
 
-static inline int64_t max(int64_t a, int64_t b) { return a > b ? a : b; }
-static inline int64_t min(int64_t a, int64_t b) { return a < b ? a : b; }
+// Real-time thread
+static void *timerthread(void *p) {
 
-// Code from cyclictest
-void compute_resolution() {
-  int clock;
+  struct timespec previous, current;
+  struct sched_param priority;
   uint64_t diff;
-  int k;
-  uint64_t min_non_zero_diff = UINT64_MAX;
-  struct timespec now;
-  struct timespec prev;
-  struct timespec *time;
-  int times;
-
-  clock = CLOCK_ID;
-
-  /*
-   * Calculate how many calls to clock_gettime are needed.
-   * Then call it that many times.
-   * Goal is to collect timestamps for ~ 0.001 sec.
-   * This will reliably capture resolution <= 500 usec.
-   */
-  times = 1000;
-  clock_gettime(clock, &prev);
-  for (k = 0; k < times; k++) {
-    clock_gettime(clock, &now);
-  }
 
-  diff = calcdiff_ns(now, prev);
-  if (diff == 0) {
-    /*
-     * No clock rollover occurred.
-     * Use the default value for times.
-     */
-    times = -1;
-  } else {
-    int call_time;
-    call_time = diff / times;         /* duration 1 call */
-    times = NSEC_PER_SEC / call_time; /* calls per second */
-    times /= 1000;                    /* calls per msec */
-    if (times < 1000) times = 1000;
-  }
-  /* sanity check */
-  if ((times <= 0) || (times > 100000)) times = 100000;
+  thread_param_t * param = (thread_param_t *)p;
+  thread_stat_t * stat = &param->stat;
 
-  time = calloc(times, sizeof(*time));
+  priority.sched_priority = param->priority;
 
-  for (k = 0; k < times; k++) {
-    clock_gettime(clock, &time[k]);
-  }
+  if (sched_setscheduler(0, SCHED_FIFO, &priority))
+    error(EXIT_FAILURE, errno, "Couldn't set priority");
 
-  prev = time[0];
-  for (k = 1; k < times; k++) {
-    diff = calcdiff_ns(time[k], prev);
-    prev = time[k];
+  stat->max_res = 0;
+  stat->min_res = UINT64_MAX;
 
-    if (diff && (diff < min_non_zero_diff)) {
-      min_non_zero_diff = diff;
-    }
-  }
+  for(stat->nb_cycles = 0;; stat->nb_cycles++) {
+
+    if(param->max_cycles && (stat->nb_cycles >= param->max_cycles))
+      break;
+
+    clock_gettime(CLOCK_ID, &previous);
+    clock_gettime(CLOCK_ID, &current);
 
-  free(time);
+    diff = calcdiff_ns(current, previous);
 
-  printf("measured clock resolution approximately: %llu nsec\n",
-         (unsigned long long)min_non_zero_diff);
+    stat->max_res = max(stat->max_res, diff);
+    stat->min_res = min(stat->min_res, diff);
+
+    usleep(param->interval);
+  }
+
+  return NULL;
 }
 
-// Real-time thread
-// Sends packets at a regular intervall
-static void *timerthread(void *p) {
-  struct sched_param priority;
+// Main thread, has non-real time priority
+// Handles the IO and creates real time threads
+int main(int argc, char *argv[]) {
 
-  thread_param_t *param = (thread_param_t *)p;
-  thread_stat_t *stat = &param->stat;
+  pthread_t thread;
+  thread_param_t param;
+  main_param_t main_param;
 
-  priority.sched_priority = param->priority;
+  // Default values
+  param.interval= 1000;
+  param.max_cycles = 100000;
+  param.priority = 99;
+  main_param.refresh_rate = 10000;
 
-  int err = sched_setscheduler(0, SCHED_FIFO, &priority);
+  process_options(argc, argv, &param, &main_param);
 
-  if (err) error(EXIT_FAILURE, errno, "Couldn't set priority");
+  usleep(10000);
 
-  stat->max_res = 0;
-  stat->min_res = 1000000;
+  if(pthread_create(&thread, NULL, timerthread, (void *)&param))
+    error(EXIT_FAILURE, errno, "Couldn't create thread");
 
-  for (stat->nb_cycles = 0;; stat->nb_cycles++) {
-    if (param->max_cycles)
-      if (stat->nb_cycles >= param->max_cycles) break;
+  for (;;) {
 
-    compute_resolution();
+    usleep(main_param.refresh_rate);
 
-    usleep(param->interval);
-  }
+    printf("Maximum res: %" PRIu64 "ns (%d)", (param.stat.max_res), param.stat.nb_cycles);
+    printf(", minimum res: %" PRIu64 "ns (%d)\n", (param.stat.min_res), param.stat.nb_cycles);
 
-  printf("Done\n");
+    if( param.max_cycles == param.stat.nb_cycles )
+      break;
+  }
 
-  return NULL;
+  exit(EXIT_SUCCESS);
 }
 
-static void process_options(int argc, char *argv[], thread_param_t *param,
-                            main_param_t *main_param) {
-  for (;;) {
+static void process_options(int argc, char *argv[], thread_param_t * param, main_param_t * main_param) {
+
+  for(;;) {
+
     int c = getopt(argc, argv, "l:p:i:r:");
 
-    if (c == -1) break;
+    if(c == -1)
+      break;
 
-    switch (c) {
+    switch(c) {
     case 'p':
       param->priority = atoi(optarg);
       break;
@@ -163,35 +137,17 @@ static void process_options(int argc, char *argv[], thread_param_t *param,
   }
 }
 
+static inline uint64_t calcdiff_ns(struct timespec t1, struct timespec t2)
+{
+	uint64_t diff;
+	diff = NSEC_PER_SEC * (uint64_t)((int) t1.tv_sec - (int) t2.tv_sec);
+	diff += ((int) t1.tv_nsec - (int) t2.tv_nsec);
+	return diff;
+}
 
-// Main thread, has non-real time priority
-// Handles the IO and creates real time threads
-int main(int argc, char *argv[]) {
-  pthread_t thread;
-  thread_param_t param;
-  main_param_t main_param;
-  int err;
-
-  // Default values
-  param.interval = 100;
-  param.max_cycles = 100000;
-  param.priority = 99;
-
-  main_param.refresh_rate = 10000;
-
-  process_options(argc, argv, &param, &main_param);
-
-  usleep(10000);
-
-  err = pthread_create(&thread, NULL, timerthread, (void *)&param);
-
-  if (err) error(EXIT_FAILURE, errno, "Couldn't create thread");
-
-  for (;;) {
-    usleep(main_param.refresh_rate);
-
-    if (param.max_cycles == param.stat.nb_cycles) break;
-  }
-
-  exit(EXIT_SUCCESS);
+static inline uint64_t max(uint64_t a, uint64_t b) {
+  return a > b ? a : b;
+}
+static inline uint64_t min(uint64_t a, uint64_t b) {
+  return a < b ? a : b;
 }