Fix memory leaks and add warm-up step in fixture.c

Memory leaks were addressed with the following changes:
  - Valgrind inspection detected memory leaks, with 43,632 bytes lost
    across 909 blocks per test.
  - Investigation revealed that the initialization function was called
    multiple times in the testing loop, reallocating the context array
    without freeing prior allocations.
  - The initialization is now executed only once, and memory is released
    when testing ends, eliminating the leaks.

The measurement function was modified to include a warm-up step that
discards the first batch of data. Key observations and decisions are:
  - Tests were conducted using queue insertion and removal functions to
    verify constant-time behavior, showing no notable difference with or
    without the warm-up step.
  - The dudect paper notes potential timing variations that may impact
    t-test results, such as cache misses or allocation delays.
  - This step is retained to improve t-test precision in future tests,
    ensuring alignment with the paper's recommended methodology.

Change-Id: I34b257c2ae545c7c28c0c0be60e43988efc8158d

Author: HeatCrab

dudect/fixture.c

@@ -177,6 +177,17 @@ static bool report(void)
     return true;
 }
 
+static void init_once(void)
+{
+    init_dut();
+    for (size_t i = 0; i < DUDECT_TESTS; i++) {
+        if (!ctxs[i]) {  // Avoid repeated allocation
+            ctxs[i] = malloc(sizeof(t_context_t));
+            t_init(ctxs[i]);
+        }
+    }
+}
+
 static bool doit(int mode)
 {
     int64_t *before_ticks = calloc(N_MEASURES + 1, sizeof(int64_t));
@@ -187,17 +198,25 @@ static bool doit(int mode)
     int64_t *percentiles = calloc(NUM_PERCENTILES, sizeof(int64_t));
 
     if (!before_ticks || !after_ticks || !exec_times || !classes ||
-        !input_data) {
+        !input_data || !percentiles) {
         die();
     }
 
     prepare_inputs(input_data, classes);
 
     bool ret = measure(before_ticks, after_ticks, input_data, mode);
     differentiate(exec_times, before_ticks, after_ticks);
-    prepare_percentiles(exec_times, percentiles);
-    update_statistics(exec_times, classes, percentiles);
-    ret &= report();
+
+    static bool first_time = true;
+    if (first_time) {
+        prepare_percentiles(exec_times, percentiles);
+        first_time = false;
+        ret = true;  // Discard the first batch of data
+    } else {
+        prepare_percentiles(exec_times, percentiles);
+        update_statistics(exec_times, classes, percentiles);
+        ret &= report();
+    }
 
     free(before_ticks);
     free(after_ticks);
@@ -209,22 +228,14 @@ static bool doit(int mode)
     return ret;
 }
 
-static void init_once(void)
-{
-    init_dut();
-    for (size_t i = 0; i < DUDECT_TESTS; i++) {
-        ctxs[i] = malloc(sizeof(t_context_t));
-        t_init(ctxs[i]);
-    }
-}
-
 static bool test_const(char *text, int mode)
 {
     bool result = false;
 
+    init_once();  // Initialize only once
+
     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_MEASURES - DROP_SIZE * 2) + 1;
              ++i)
             result = doit(mode);
@@ -235,6 +246,7 @@ static bool test_const(char *text, int mode)
 
     for (size_t i = 0; i < DUDECT_TESTS; i++) {
         free(ctxs[i]);
+        ctxs[i] = NULL;
     }
 
     return result;