Refine dudect

The consistency of the dudect source files is revised to adhere to the
coding style.

Author: jserv

dudect/constant.c

@@ -1,31 +1,18 @@
-#include "constant.h"
 #include <assert.h>
-#include <signal.h>
 #include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
+
+#include "constant.h"
 #include "cpucycles.h"
 #include "queue.h"
 #include "random.h"
 
-#define N_MEASURE 150
-
-/* Allow random number range from 0 to 65535 */
-const size_t chunk_size = 16;
-
-/* Number of measurements per test */
-const size_t n_measure = N_MEASURE;
-
-const int drop_size = 20;
-
 /* Maintain a queue independent from the qtest since
  * we do not want the test to affect the original functionality
  */
 static struct list_head *l = NULL;
 
-static char random_string[N_MEASURE][8];
+static char random_string[N_MEASURES][8];
 static int random_string_iter = 0;
 
 enum {
@@ -41,22 +28,22 @@ void init_dut(void)
     l = NULL;
 }
 
-char *get_random_string(void)
+static char *get_random_string(void)
 {
-    random_string_iter = (random_string_iter + 1) % N_MEASURE;
+    random_string_iter = (random_string_iter + 1) % N_MEASURES;
     return random_string[random_string_iter];
 }
 
 void prepare_inputs(uint8_t *input_data, uint8_t *classes)
 {
-    randombytes(input_data, n_measure * chunk_size);
-    for (size_t i = 0; i < n_measure; i++) {
+    randombytes(input_data, N_MEASURES * CHUNK_SIZE);
+    for (size_t i = 0; i < N_MEASURES; i++) {
         classes[i] = randombit();
         if (classes[i] == 0)
-            memset(input_data + (size_t) i * chunk_size, 0, chunk_size);
+            memset(input_data + (size_t) i * CHUNK_SIZE, 0, CHUNK_SIZE);
     }
 
-    for (size_t i = 0; i < N_MEASURE; ++i) {
+    for (size_t i = 0; i < N_MEASURES; ++i) {
         /* Generate random string */
         randombytes((uint8_t *) random_string[i], 7);
         random_string[i][7] = 0;
@@ -73,37 +60,37 @@ void measure(int64_t *before_ticks,
 
     switch (mode) {
     case test_insert_head:
-        for (size_t i = drop_size; i < n_measure - drop_size; i++) {
+        for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             char *s = get_random_string();
             dut_new();
             dut_insert_head(
                 get_random_string(),
-                *(uint16_t *) (input_data + i * chunk_size) % 10000);
+                *(uint16_t *) (input_data + i * CHUNK_SIZE) % 10000);
             before_ticks[i] = cpucycles();
             dut_insert_head(s, 1);
             after_ticks[i] = cpucycles();
             dut_free();
         }
         break;
     case test_insert_tail:
-        for (size_t i = drop_size; i < n_measure - drop_size; i++) {
+        for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             char *s = get_random_string();
             dut_new();
             dut_insert_head(
                 get_random_string(),
-                *(uint16_t *) (input_data + i * chunk_size) % 10000);
+                *(uint16_t *) (input_data + i * CHUNK_SIZE) % 10000);
             before_ticks[i] = cpucycles();
             dut_insert_tail(s, 1);
             after_ticks[i] = cpucycles();
             dut_free();
         }
         break;
     case test_remove_head:
-        for (size_t i = drop_size; i < n_measure - drop_size; i++) {
+        for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             dut_new();
             dut_insert_head(
                 get_random_string(),
-                *(uint16_t *) (input_data + i * chunk_size) % 10000);
+                *(uint16_t *) (input_data + i * CHUNK_SIZE) % 10000);
             before_ticks[i] = cpucycles();
             element_t *e = q_remove_head(l, NULL, 0);
             after_ticks[i] = cpucycles();
@@ -113,11 +100,11 @@ void measure(int64_t *before_ticks,
         }
         break;
     case test_remove_tail:
-        for (size_t i = drop_size; i < n_measure - drop_size; i++) {
+        for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             dut_new();
             dut_insert_head(
                 get_random_string(),
-                *(uint16_t *) (input_data + i * chunk_size) % 10000);
+                *(uint16_t *) (input_data + i * CHUNK_SIZE) % 10000);
             before_ticks[i] = cpucycles();
             element_t *e = q_remove_tail(l, NULL, 0);
             after_ticks[i] = cpucycles();
@@ -127,11 +114,11 @@ void measure(int64_t *before_ticks,
         }
         break;
     default:
-        for (size_t i = drop_size; i < n_measure - drop_size; i++) {
+        for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             dut_new();
             dut_insert_head(
                 get_random_string(),
-                *(uint16_t *) (input_data + i * chunk_size) % 10000);
+                *(uint16_t *) (input_data + i * CHUNK_SIZE) % 10000);
             before_ticks[i] = cpucycles();
             dut_size(1);
             after_ticks[i] = cpucycles();

dudect/constant.h

@@ -2,6 +2,15 @@
 #define DUDECT_CONSTANT_H
 
 #include <stdint.h>
+
+/* Number of measurements per test */
+#define N_MEASURES 150
+
+/* Allow random number range from 0 to 65535 */
+#define CHUNK_SIZE 16
+
+#define DROP_SIZE 20
+
 #define dut_new() ((void) (l = q_new()))
 
 #define dut_size(n)                                \

dudect/cpucycles.h

@@ -1,4 +1,8 @@
+#ifndef DUDECT_CPUCYCLES_H
+#define DUDECT_CPUCYCLES_H
+
 #include <stdint.h>
+
 // http://www.intel.com/content/www/us/en/embedded/training/ia-32-ia-64-benchmark-code-execution-paper.html
 static inline int64_t cpucycles(void)
 {
@@ -21,3 +25,5 @@ static inline int64_t cpucycles(void)
 #error Unsupported Architecture
 #endif
 }
+
+#endif

dudect/fixture.c

@@ -26,24 +26,23 @@
  *    variable time.
  */
 
-#include "fixture.h"
 #include <assert.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "../console.h"
 #include "../random.h"
+
 #include "constant.h"
+#include "fixture.h"
 #include "ttest.h"
 
-#define enough_measure 10000
-#define test_tries 10
+#define ENOUGH_MEASURE 10000
+#define TEST_TRIES 10
 
-extern const int drop_size;
-extern const size_t chunk_size;
-extern const size_t n_measure;
 static t_context_t *t;
 
 /* threshold values for Welch's t-test */
@@ -61,13 +60,13 @@ static void differentiate(int64_t *exec_times,
                           const int64_t *before_ticks,
                           const int64_t *after_ticks)
 {
-    for (size_t i = 0; i < n_measure; i++)
+    for (size_t i = 0; i < N_MEASURES; i++)
         exec_times[i] = after_ticks[i] - before_ticks[i];
 }
 
 static void update_statistics(const int64_t *exec_times, uint8_t *classes)
 {
-    for (size_t i = 0; i < n_measure; i++) {
+    for (size_t i = 0; i < N_MEASURES; i++) {
         int64_t difference = exec_times[i];
         /* CPU cycle counter overflowed or dropped measurement */
         if (difference <= 0)
@@ -86,9 +85,9 @@ static bool report(void)
 
     printf("\033[A\033[2K");
     printf("meas: %7.2lf M, ", (number_traces_max_t / 1e6));
-    if (number_traces_max_t < enough_measure) {
+    if (number_traces_max_t < ENOUGH_MEASURE) {
         printf("not enough measurements (%.0f still to go).\n",
-               enough_measure - number_traces_max_t);
+               ENOUGH_MEASURE - number_traces_max_t);
         return false;
     }
 
@@ -119,11 +118,11 @@ static bool report(void)
 
 static bool doit(int mode)
 {
-    int64_t *before_ticks = calloc(n_measure + 1, sizeof(int64_t));
-    int64_t *after_ticks = calloc(n_measure + 1, sizeof(int64_t));
-    int64_t *exec_times = calloc(n_measure, sizeof(int64_t));
-    uint8_t *classes = calloc(n_measure, sizeof(uint8_t));
-    uint8_t *input_data = calloc(n_measure * chunk_size, sizeof(uint8_t));
+    int64_t *before_ticks = calloc(N_MEASURES + 1, sizeof(int64_t));
+    int64_t *after_ticks = calloc(N_MEASURES + 1, sizeof(int64_t));
+    int64_t *exec_times = calloc(N_MEASURES, sizeof(int64_t));
+    uint8_t *classes = calloc(N_MEASURES, sizeof(uint8_t));
+    uint8_t *input_data = calloc(N_MEASURES * CHUNK_SIZE, sizeof(uint8_t));
 
     if (!before_ticks || !after_ticks || !exec_times || !classes ||
         !input_data) {
@@ -152,19 +151,19 @@ static void init_once(void)
     t_init(t);
 }
 
-static bool TEST_CONST(char *text, int mode)
+static bool test_const(char *text, int mode)
 {
     bool result = false;
     t = malloc(sizeof(t_context_t));
 
-    for (int cnt = 0; cnt < test_tries; ++cnt) {
-        printf("Testing %s...(%d/%d)\n\n", text, cnt, test_tries);
+    for (int cnt = 0; cnt < TEST_TRIES; ++cnt) {
+        printf("Testing %s...(%d/%d)\n\n", text, cnt, TEST_TRIES);
         init_once();
-        for (int i = 0; i < enough_measure / (n_measure - drop_size * 2) + 1;
+        for (int i = 0; i < ENOUGH_MEASURE / (N_MEASURES - DROP_SIZE * 2) + 1;
              ++i)
             result = doit(mode);
         printf("\033[A\033[2K\033[A\033[2K");
-        if (result == true)
+        if (result)
             break;
     }
     free(t);
@@ -173,20 +172,20 @@ static bool TEST_CONST(char *text, int mode)
 
 bool is_insert_head_const(void)
 {
-    return TEST_CONST("insert_head", 0);
+    return test_const("insert_head", 0);
 }
 
 bool is_insert_tail_const(void)
 {
-    return TEST_CONST("insert_tail", 1);
+    return test_const("insert_tail", 1);
 }
 
 bool is_remove_head_const(void)
 {
-    return TEST_CONST("remove_head", 2);
+    return test_const("remove_head", 2);
 }
 
 bool is_remove_tail_const(void)
 {
-    return TEST_CONST("remove_tail", 3);
+    return test_const("remove_tail", 3);
 }

dudect/ttest.c

@@ -8,12 +8,11 @@
  * See https://en.wikipedia.org/wiki/Welch%27s_t-test
  */
 
-#include "ttest.h"
 #include <assert.h>
 #include <math.h>
 #include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
+
+#include "ttest.h"
 
 void t_push(t_context_t *ctx, double x, uint8_t class)
 {

dudect/ttest.h

@@ -2,6 +2,7 @@
 #define DUDECT_TTEST_H
 
 #include <stdint.h>
+
 typedef struct {
     double mean[2];
     double m2[2];